Want to learn Clojure? It doesn't have to be hard!

We learn how to call functions and define new ones.

Defining a bake-cake function

We define a function to bake a cake.

Conditionals

We learn how to choose different code to evaluate based on a condition.

Defining scooped?

We write a function that can tell us whether we need to scoop an ingredient.

Defining squeezed?

We define a function to determine whether an ingredient is squeezed.

Defining simple?

We define a function to decide whether an ingredient is simple.

Defining ingredient types

11 min

We develop functions that add certain ingredient types.

Looping a number of times

Let's learn how to iterate a certain number of times using dotimes.

Using the plural functions

We'll use our new functions to refactor our baking function.

Variadic functions

15 min

We learn to write functions that can take a variable number of arguments and use a common pattern for handling default argument values.

Baking with variadic functions

Now we can rework our bake-cake function to use the variadic versions of our add functions.

Bake cookies function

We can now define a function called bake-cookies to implement the cookies recipe we thought before.

Day 1 Conclusion

Let's wrap up our first day at the bakery and take a look at what we've accomplished.

Running Leiningen projects

11 min

In this first lesson, we'll take a tour of a Clojure project and learn how to run it. We'll also take a look at the editor we'll be using to edit the code for the rest of the course.

Error function

11 min

We define a function to indicate an error.

Refactoring errors

Let's now use the error function we just wrote and replace all of the error expressions we've already got with calls to it.

Bakery locations

14 min

We learn about the different locations that X5 can go to in the bakery. We learn about sets and what they can hold.

Scooped?, squeezed?, and simple? refactor

We refactor scooped?, squeezed?, and simple? to use the same pattern we just wrote.

Fetching ingredients

We need to go fetch ingredients from different locations. Let's write a function that will go to the right location and fetch an ingredient and bring it back to the prep area.

Fetch ingredients generic

We can now write a function that will just take the ingredient as an argument and decide where to go to fetch it.

Maps

We learn about another data structure called maps (hash maps).

Fetching a shopping list

We learn a new conditional and how we can begin fetching an entire shopping list with as few trips as possible.

Refactoring fetch-list

We start to refactor our big fetch-list function into smaller parts.

Refactoring locations

We have some duplication. Let's learn a new loop to go through all of the locations and fetch what we need from each.

A day at the bakery

20 min

Now that we have an efficient way of fetching ingredients, let's handle the orders for the day.

Analyzing a day at the bakery

Let's take a look at the day-at-the-bakery function and see how we can improve it.

Functional programming

Let's talk about Functional Programming. Then we can talk about combining ingredient lists.

Into

We also want to be able to multiply an ingredient list. For instance, if we need to make 3 cakes, we can multiply the ingredients for a cake by 3. That's not quite as easy as adding, but it's not hard. We just need a few more things.

multiply-ingredients

Now we can learn how to calculate one list from another and how to use it to multiply ingredients.

order to ingredients

5 min

We create a function that will take an order and return the ingredients needed to complete it.

orders to ingredients

8 min

Now we can write a function that takes a list of orders and gives you the whole list of ingredients you'll need to complete all of them.

Making one shopping trip

Let's now do one big shopping trip after we fetch the orders.

Making one delivery

12 min

The delivery bot is annoyed that we give him one receipt per baked good. Let's fix that by grouping them by order.

Day 2 conclusion

We review what we've learned and how our baking is doing.

Day 3

Today is X5's third day at the bakery. The first day, we learned how to use ingredients. In the second day, we learned how to calculate, basically plan ahead, before we started working, to make things more efficient.

Let's start with cleaning up some unused code.

Add cocoa

Let's add a new ingredient, namely cocoa.

Baking brownies

Let's add a recipe for a new baked good, brownies.

Analyzing recipes

We make note of some duplication and make a plan for removing it.

Starting the database

Let's get started on our database where we store bakery knowledge.

Perform

We need to write a function that can take actions. We'll start with cooling the pan.

Mix step

We add :mix to the perform function.

Pouring and baking

Let's add pour and bake to our perform function.

Adding ingredients

Let's add an action for adding ingredients.

Bake recipe

We make a generic bake-recipe function that looks up the steps in the database and bakes it.

Generic bake function

We can now rewrite bake to use the new bake-recipe function.

Adding all recipes

5 min

Now that we can bake recipes, let's add the other recipes, cookies and brownies.

Cleaning up order to ingredients

We get rid of the ingredients listed in the definition of order->ingredients and instead look them up in the database.

Ingredients in the database

We need to add a section to the database about where to fetch ingredients and how to use them.

Refactoring scooped, squeezed, and simple

We redefine scooped?, squeezed?, and simple? to use the baking database.

Generic fetch ingredient

We can now do a generic fetch-ingredient function that looks up the location in the database. That lets us get rid of the specific fetch-from-pantry and fetch-from-fridge functions.

Refactoring fetch-list (again)

Currently, we've defined a map called locations that lists the locations of all of the ingredients. It's duplicating what's in the database.

We learn a new tool, called group-by, that will allow us to drive the fetching of an entire list of ingredients by that list alone.

Make storage-location more useful

I'm not completely happy with storage-location. It's not a very valuable function outside of this one usage. We should really use a custom function just for the item-amount usage.

Redefining add

We refactor add to dispatch from a map based on usage type.

Defining actions

We can make a map for dispatching actions.

Refactoring perform

Now that we have the actions map, we can refactor perform to use it.

Conclusions

5 min

We conclude the course with reflections on what we've learned.

Appendix: Creating a Leiningen project