Clojure - from beginner to advanced

Explore the basics of Clojure syntax with s-expressions, learn that code is data, define global variables and functions, and work with primitive types, lists, vectors, maps, and sets, plus immutability.

Explore Lisp syntax and s-expressions, using prefix notation and code as data to understand how read and evaluate processes operate on nested expressions like plus and multiply.

Define global variables with def in current namespace, setting X to 42, and create global functions with defn, outlining name, arg vector, and body whose last form is the result.

Explore primitive data types in Clojure, including integers, floats, ratio, big integer and big decimal, booleans, strings, characters, regular expressions, and the use of symbols and keywords.

Explore basic data structures in Clojure, including lists, vectors, sets, and maps, and learn core operations like concat, first, rest, drop, get with default values, and merge.

Explore immutability in Clojure by showing vectors, sets, and maps return new collections without changing originals. See persistent data structures share data for speed, enabling pure functions and easier testing.

Explore Clojure fundamentals from control structures and scope to loops, exceptions, namespaces, functional programming basics, map, reduce, filter, threading macros, and recursion.

Explore Clojure control structures and conditional expressions, including if, when, case, and cond, with practical examples like absolute value and safe division.

Explore how to define and use local variables in Clojure with the let form, manage scope, hide globals, and evaluate expressions across multiple bindings.

Explore the for macro to iterate over ranges and collections and return a result sequence. Use let, when, and while to control iteration, and do times for side effects.

Learn how Clojure namespaces organize code by declaring a current namespace, using require, use, and import to bring in symbols, and switching namespaces for cross-namespace calls.

Discover basic functional programming: treat functions as first class, bind and compose them, create closures, and use map, filter, and reduce to process collections.

Describe destructuring in Clojure, extracting values from vectors and maps, binding to symbols, using rest, as, and keywords for defaults; apply in function arguments and maps.

Explore Clojure threading macros, including thread-first and thread-last, converting nested calls into a linear flow. Use some-> for nil-safe threading and apply to collections with filter, map, and reduce.

Explore recursion in functional programming by implementing factorial with self-calls, then convert to tail recursion with an accumulator and loop and recur, adding a two-argument signature and defaulting to one.

Explore closures and lexical scope, showing how functions capture surrounding values to form new functions, with examples like Make Inc that returns a function using captured x.

Explore advanced Clojure concepts, including dynamic versus lexical scope, reading and evaluating Gloater code, macros, protocols with multimethods, transducers, and concurrent tools such as software transactional memory engines and atonce.

Explore lexical scope and dynamic scope in Clojure, see how let shadows lexical variables and how dynamic binding propagates through function calls, with practical examples like redirecting standard output.

Learn to read Clojure code from strings, evaluate forms, and apply functions in a simple repl. Build a read-eval-print loop that processes input, prints results.

Explore the macro system in Clojure, building a my when macro, understanding macro expansion with macroexpand, and comparing quote-based and substitution syntax for transforming code.

Define a shape protocol with area and perimeter and implement it for circle and square using records, reify, and dot syntax to access fields.

Define a multimethod with a dispatching function, dispatch methods by type, and implement circle and square shapes with short and detailed string representations.

Explore transducers, a composable algorithm transformation that works independently of input data in Clojure. Compose map, filter, and take five transducers, then apply them to data with transduced for reductions.

Explore concurrent programming tools in Clojure, including atoms, refs, agents, and software transactional memory, and learn how immutable data and watchers help manage state and avoid race conditions.

This section covers Java interoperability in Clojure, creating and calling Java objects, reading, writing files, and checking existence. It covers Leiningen dependencies, HTTP requests, servers, templates, PostgreSQL, and testing.

Explore Clojure's Java interoperability by calling Java methods and static members with dot and slash syntax, handling Java strings, accessing system properties, and creating Java objects like hash maps.

Learn how to perform file input and output in Clojure with slurp and spit, manage resources with with-open, and use Java interop to check existence and delete files.

Learn to manage dependencies in Leiningen by adding libraries to the project file, reloading the app to download them, and using the terminal to require and use external packages.

Install and require a popular Clojure json library, encode maps to json, and decode json back to maps, with practical examples and guidance from the library's GitHub page.

Learn to use a clojure http library to perform http requests and spin up a http server with a handler on localhost:3000, and define routes with defroutes and composable roads.

Discover three approaches to generate HTML email in Clojure: Hiccup builds HTML from Clojure data structures, Enlive modifies existing markup, and Selmer renders templates.

Learn to work with PostgreSQL from Clojure using jdbc, configuring a connection map with dbname, host, user, and password; perform insert, update, select, and delete on a test table.

Learn to use mongo as a NoSQL database with the monger library in Clojure, connect to a local database, work with collections, and insert and find user documents.

Learn how to test in a Leiningen project with Clojure, covering the standard library for testing, running tests from terminal or editor, and fixing failures for reliable code.

Build a from-scratch personal blog web app with article reading, administrator login, and post creation and editing, using hiccup for pages and markdown support, with docker deployment.

Build a basic Clojure web app with the Compojure template and Leiningen, explore a blog project, inspect Ring, dependencies, and run a server with hot reloading to update the index.

Build an articles service with Mongar to create, save, and fetch articles in the articles collection, and update the index page handler to display the article list.

Learn to build a base page template with Hiccup in Clojure, render index and article pages from templates, and wire article data, IDs, and navigation using Hiccup-based HTML generation.

build a clojure article management flow with create and edit pages, using a title and body form and routes for new and edit actions, with forgery middleware to prevent csrf.

Build a login page and implement admin check with session-based middleware to restrict article creation and editing, protecting admin routes and redirecting non-admin users.

Enhance a Clojure app's UI with bootstrap styling and markdown support for articles, enabling styled containers, navigation, login forms, article previews, and admin delete actions.

Learn to run a Clojure web server as a standalone docker app by building a jar image and deploying with docker-compose using a yaml file.

Finish this course and celebrate your progress in Clojure from beginner to advanced. Continue learning, grow your skills, and I hope to see you again in the future.