All Episodes

28. Authentication with Buddy
Published 03 April 17
Buddy is a popular security library for implementing authentication and authorization. In this episode you'll learn what the difference is, and how to implement password based authentication for a simple Ring app.
27. Resolving Dependency Conflicts Freebie
Published 17 March 17
In this beginner friendly episode you'll learn how to resolve a common type of Clojure error. It walks you through the process step by step, from analyzing the error, investigating the cause, coming up with a solution, up to finally reporting the issue on Github. In the process you'll learn how to interpret stack traces, how to inspect the dependency tree with Leiningen, and how to influence Leiningen's choice of version in case of a conflict.
26. Component and System
Published 07 March 17
Stuart Sierra's Component is a small library that can have a big impact on the structure and architecture of your application. In this episode you learn how you can use it to create components, and manage dependencies. You will create a Jetty and an Endpoint component, and use the PostgreSQL component from the System project.
25. re-frame Events and Effects
Published 20 February 17
Side effects in re-frame are handled through events. You'll implement several event handlers of a TodoMVC app so it becomes functional. You'll also implement custom effect and co-effect handlers for storing the application state in localStorage. To debug event handlers you'll learn about the "debug" interceptor, and about re-frisk, a handy tool for inspecting your re-frame database.
24. defrecord and defprotocol
Published 30 January 17
With records, Clojure has introduced a way to create struct-like objects, while avoiding some of the problems encountered in object orientation. Records don't hide their data behind custom interfaces, but instead partake in the abstractions that Clojure's own data types are built on, so that code can treat treat a record like a regular Clojure data type. Protocols are Clojure's take on abstract interfaces. They make it possible to extend preexisting types to new methods, and extend preexisting methods to new types, thus avoiding the expression problem.
23. deftype and definterface
Published 19 January 17
Clojure is built on a well thought out set of abstractions. To implement these, it makes use of the ability to define abstractions in the host language, namely Java interfaces, and the high-performance polymorphism that they provides. As a Clojure programmer you don't have to resort to Java to achieve the same thing. All the facilities are there to create interfaces, and to create types that implement interfaces, getting you as close to the JVM as you need to be.
22. Seq and Seqable Freebie
Published 23 December 16
Seqs are a key abstraction in how Clojure processes data, but what exactly is a "seq", and how does it relate to "seqable?". Time for a deep dive in Clojure and ClojureScript source code to discover the finer points. Learn exactly what seqs and seqables are, what they do, and how you can use them to your advantage.
21. Compojure
Published 09 December 16
Compojure is one of the more popular routing libraries for Ring. It's easy to pick up, and gives you a great foundation to further explore Clojure web development.
20. re-frame Subscriptions
Published 17 November 16
A complete look at re-frame subscriptions, including coverage of Reagent's atoms and reactions. You learn how to write subscriptions, how they work, and how to plug them together into a signal graph.
19. re-frame
Published 11 October 16
Reagent is a popular and easy to use option for using React with ClojureScript. re-frame builds on top of Reagent, providing an elegant and opinionated way to structure applications and deal with application state. The documentation for re-frame can easily overwhelm. With this episode you get a practical hands-on introduction, so you can be making your own apps in no time.
18. Using JavaScript libraries in ClojureScript Freebie
Published 23 September 16
One of the benefits of ClojureScript is that it lets you leverage the great JavaScript ecosystem. Using arbitrary JS libraries isn't always trivial though, and a lot of head scratching can ensue. In this episode you'll learn the exact steps from here to success, and you'll gain insight into ClojureScript's build process, so you can tackle any challenge that comes your way.
17. Ring III, Return of the Middleware
Published 09 September 16
We add `GET`, `PUT`, `DELETE` operations to the contact book API. In the process we pull out the EDN handling into its own middleware, and come across some handy Regex tips. This third episode picks up the pace a bit, but by now that shouldn't be a problem.
16. Ring II, the Two Routes
Published 01 September 16
In this second installment of our beginner friendly introduction to Ring the API goes from being read-only to being read-write. You also learn about `juxt`, `slurp`, and how to parse an incoming request body.
15. Using Figwheel With Emacs, part 2: CIDER
Published 20 August 16
By using Figwheel with CIDER you get both a Clojure and a ClojureScript REPL at the same time, and you get all the nice features of CIDER. It's a more complex setup than just straight inf-clojure, so before we get there we need to talk a bit about nREPL and Piggieback, tooling you should be familiar with, no matter which editor you are using.
14. Using Figwheel With Emacs, part 1: inf-clojure-mode
Published 16 August 16
Learn how to integrate Figwheel's browser connected REPL into Emacs, for an ever greater degree of interactive development, using inf-clojure-mode.
13. Ring, pt.1
Published 06 August 16
In this new series you'll build an API with Ring from the ground up. The pace is slow and no steps are skipped, making it a great lesson for beginners.
12. Clojure Keyword Arguments
Published 26 July 16
Clojure's variable argument functions combined with map destructuring results in a concise syntax for keyword arguments. We'll pick this feature apart to see exactly what's inside. You'll learn about "mapply", and learn why keyword arguments aren't always the best solution.
11. Reagent part 3: Keys & Lifecycle Methods Freebie
Published 17 July 16
Learn about React performance, the use of `keys` properties, and how to use lifecycle methods with Reagent.
10. Reagent part 2: Cursors
Published 07 July 16
We continue building a Kanban board with Reagent, adding functionality to edit cards. In the process you'll learn all about Reagent's cursors and event handlers.
9. Reagent
Published 27 June 16
One of the more popular wrapper libraries for using React with ClojureScript is Reagent. We'll build a kanban style board to demonstrate the main features.
8. The ClojureScript Compiler
Published 17 June 16
To be effective at programming, you have to understand your tools. In this episode we'll peel a few layers away, and use the ClojureScript compiler without any help from Leiningen, Cljsbuild or Figwheel. You'll learn about compiler options, levels of optimization, the role of the Google Closure Library, and how to confgure the compiler for development and production use.
7. Intro to clojure.spec Freebie
Published 08 June 16
The spec library which will be included in Clojure 1.9 gives you a powerful mechanism for validating data. Find out how to use it in this episode.
6. Building a React app with ClojureScript
Published 02 June 16
React.js is the new hotness in the land of user interfaces. It's descriptive approach pairs wonderfully with ClojureScript's functional underpinnings. This episode will show how to build an app with React, all from comfortable ClojureScript. It provides a solid foundation for diving into React wrappers like Reagent or Om later on, and it's a welcome exercise in using ClojureScript's interop features. We'll cover: elements, components, the virtual DOM, using an atom to keep application state, and attaching event handlers with component properties.
5. Introduction to Luminus, part 3
Published 24 May 16
In this closing episode of the Luminus introduction, you'll learn how to extend the template language with custom filters, and how to generate HTML components in code using Hiccup.
4. ClojureScript Interop Freebie
Published 20 May 16
In this episode we'll go over all the tools ClojureScript puts at your disposal to interoperate with JavaScript. You'll learn how to call JavaScript libraries, how to work with JavaScript datatypes, how to convert data back and forth, and how to use "this".
3. Introduction to Luminus, part 2
Published 19 May 16
We continue our journey through Luminus by building a wiki. In this episode you'll learn how to create the form to edit pages, and handle creating new page revisions. We'll also come across Cross Site Request Forgery, and learn how to prevent it.
2. Introduction to Luminus, part 1
Published 14 May 16
To give you a starting point for building your own app, we'll go through the process of building an application from scratch with Luminus. In this first part in a series of three, you'll learn to set up the database, write migrations to create tables with Migratus, create SQL queries with HugSQL, and tie it all together with Compojure routes and Selmer templates.
1. clojure.core/some Freebie
Published 09 May 16
Clojure's `some` function is surprisingly versatile. Find out what it does, and what you can do with it.