Laliluna Clojure, Java, Architecture articles

Setting up a Clojure Project in 2017

2017-12-17T00:00:00Z

Setting up a Clojure project in 2017

The challenge

After at least two year of Clojure abstince, I explored libraries for an application exposing REST services. The system design is trival, a database and a couple of REST services exposing the data in various forms.

The surprise

The Clojure world seems to undergo a phase of library consolidation. After years of heavily exploring new approaches, some libraries are successful while many projects are actually dead.

This is not something bad. In my option it is a consequence of developers with background in other languages carried over concepts just to find out that it is actually not needed.

SQL

I explored libraries to interact with relation databases and I found that Korma, which I used in the past, is getting little community attention. So I explored available options

None of those felt like the perfect choice. After reading http://clojure-doc.org/articles/ecosystem/java_jdbc/home.html and http://peterstratton.com/posts-output/2017-01-28-postgres-and-clojure-using-clojure-java-jdbc the need for a library was actually questioned at all. Clojure JDBC has a light abstraction for inserts and updates. In addition it provides options to convert column names when reading and writing. It took 1 hour to write a small abstraction to convert our camelcase to nicer Clojure keywords. Consequently, there is a good chance that a library is not needed at all. We will see if we stay with core Clojure on the long term but currently it is a simple way to interact with a DB.

To have slightly better support for dynamic queries, we are exploring Honeysql as an addition. Many of the named libraries are much more powerful than HoneySQL, but as long as there is no need for more advanced stuff, why add complexity

REST

Exploring REST libraries is trivial as there are many good options. I looked at

Yada
Pedestal with Rook
Liberator
Compojure only

Compojure is still an option but I found that the REST libraries are mature and simple. For this time, I went with Liberator as it works nicely with Compojure which I have some experience with.

Module system

A module system allows to define modules and dependencies between them. You can start your system and all modules are started depending on their relation and order. A module might read configuration files, another one connect to the DB, start scheduler for cron jobs etc. I liked tolituis/mount. Integrant is a new candidate with nice concepts but it relies on a very fresh Clojure version. For know I postponed using a module system at all, because currently the complexity is not needed. If you are interested, here are some options

Testing

I used Midje in the past and had a look at alternatives.

Plain clojure test with aviso pretty to nicely show test results.
Expectations with lein-test-refresh to execute tests automatically
Midje in combination with lein midje

First, all solutions are good solutions. Test failures are very clear and precise. Java please have a look. ;-)

I compared the test runners. Basically, they execute the tests if a test or code is modified. After saving your file, you can see the results in fractions of a second. If you are into TDD this is a productiviy turbo boost.

Expectations

Tests written in Java are verbose, tests written in Clojure are way more conside and small, but this library pushes it to an extreme that is very impressive. If too much code is an issue, have a look at it. The latest versions integrate nicely with standard Clojure test runners as well. It is really worth looking at it.

Aviso

Use it to improve test output with standard clojure test significantly

Midje

Nice and powerful assertions
Good support for mocks and pre/post executed code
Asserts do not look like very “Clojure style”
Very efficient execution of only relevant tests on code change

The impressive thing of the lein midje :autotest is that it only executes, depending on what you change, the modified test or all tests refering the modified code. This is amazing.

In this case the test execution was the argument to prefer Midje over the other options.

Other stuff

I stumbled upon libraries while looking for security and scheduler. I did not explore them in detail, but the first impression was nice, so I decided to note them here.

Security: https://funcool.github.io/buddy-auth/latest

Scheduler (Later): http://docs.caudate.me/hara/hara-io-scheduler.html

Summary

The first version of the software is ready by now and there is one thing I appreciate a lot using Clojure: simplicity

Here is what we achieved

Read configuration file from Tomcat data directory or fall back to a configuration in the classpath based on an environment test or development
Logger integration using an external configuration or as fall back a configuration in the classpath
Scheduler integration
Connection pools
No connection pool for import job
Tests for REST services, database and unit tests

In other projects, I use technologies like Java, JEE, Spring, Java Persistence/Hibernate. If you have experience setting up a customized Spring configuration, you probably have an idea what complexity is. It requires days of dedication to have a Spring application with mixed security for legacy and REST services nicely in place. But still at the point it works, you do not understand all pieces. Java libraries have a strong tendency to support old approaches they offered once. The downside is if you solve a problem, you find documentation using one approach, another or a mixture of many.

Given my basic Clojure experience, I was impressed how quick everything was in place.

When it comes to simplicity, Clojure rocks.

Best Regards / Viele Grüße

Sebastian Hennebrueder

An Angular template for Java and Clojure REST services

2014-12-12T00:00:00Z

Introduction

I created a clean and lean template for AngularJS development, which allows to easily plugin a Java or Clojure backend.

It includes

Module based structure for GUI
Test automation: GUI unit and end to end tests
Bootstrap and font awesome
Sass stylesheets
Live reload for GUI and Clojure backend

It is published under Apache License.

https://github.com/laliluna/angular-rest-seed

Best Regards / Viele Grüße

Sebastian Hennebrueder

Understanding JavaScript GUI builds for Java and Clojure developer

2014-09-05T00:00:00Z

Introduction

Imagine you want to build an application with a Java or Clojure backend, exposing services via REST. The services are consumed by a JavaScript application using AngularJS.

In article, I summarize the experience I made to develop, test, build and release applications with mixed technologies. I will give you an introduction into JavaScript tooling and share my experience how to integrate the GUI with a Java or Clojure backend.

JavaScript build tool ecosystem

The JavaScript ecosystem is amazing. You will find well designed tools, each one with a defined but limited responsibility, which allows to combine them into powerful tool chains. It is enlightening coming from a Java Maven background. The Java world has a tendency to create things like ‘the coffee making, water distributing, ice machine, soap bubble making bicycle’.

Task runner

A task runner can execute tasks, define dependencies between them, run them in parallel or sequential but very important they don’t know much about the tasks themselves. Gulp Grunt and Brunch fall into this category.

Combined with plugins the task runner can do anything you need to do with a JavaScript web application.

Here is an extract of a task definition using Gulp. It compiles Sass style sheets into normal CSS and send a desktop notification, if it succeeds or fails.

	// load plugins
	var gulp = require('gulp'),
    	minifycss = require('gulp-minify-css'),
    	notify = require('gulp-notify'),
    	source = require('vinyl-source-stream'),
    	streamify = require('gulp-streamify'),
    	uglify = require('gulp-uglify'),
    	sass = require('gulp-ruby-sass');

	// define a task	
	gulp.task('styles-sass', function () {
	    return gulp.src(paths.styles_sass)
	            .pipe(sass({ style: 'expanded' }))
	            .on("error", notify.onError(function (error) {
	                return "CSS problem: " + error.message;
	            }))
	            .pipe(gulp.dest('dist/dev/styles'))
	            .pipe(notify({ message: 'Saas styles task complete' }));
	});

A typical JavaScript build file consists of small tasks. Whenever you need to achieve something, just search for a plugin using something like “Grunt minify CSS” or “Gulp compress JavaScript”.

To describe the three task executors shortly: Grunt has the largest plugin collection, Gulp is more efficient has it uses pipes to pass the output from one step into the next, Brunch is the youngest and makes heavy use of conventions over configurations, which makes it very easy to setup but on the other hand sometimes harder to understand and to adapt. After trying out each of them, I choose Gulp. But this is a matter of personal preferences. Each tool has its shiny sites.

Dependency management

The Maven or Clojars equivalent in the JavaScript world are NPM and Bower. Both help dealing with fetching dependencies. NPM provides dependencies in a format suitable for JavaScript backend application. Combined with a tool like Browserify which packs the dependency into a single file, it can be used for JavaScript in the browser as well. Bower is already intended to be used with Browser applications. Both are viable solutions.

You will probably always use NPM to install all other tools needed for development.

Writing JavaScript modules is not trivial, as you need to target both NPM and Bower. It is worth to invest some time understanding how they work. Especially in larger GUI applications you need a form of modularization to avoid naming conflicts.

Scaffolding

There is a good chance that you run into Yeoman as well. It helps to quickly start building a JavaScript application. If you want to have an AngularJS application including build script, test runner and an application template, just type:

yeoman init angular

Alternatively, there is large choice of boilerplate tempates.

Development

For development there is a list of typical tasks for a JavaScript application.

Quality check the JavaScript code using JSHint or JSLint
Package all required libraries
Concatenate all your JavaScript code
Transform your Saas or LESS style sheets into normal CSS
Copy fonts, HTML files and images
Execute unit and end to end tests
Automatically reload the browser if anything has changed

All this can be achieved with plugins for Gulp, Grunt or Brunch. The automated test execution, reloading and quality check are very useful. Every time you save a file, you get a feedback fractions of a second later.

To get an impression, how to configure such a build file, I found it helpful to develop it step by step from scratch and then compare it to existing solutions.

AngularJS template
Templates created by yeoman

Next thing is how to integrate the JavaScript GUI with a deployed Java or Clojure backend.

A very good way to achieve this is using a JavaScript web server with integrated proxy. It is a normal web server serving requests from a defined directory. In addition a URL like /api can be defined to be forwarded to a backend running under its own port.

Why not using backend tools to build the JavaScript application?

Gradle and even Maven has extensions to build JavaScript applications. The answer is simple. If you go swimming what do you pick: flippers or a bucket of heavy stones.

The JavaScript build tools are much more advanced, used by many more people and are very easy to adapt to your own needs.

Packaging for Production

For production CSS, JavaScript and libraries needs to be minimized. If the backend and the GUI is packaged as single application, the JavaScript application is copied into the web directories of the backend project.

In the past, I achieved this by adding a task to the Gulp or Grunt build. The reason, I am controlling this from the JavaScript and not the backend build script, is that the JavaScript task runners are way easier to adapt. Neither of tools like Maven or Gradle (Java world) or leiningen (Clojure world) is as flexible.

Releasing

Typical tasks to release a project are

run production build for backend and GUI
run tests
remove snapshot suffix for production release in backend and GUI
commit and tag version
upload application to a repository (Nexus etc)
bump up version in backend and GUI
commit with new version

I found this part a bit tricky. Releasing can be both controlled from the task runner and the backend build script or even a third script controlling both. I used the backend build script in the past to do the actual release, but triggered the JavaScript task runner before doing this from an outside script.

Summary

This overview should get you started easier in building mixed builds. Feel free to sent me comments with your own experiences.

Clojure Async - Kindergarden Party

2014-04-28T00:00:00Z

Clojure Async Channels: Kindergarden Party

Let’s learn about Clojure async channels by organizing a kindergarden party.

The parents bake cake and bring them to the event. Cake has to be cut in pieces, put on tables etc. Everybody is doing something to make it a nice event.

Preparation

Create a new leiningen project and update the project.clj to

(defproject sample "0.1.0-SNAPSHOT"
  :dependencies [[org.clojure/clojure "1.5.1"]
                 [org.clojure/core.async "REPLACE_THIS_WITH_THE_LATEST_VERSION_ON_http://clojure.github.io/core.async/"]
                 [org.jgroups/jgroups "3.4.4.Final"]])

Handing over a cake

Anne is preparing the table with the cakes. She takes a cake and puts it on a table.

Open a REPL session to execute the code.

(require '[clojure.core.async :refer :all])

Create a channel:

(def anne (chan))

Let Anne wait in the background:

(thread (println "Put" (<!! anne) "on the table"))

<!! reads from a channel and waits until something is put onto the channel.

A crib for me: The channel is !! and you send something to it >!! or read from it <!!

Pass the cake to the channel.

(>!! anne "Apple cake")

And we see:

Put Apple cake on the table

A channel is blocking. If you write to a channel, you will wait until a read from this channel happens.

Tuning our code a bit

Our code is not very efficient.

(thread (println "Put" (<!! anne) "on the table"))

This code created a thread waiting in the background. This blocks a JVM thread even if Anne is doing nothing. You can verify it by starting a jconsole.

To improve, we can use a go block. It runs in the background but releases the background thread when Anne is doing nothing. In a go block <! is used instead of <!!

(go (println "Put" (<! anne) "on the table"))

Next, let Anne take over the job for a while and simulate parents bringing a couple of cakes over time.

Anne:

(go (loop [cake (<! anne)]
       (if cake
          (do (println (str "Anne puts " cake " cake on the table"))
              (Thread/sleep 1000)
              (recur (<! anne)))
          (println (str "I, Anne go home")))))

Or a bit shorter:

(go-loop [cake (<! anne)]
	     (if cake
	         (do (println (str "Anne puts " cake " cake on the table"))
	             (Thread/sleep 1000)
	             (recur (<! anne)))
	         (println (str "I, Anne go home"))))

The parents:

(go (doseq [cake ["Apple" "Pineapple" "Chocolade" "Creme"]]
	    (println "About to deliver cake " cake)
	    (>! anne cake)
	    (Thread/sleep (rand-int 1000))))

A closed channel returns nil. If you close the channel, Anne is going home. :

(close! anne)

The problem we are facing is that parents are queuing up, as there are too many cakes. So we setup a small table where the parents can at least put 2 cakes, which are then taken by Anne. Basically, we create a buffered channel.

(def anne (chan 2))

Holger starts helping Anne now. So we introduce the small table as channel and both Anne and Holger fetch cake from it to place it on the tables.

(defn put-cake-on-the-table [name in-table]
	(go-loop [cake (<! in-table)]
	       (if cake
	         (do (println (str name " puts " cake " cake on the table"))
	             (Thread/sleep 1000)
	             (recur (<! in-table)))
	         (println (str "I," name " go home")))))
	
(def small-table (chan 2))
(put-cake-on-the-table "Anne" small-table)
(put-cake-on-the-table "Holger" small-table)

Let’s introduce a method for delivering cakes.

(defn deliver-some-cakes [table]
	(go (doseq [cake ["Apple" "Pineapple" "Chocolade" "Creme"]]
	    (println (str "About to deliver cake " cake))
	    (>! table cake)
	    (Thread/sleep (rand-int 1000)))))
	
(deliver-some-cakes small-table)

Splitting work

Anne and Holger are going to specialize. Anne takes only fruit cakes whereas Holger takes all other cakes.

We can achieve this using a splitter.

A cake is now a map: {:name “Apple” :type "fruit"}

First we enhance the put-cake-on-the-table and deliver-some-cake methods to work with a map.

(defn put-cake-on-the-table [name in-table]
	(go-loop [{cake :name} (<! in-table)]
	       (if cake
	         (do (println (str name " puts " cake " cake on the table"))
	             (Thread/sleep 2000)
	             (recur (<! in-table)))
	         (println (str "I," name " go home")))))
	
(defn deliver-some-cakes [in-table]
	(go (doseq [{:keys [name] :as cake} [{:name "Apple" :type "fruit"}
	                          {:name "Pineapple" :type "fruit"}
	                          {:name "Chocolade" :type "other"}
	                          {:name "Creme" :type "other"}]]
	    (println (str "About to deliver cake " name))
	    (>! in-table cake)
	    (println (str "Delivered cake " name))
	    (Thread/sleep (rand-int 1000)))))

Then we can split the work.

(def small-table (chan 2))
(let [[cake-for-anne cake-for-holger] (split #(= (:type %) "fruit") small-table)]
	(put-cake-on-the-table "Anne" cake-for-anne)
	(put-cake-on-the-table "Holger" cake-for-holger))
(deliver-some-cakes small-table)

Next Karl is going to help out. He is making small labels for every cake, before Anne and Holger put them on the tables.

(defn make-label [my-name in-table me]
	(go-loop [{name :name :as cake} (<! in-table)]
	       (if cake
	         (do (println (str my-name " makes label for " name))
	             (>! me cake)
	             (recur (<! in-table))))))

(def karl (chan))
(def small-table (chan 2))
(let [[cake-for-anne cake-for-holger] (split #(= (:type %) "fruit") karl)]
	(put-cake-on-the-table "Anne" cake-for-anne)
	(put-cake-on-the-table "Holger" cake-for-holger))
(make-label "Karl" small-table karl)
(deliver-some-cakes small-table)

Merging work

Judie has a nice hand writing and starts writing labels as well. Anne and Holger can now take cakes from both of them.

We can merge messages from two channels into one using merge.

(def karl (chan))
(def judie (chan))
(def small-table (chan 2))
(let [[cake-for-anne cake-for-holger] (split #(= (:type %) "fruit") 
(merge [karl judie]))]
	(put-cake-on-the-table "Anne" cake-for-anne)
	(put-cake-on-the-table "Holger" cake-for-holger))
(make-label "Karl" small-table karl)
(make-label "Judie" small-table judie)
(deliver-some-cakes small-table)

Alternating

As more and more cakes are delivered, the small entry table has not enough capacity. We set up a second table and ask Karl and Judie to take cakes from both tables.

If no cake is their, they just do nothing for a moment.

(defn make-label [my-name in-tables me]
	(go-loop [[{name :name :as cake} _] (alts! in-tables :default "nothing")]
	       (if cake
	         (do
	           (if (= cake "nothing")
	             (do (println "Do nothing for a moment")
	                 (Thread/sleep 500))
	             (do (println (str my-name " makes label for " name))
	                 (>! me cake)))
	           (recur (alts! in-tables :default "nothing")))
	         (println (str my-name " goes home")))))

(def karl (chan))
(def judie (chan))
(def small-table-1 (chan 2))
(def small-table-2 (chan 2))
(let [[cake-for-anne cake-for-holger] (split #(= (:type %) "fruit")
	                                         (merge [karl judie]))]
	(put-cake-on-the-table "Anne" cake-for-anne)
	(put-cake-on-the-table "Holger" cake-for-holger))
(make-label "Karl"  [small-table-1 small-table-2] karl)
(make-label "Judie" [small-table-1 small-table-2] judie)
(deliver-some-cakes small-table-1)

The function alts! alternates between a vector of channel. It none of the channel contains messages, it can block or fall back to a default value.

(alts! in-tables :default "nothing")

You can use alts! to write to different channels as well.

Timeout

Karl and Judie decide not wait for ever for cakes. If no cake is delivered for a long time, they go home.

This can be achieved by adding a timeout channel to the alts! function. It creates a channel which closes after the defined milliseconds. A closed channel returns nil.

The modified method looks like

(defn make-label [my-name in-tables me]
	(go-loop [[{name :name :as cake} _] (alts! (cons (timeout 5000) in-tables))]
		(if cake
	       (do (println (str my-name " makes label for " name))
	           (>! me cake)
	           (recur (alts! (cons (timeout 500) in-tables))))
	       (println (do (println (str my-name " does nothing for a moment"))
	                    (Thread/sleep 500))))))
							

(def karl (chan))
(def judie (chan))
(def small-table-1 (chan 2))
(def small-table-2 (chan 2))
(let [[cake-for-anne cake-for-holger] 
	(split #(= (:type %) "fruit") (merge [karl judie]))]
	(put-cake-on-the-table "Anne" cake-for-anne)
	(put-cake-on-the-table "Holger" cake-for-holger))
(make-label "Karl"  [small-table-1 small-table-2] karl)
(make-label "Judie" [small-table-1 small-table-2] judie)
(deliver-some-cakes small-table-1)

Network

If we need more computing power, we can start distributing the application across multiple computers. So we need a channel, which actually writes to a remote channel.

Let’s write a simple solution using reliable messaging via JGroups.

The basic usage pattern is to create a channel, connect to a cluster name, set a receiver to react on incoming messages and to use the channel to send messages.

Use the following to use the JGroups default configuration. It uses UDP multicast for node detection.

(def c (org.jgroups.JChannel.))

Or specify a customized configuration if you like.

(def c (org.jgroups.JChannel. (clojure.java.io/resource "jgroups.xml")))

(def r (reify org.jgroups.Receiver
         (receive [this msg]
           (println (.getObject msg) (.getSrc msg)))
         (viewAccepted [this view]
           (println view))))
(.setReceiver c r)
(.connect c "foo")
(.send c nil "hello")

If you struggle sending messages, have a look in the JGroups documentation. It has a trouble shooting section.

It is easier, to use JGroups messaging, if we provide a couple of utility classes. Let’s built a channel which sends messages to remote addresses and a receiver which passes
the message to a local channel.

Here is the source code.

(ns sample.jgroups-async
	(:import (org.jgroups Channel Address Receiver))
	(:require [clojure.core.async.impl.protocols :as protocols]
	      [clojure.core.async.impl.channels :as channels]
	      [clojure.core.async :refer [close! >!!]]))

clojure.core.async defines protocols. If you implement WritePort, then you can use your channel with the async API >!! to send messages.

(deftype JgroupsWriteChannel [^Channel jgroups-channel ^Address target-address]
	protocols/WritePort
	(protocols/put! [port val fn0-handler]
		(when (nil? val)
			(throw (IllegalArgumentException. "Can't put nil on Jgroups channel")))
			(.send jgroups-channel (org.jgroups.Message. target-address nil val))
			(channels/box nil))
	protocols/Channel
	(protocols/close! [chan]
		(.close jgroups-channel)))

A factory method bootstraps JGroups and creates instances of the JGroupsWriteChannel.

(defn create-write-channel [cluster-name target-address]
	(let [jc (org.jgroups.JChannel.)]
	(.setReceiver jc (reify Receiver
	                   (viewAccepted [this view]
	                     (println view))))
	(.connect jc cluster-name)
	(JgroupsWriteChannel. jc target-address)))

The receiver is composed of a JGroups channel and a async channel.

(deftype JgroupsReceiver [jgroups-channel local-channel]
	protocols/Channel
	(protocols/close! [chan]
	(.close jgroups-channel)
	(close! local-channel)))

A factory method bootstraps JGroups and creates instances of JgroupsReceiver.

(defn create-remote-receiver
	[cluster-name port]
	(let [jc (org.jgroups.JChannel.)]
		(.setReceiver jc (reify Receiver
	    	(receive [this msg] (>!! port (.getObject msg)))
        	(viewAccepted [this view] (println view))))
	(.connect jc cluster-name)
	(JgroupsReceiver. jc port)))

Let’s play with it.

(require '[clojure.core.async :refer :all])
(def anne (create-remote-receiver "foo" (chan)))
(def joe (create-write-channel "foo" (.getAddress(.jgroups_channel anne))))
(go-loop [m (<! (:local-channel anne))] 
	(if m (do (println "Anne " m)
		(recur (<! (:local-channel anne))))))

Now, we can send messages around

(>!! joe "Hello Anne")

Once you are done, close the JGroups cluster and the channels.

	
(doseq [c [anne joe]] (close! c))

As an exercise, try to split the cake preparation steps across two nodes.

Summary

If you ever wanted to parallelize processing in an application, Clojure async is a great tool set to achieve this. I hope you enjoyed the article.

Sebastian Hennebrueder

Beautiful Clojure - destructuring data

2013-10-29T00:00:00Z

Beautiful Clojure – Destructuring data

What is destructuring?

Destructuring is one of the beautiful features which impressed me, when learning Clojure. It helps you to assign individual elements of a vector/list or map to variables. You can destructure function parameters as well as return values.

A first example

Imagine a function which returns the age of the youngest and the oldest person in a sport club.

(defn find-min-max-age [club]
  (let [min-age (calculate-min-age club)
        max-age (calculate-max-age club)]
    [min-age max-age]))

The vector which is returned can be assigned directly to two variables: min and max.

(let [[min max] (find-min-max-age "Swim Club")]
  (println "Youngest member is " min)
  (println "Oldest member is " max))

I like this elegant approach a lot. It is much more compact as a comparable Java version, which requires additional code to deal with null values.

    Integer[] minMax = findMinMax("Swim Club");
    Integer min = minMax.length > 0 ? minMax[0] : null;
    Integer max = minMax.length > 1 ? minMax[1] : null;
    System.out.println("Youngest member is " + min);
    System.out.println("Oldest member is " + max);

More vector examples

You can destructure function parameters as well. It just works every where.

(defn find-team-member [[min max]] 
	(println min max))
	
; Calling the function
(find-team-member [5 20])

As well, you can ignore values. To ignore values at the end of the vector, just leave off the variables.

(let [[min] (find-min-max-age "Rugby Club")]
  (println "Youngest member is" min))

To ignore values at a specific place, just use _ as the variable name. It is a common convention.

(let [[_ max] (find-min-max-age "Kite Surfing Club")]
  (println "Oldest member is" max))

Destructuring maps

Clojure separates functions and data. Maps are frequently used to store data and they can be destructured as well.

The following function expects a map as parameter. It extracts the values for the keys min and max and assigns them to variable named min, max respectively.

(defn find-team-member[ {:keys [min max]} ] 
	(println min max))

; Let us use our function
(find-team-member {:min 5 :max 10})

The destructuring of a map is expressed as a map. What could be more concise?

If you need to get hold of the whole map, you can add a special key :as to the map.

(defn find-team-member[ {:keys [min max] :as all-data} ] 
	(println min max all-data))

; Let us use our function
(find-team-member {:min 5 :max 10 :foo "some value"})

Default values for maps

To specify default values for maps, just add a key :or and a map describing those values.

(defn find-team-member[ {:keys [min max] :or {min 3 max 20}}] 
	(println min max))

I hope you enjoyed the article.