Clojure Fundamentals Course For Beginners
Download as PPTX, PDF1 like1,157 views
The document outlines a course on Clojure fundamentals aimed at beginners, highlighting its advantages as a concise, functional programming language that runs on the JVM and works well with Java and JavaScript. It covers various topics including higher-order functions, concurrency, Clojure web applications, and software engineering tools like Leiningen. Additionally, it explains core concepts such as immutability, threading models, and provides examples of functions and data flow management.
![Clojure Functions
Function defn
( defn square [x] ( * x x))
https://clojuredocs.org/clojure.core/range
( range 10)
Higher order function ‘map‘
(map square ( range 10) )
Core functions data flow for expressions
Core function = str
(def myMap {:firstKey "firstValue", :secKey "secValue"})
(str "first key value: " (:firstKey myMap ) " second key value: " (:secKey myMap ))
Higher order function ‘apply ‘
(apply str [ "one" "two" "three" ]) is the same as : (str "one" "two" "three")
(str [ "one" "two" "three" ])](https://image.slidesharecdn.com/clojureppt-160427051306/85/Clojure-Fundamentals-Course-For-Beginners-5-320.jpg)
![Functional Composition
Arity
arity 2
(def make-a-set
(fn ([x] #{x})
([x y] #{x y})))
(make-a-set 1)
(make-a-set 1 2)
Variadic functions
(defn var-args [x & rest] (apply str
(butlast rest) ) )
(var-args 0 1 2 3 4)
Currying
Currying is a way to generate a new function with an
argument partially applied
partial is a way of currying
partial
https://clojuredocs.org/clojure.core/partial
(def make-a-set (fn ([x y] #{x y})))
( (partial make-a-set 2) 3 )
What if we want to create a function not just a form
(def make-a-set-5 (partial make-a-set 5))
(make-a-set-5 10)](https://image.slidesharecdn.com/clojureppt-160427051306/85/Clojure-Fundamentals-Course-For-Beginners-10-320.jpg)
![Functional Recursive Data Flow
Recursion is one of the fundamental techniques
used in functional programming.
Review
Function literal
((fn [x y] #{x y}) 1 2)
Function arity 2
(def make-a-set
(fn ([x] #{x})
([x y] #{x y})))
(make-a-set 1)
(make-a-set 1 2)
def special form is a way to assign a symbolic name to a piece of Clojure data](https://image.slidesharecdn.com/clojureppt-160427051306/85/Clojure-Fundamentals-Course-For-Beginners-15-320.jpg)
Clojure Fundamentals Course For Beginners
- 1. One of the Most Popular Course on Clojure - Clojure Fundamentals For Beginners Write shorter codes that do so much more with Clojure. Clojure is the perfect blend of a general-purpose programming language and a functional programming language. Created by Rich Hickey, the programming language combines the interactive development of a scripting language with that of a robust infrastructure for multi-threading programming. This course covers the fundamentals of Clojure as well as teach you how to start coding using the language. The following slides will let you know, all that the course encompasses.
- 2. Clojure and Java Clojure runs on the JVM. Java is an incredibly verbose language that has only limited support for functions via lambda’s Clojure is an incredibly terse language By incorporating Clojure into Java code we can greatly reduce the verbosity and allow important functional tools like recursion By incorporating Java into Clojure code allows use of Java’s extensive native functionality and its enormous ecosystem The ability to use Java classes, objects, and methods is called Java interop http://clojure.org/reference/java_interop
- 3. Clojure and JavaScript Developers don't just write assembly to write a desktop applications it is just not feasable. JavaScript is ubiquitous. Developers use compilers to take a high level language to assembly Is Javascript like the assembly language of the web. Javascript is a high-level, dynamic language Writing high-performance JavaScript is a challenge Javascript does not really have shared memory model, it has webworkers can only pass very limited set of data, strings or JSON objects By using Compilers we can take JavaScript to output JavaScript as properly formed and otherwise cross-browser compatible code
- 4. Clojure Application Packaging Software Engineering Build Tools compiling computer source code into binary code packaging binary code running tests deployment to production systems creating documentation and/or release notes Uber Jar Package your Clojure project into one self-contained file. (a Java “uber” jar file.) The JVM has a classloader, which takes the compiled bytecode and loads it into the running JVM. If the byte code for your dependencies is not available at runtime then your application fails with a “class not found exception”. “Uber jar” is a jar file of all Clojure source code compiled to bytecode and all the projects dependencies.
- 5. Clojure Functions Function defn ( defn square [x] ( * x x)) https://clojuredocs.org/clojure.core/range ( range 10) Higher order function ‘map‘ (map square ( range 10) ) Core functions data flow for expressions Core function = str (def myMap {:firstKey "firstValue", :secKey "secValue"}) (str "first key value: " (:firstKey myMap ) " second key value: " (:secKey myMap )) Higher order function ‘apply ‘ (apply str [ "one" "two" "three" ]) is the same as : (str "one" "two" "three") (str [ "one" "two" "three" ])
- 6. Clojure Macros Macros use the source code as data (input) like functions use data "thread-first" macro (-> "first" (str " last")) (str "first" " last") "thread-last" macro (->> " last" (str " first")) Thread macro takes an expression to a form f(source code) -> source code ‘->’ : “term” ===> Form ‘-->’ : “term” ===> Form inserts the first term as the first /last item in second form inserts the first form as the first /last item in second form
- 7. Clojure Memory Model Clojure is a dialect of Lisp that runs on the JVM. (Common Language Runtime (like JVM) and Javascript engines) Objectives What is a memory model why is it needed JMM what is it how does it work STM what is it how does it work
- 8. Clojure Process core-async Summary Clojure Concurrency Vars Immutable by default Mutable call dynamic (def ^:dynamic *my-str-type* "mutable variable") As a mutable variable have thread local scope (visibility) Atoms Are visible (synchronised) (def my-atom (atom 10)) de-reference @my-atom (reset! my-atom 12) functional (swap! my-atom update ) Use swap! in STM block STM Refs Agents Refs ACID Transcational Atoms Update with alter in synchronised block (dosync (translate-point )) Agents Refs that update asynchronously (def my-agent (agent 10)) No strict consistency for reads (send my-agent update-my-agent)
- 9. Clojure Web Applications Ring is a Clojure web applications library inspired by Python's WSGI and Ruby's Rack Compojure is a rest api for rapid development of web applications in Clojure https://github.com/weavejester/compojure In compojure, each route is an HTTP method paired with a URL-matching pattern Compojure route definitions are just functions configured for Ring (accept request maps and return response maps) 1. Use a template lein new compojure eddy_comp 2. run the Ring web server lein ring server 3. defroutes site-defaults src/eddy_compjure/handler.clj 4. :keys :plugins :ring project.clj 5. Access the context root localhost:3000 6. JSON https://github.com/dakrone/cheshire 7. ClojureScript configuration 8. ClojureScript rest client
- 10. Functional Composition Arity arity 2 (def make-a-set (fn ([x] #{x}) ([x y] #{x y}))) (make-a-set 1) (make-a-set 1 2) Variadic functions (defn var-args [x & rest] (apply str (butlast rest) ) ) (var-args 0 1 2 3 4) Currying Currying is a way to generate a new function with an argument partially applied partial is a way of currying partial https://clojuredocs.org/clojure.core/partial (def make-a-set (fn ([x y] #{x y}))) ( (partial make-a-set 2) 3 ) What if we want to create a function not just a form (def make-a-set-5 (partial make-a-set 5)) (make-a-set-5 10)
- 11. Clojure Concurrent tools: Atoms, Refs, Vars Objectives 1. What is a memory model why is it needed 2. JMM what is it how does it work 3. STM what is it how does it work Result 1. memory model is a set of rules implemented in hardware and software that controls the way variables are updated during program execution by multiple threads of execution 2. Java memory model (JMM) is a set of low level concurrency artifacts (locks, atomic variables and synchronisation(visibility) ) combined with high level frameworks (Executor Service, Futures, ForkJoin, …...) to implement a memory model. 3. Software Transactional Memory (STM) an ACID transactional system for how a variable that is shared between threads updates, STM is implemented with the low
- 12. Functional recipe: Pure functions with Immutable Data Structures Pure Functions Side effects = changes that functions make in addition to their return value Pure functions do not depend on external data sources and do not provoke side effects of any kind. When invoked with a set of arguments, will always respond with the same return value Higher-Order Functions ● Takes one or more functions as arguments ● Returns a function as a result Clojure has families of higher order functions <==> Clojure Abstractions Eg sequence functions map reduce filter sequence <==> Data Structure Abstraction {sequence}
- 13. Gradle Environment 1 install gradle .bashrc export GRADLE_HOME=/home/ubu/gradle export PATH=$PATH:$GRADLE_HOME/bin export JAVA_HOME=/usr/lib/jvm/java-8-oracle .bashrc export JAVA_HOME=/usr/lib/jvm/java-8-oracle export GRADLE_HOME=/home/ubu/gradle export PATH=$PATH:$GRADLE_HOME/bin source .bashrc
- 14. Leiningen Environment Software Engineering Build Tools Compiling computer source code into binary code Packaging binary code Running tests Deployment to production systems Creating documentation and/or release notes Objectives 1. Install leningen 2. Understand Leiningen project layout 3. Understand Leiningen build script (dependencies ect ..) 4. Run the clojure repl
- 15. Functional Recursive Data Flow Recursion is one of the fundamental techniques used in functional programming. Review Function literal ((fn [x y] #{x y}) 1 2) Function arity 2 (def make-a-set (fn ([x] #{x}) ([x y] #{x y}))) (make-a-set 1) (make-a-set 1 2) def special form is a way to assign a symbolic name to a piece of Clojure data