Functional Design in Clojure

We look at pure data models we've created and see what they have in common.

We find a clear and pure heart in our application, unclouded by side effects.

We turn our attention to the frontend, and our eyes burn from the complexity.

We look for a suitable place to dig into the code and find an entry point.

We find ourselves staring at code for the first time—even though we wrote some of it!

We highlight the highlights of the Sportify! series.

We loop back to our new approach and find more, and less, than we expected!

We throw our code in a loop, and it throws us for a loop.

Our downloads fail at random, but our dead program won't give us any answers.

We need to test our logic, but the I/O is getting in the way.

We start testing our code only to discover we need the whole world running first!

We discover when giving up is the way to get ahead.

We push our software to reach out to the real world and the real world pushes back.

We grow beyond our REPL-driven pieces toward an end-to-end solution.

We realize we're done exploring when all of the pieces fall into place.

We peruse APIs to uncover the data hidden beneath.

We find ourselves in a murky situation, so we go to our REPL-connected editor to shine some light on the details.

We tackle a new application, thinking it'll be an easy win—only to discover that our home run was a foul, and the real world is about to strike us out!

We reflect on Clojure, the community, and how much we have to be thankful for.

We free our REPL to explore and automate the world around us.

We reflect on keeping the necessary mess at the edges so our core can be composed together with beauty and simplicity.

We get a handle on bringing I/O resources together in an application.

We go back to start and play through a composition strategy to see where we land.

We venture toward the core of a solution.

We help our code through a breakup so it can find its true colors.

We search for that sweet spot between full-featured mixes and simple ingredients when crafting your software recipes.

We bump into limiting constraints and learn to love their freedoms.

We compose our thoughts on why Clojure expressiveness is so effective but can be so hard to learn.

We devote some time to two functions that are indispensable when computations require variation.

We wander through the myriad ways of making decisions and listing choices in Clojure.

We eagerly discuss the times we need to interact with the messy world from our nice clean language.

We discuss polymorphism and how we tackle dynamic data with families of functions.

Let us share some tricks to reduce nesting and make your code easier to understand.

We talk about this data generating macro, while we remember situations when it was useful.

We lay out a list of ways to sort your data, ordered by their relative power.

We get a handle on big buckets of data by sifting elements into smaller buckets.

We talk about sifting data and marvel at the simple function that can turn two steps into one.

We talk about positive nothing and the proliferation of tuples.

We take time to unroll some examples of this function.

We create a whole episode by combining examples of useful uses of comp.

We cover some of the ways we use partial, without getting too literal.

We spend some time going through how these macros help keep our code nil-safe.

We take a turn with juxt, looking at all the ways it can help line up data.

We focus in on merge-with, a powerful function for aggregating data.

We survey the myriad ways we've used to launch our code into production, and laugh about the various complexities we've found.

We worry about the health of our websockets and, after looking for help from the standards bodies, roll up our sleeves and handle it ourselves.

We switch to using a component to manage our websockets, enabling ease of development and future growth.

We wander into the weeds, jumping through the myriad hoops required to deliver a simple notification.

We talk about spontaneously sending data from the server to the client to address our users' insecurities.

We examine our history writing web handlers and talk about all the ways we've broken them.

We tease apart the layers involved in serving static assets and are surprised by how many we find.