Advertisements

Clojure From Scratch: Code and Concepts Woven Together

Advertisements
Learn idiomatic Clojure at the REPL: functional ideas, concurrency model, and design philosophy that make it powerful
4.5
4.5/5
(59) Ratings
12,792 students
Created by ProgLang MainSt.
Advertisements

What you'll learn

  • Write idiomatic Clojure at the REPL using prefix notation, immutable values, and the four core collections
  • Define functions with multiple arities, variadic arguments, destructuring, and closures
  • Replace loops with recursion, comprehensions, and the functional trio of map, filter, and reduce
  • Build readable data pipelines with threading macros, transducers, and the function combinators
  • Manage concurrent state safely with atoms, refs, software transactional memory, futures, and core.async
  • Work with lazy and infinite sequences, and avoid the head-holding and chunking pitfalls that bite newcomers
  • Model data with records, protocols, multimethods, and spec, and handle errors as structured data with ex-info
  • Understand the design philosophy behind Clojure: simplicity, hosting on the JVM, code-as-data, and the identity-state-time model
This course includes:
6.5 total hours on-demand video
0 articles
0 downloadable resources
92 lessons
Full lifetime access
Access on mobile and TV
Certificate of completion
Advertisements

Course content

Requirements

  • Comfort with at least one programming language such as Python, JavaScript, Java, or Ruby
  • Basic understanding of variables, functions, loops, and data structures
  • Familiarity with using a terminal or command line to run programs
  • A computer running Windows, macOS, or Linux with permission to install software
  • No prior experience with Lisp, functional programming, or the JVM required

Description

This course contains the use of artificial intelligence.

Clojure is the most widely deployed Lisp in industry, and it rewards programmers who understand not just how to write it but why it was designed the way it is. This course teaches you both at once. You’ll write real Clojure from the very first lecture at the REPL, and every coding section opens with a short, story-driven lecture that gives you the context behind the code you’re about to write, so the syntax never feels arbitrary.

You start at the keyboard: evaluating expressions, printing values, and learning the parenthesized prefix notation that defines the language. From there you build steadily through bindings, the core data types, equality and conditionals, and the four immutable collections at the heart of every Clojure program. You’ll define functions, close over values, and learn to iterate the Clojure way with recursion, comprehensions, and the functional toolbox of map, filter, reduce, threading macros, and transducers. The advanced sections take you into concurrency and state with atoms, refs, futures, and core.async, then into lazy sequences, records, protocols, multimethods, spec, and data-rich error handling.

What sets this course apart is its woven structure. Across ten sections, hands-on coding lectures carry the bulk of the learning, but they’re framed by conceptual lectures that explain the ideas a senior Clojure engineer takes for granted: why Rich Hickey built the language in 2007, what hosting on the JVM buys you and costs you, how persistent data structures stay fast while immutable, why code is data, and how identity, state, and time form a coherent model of the world. The course then closes with a run of deeper conceptual lectures that tie the whole language together, ending on the big ideas of lazy evaluation and the sequence abstraction, and the two quietly profound features — transducers and protocols — that set Clojure apart.

By the end you’ll be comfortable reading and writing idiomatic Clojure, you’ll understand the design decisions behind it well enough to make good choices in your own code, and you’ll have hands-on experience with the concurrency and data-shaping tools that make Clojure a favorite for data-heavy, correctness-critical systems. Whether you’re coming from Python, JavaScript, Java, or another Lisp, this course meets you where you are and takes you to fluency.

Who this course is for:

  • Developers from object-oriented or imperative backgrounds curious about functional programming
  • JVM developers (Java, Kotlin, Scala) who want a productive, data-oriented Lisp
  • Engineers who want concurrent, immutable-by-default code with less ceremony
  • Self-taught programmers looking to deepen their grasp of functional design
  • Anyone who wants to think in data and expressions rather than classes and mutation
Advertisements
CLOJURE-FREE-JUN26
Advertisements
Advertisements
Free Online Courses with Certificates
Logo
Register New Account