An general purpose , pragmative, dynamic, functional variant of Lisp on top of JVM with concurrency and power in mind...

...Elegance and Simplicity Made Easy...

Power and Elegance...

• Simple in design, elegance in bloodline
• Functional Programming at its finest
• Extreme power, extensible even at syntax level
• Mother of all DSL
• Good for grokking AI
• If you can think of anything, in any way, Lisp can do it
• Futuristic features... since 1950s.

Do I really need to say anything here?

Let's not get into who uses it or what got created with JVM?

Unless you want to give me the whole session or more?

LISP + JVM = Clojure

Clojure brings the power of Lisp into the glory of JVM...

Sword on a Gun-fight?

Gun on a Sword Fight?

So How do I do this???

Keep it Simple, Stupid!!!

My to-do list...

• Discuss theories of functional programming
• Teach Clojure, along with its macro features, concurrency constructs, transducers, monads, lambda calculus
• Logical/Relational programming while at it
• Recreate ADA and FORTRAN with Clojure via live-coding
• Discuss theory of relativity
• Display round-house kicks
• Whet your appetite
• Talking some FP for OOP guys
• Discuss some simple ideas on how Clojure makes you think

Congratulations, you know Clojure (and probably all other Lisps)

Immutability

Functional Programming
Concurrency & Parallelism
Interoperability

People never change, they just become more of what they are

- Count Lestat, Interview with the Vampire

Immutability is...

Basically forgetting about assignments and those little boxes holding values, you play pillow passing with values, values that never change.

But it demands a special data structure to ensure fast operation on immutable data.

Lambda Calculus

• Fancy Name for function?
• Remember f(x) = x + 1; therefore f(10) = ?
• (fn [x] (+ x 1))
• #(* % %)
• (defn add-a-with-b #(+ %1 %2))
• I promise, I'm not swearing...
• yet.

Higher Order Functions

• Functions can take functions in
• Functions can return function bodies
• Also called Functor, Functional Form etc
• map, reduce, filter etc.

(map square (range 100))

(->> (range 1 100)
     (comp #(square %) #(cube %))
     (apply +))

Closures

• A data structure storing a function
• A function body that has its local variable snapshots remembered per call
• That's how Clojure got its name?

(defn pow [n]
   (fn [x] (apply * (repeat n x))))

(def square (pow 2))
(def qubic (pow 3))

Then there is partial function, laziness, sequence abstraction...

Concurrency is managing more than one task at the same time.

When you are texting and driving, you're being concurrent. (DON'T by the way)...

But you don't do them at the same time, you "interleave"

Paralellism is actually doing two tasks simultaneously.

Erm... writing with both hands? Can you?

If a task takes two hands, and you have two hands, you cannot do more than two tasks paralelly.

Know your enemies: 
Shared State

Clojure and Concurrency

• Futures and Promises
• Atom
• Ref
• Var
• Agents
• core.async

State Management

• Refs are for Coordinated Synchronous access to "Many Identities".
• Atoms are for Uncoordinated synchronous access to a single Identity.
• Agents are for Uncoordinated asynchronous access to a single Identity.
• Vars are for thread local isolated identities with a shared default value.

Ref - STM

• Software Transactional Memory
• Similar to ACID (From Database Theory) sans D
• All actions in a "ref" are atomic, either one or none
• Automatic retry on failures
• Operations: ref-set, alter, commute

(def accounts 
 [(ref 0) 
  (ref 10) 
  (ref 20) 
  (ref 30)])

(defn transfer [src-account 
                dest-account 
                amount]
  (dosync
    (alter dest-account + amount)
    (alter src-account - amount)))

(map deref accounts)
;=> (5 5 20 30)

Now the most awesome... core.async

var p_client = new Db('integration_tests_20', new Server("127.0.0.1", 27017, {}), 
                                                         {'pk':CustomPKFactory});
p_client.open(function(err, p_client) {
    p_client.dropDatabase(function(err, done) {
        p_client.createCollection('test_custom_key', function(err, collection) {
            collection.insert({'a':1}, function(err, docs) {
                collection.find({'_id':new ObjectID("aaaaaaaaaaaa")}, function(err, cursor) {
                    cursor.toArray(function(err, items) {
                        test.assertEquals(1, items.length);
​
                        // Let's close the db​
                        p_client.close();
                    });
                });
            });
        });
    });
});

... Now I have two problems... intertwined ;-)

(defn upper-caser
  [in]
  (let [out (chan)]
    (go (while true (>! out (clojure.string/upper-case (<! in)))))
    out))

(defn reverser
  [in]
  (let [out (chan)]
    (go (while true (>! out (clojure.string/reverse (<! in)))))
    out))

(defn printer
  [in]
  (go (while true (println (<! in)))))

(def in-chan (chan))
(def upper-caser-out (upper-caser in-chan))
(def reverser-out (reverser upper-caser-out))
(printer reverser-out)

(>!! in-chan "redrum")
; => MURDER

(>!! in-chan "repaid")
; => DIAPER

Credits: Clojure for the Brave and True

Because you don't want to miss out on the decades of Java.

This is actually simple...

(Integer/parseInt "0")
;; Integer.parseInt("0")
(.toUpperCase "hello")
;; "hello".toUpperCase()
(.. System 
    (getProperties) 
    (get "os.name"))
;; System.getProperties().get("os.name")
(doto (new java.util.HashMap) 
      (.put "a" 1) 
      (.put "b" 2))
; HashMap hm = new HashMap();
; hm.put("a", 1);
; hm.put("b", 1);

Top-Down Approach

• Think how you want to see your solution
• Type the outcome
• Start Implementing...
• Remember, you can bend your syntax at will

(def-html page [title, body]
  (title title)
  (body (div (map employee-snippet employee-list))))

(def-snippet employee-snippet [e]
  (table :data (employees) :class "alternate-row"))

(def-form employee-form
  (html-form :map-with (get-employee-structure) 
             :on-click create-employee!))

(defn employee-list 
  (sql
    (select "employee" [:first-name :last-name] :order-by "age")))

(defn create-employee!
  (sql! 
    (create "employee" [:first-name :last-name] ["Mafinar" "Khan"]))

Program your Programming Language

Macro

• Much like templates, but for programming language
• Abstract away a snippet into your own liking
• True power of Lisp

;; UNLESS <YES> <NO> = generate_code("if (!_LOGIC_) { _YES_ } else { _NO_ }")

(defmacro unless [pred a b] `(if (not ~pred) ~a ~b))

Behold the Mighty Leiningen