Joep Schuurkes (Posts about clojure)

A lesson from every language I've used

Joep Schuurkes — Thu, 28 Dec 2023 23:00:00 GMT

Throughout the years I've used quite a few different languages - if you allow me to be somewhat generous with the word "use". One language I actually feel proficient in. Some languages I've only done coding exercises in. And one language I've only used for a total of maybe 10 minutes, but that did really help out a whole team.

I do believe we should be that generous, both towards ourselves and to others. For an industry that likes to talk about imposter syndrome, we seem to enjoy saying "You're not a real ... unless..." a bit too much.

Listing these languages for myself made me wonder what I had learned from them. Did I just learn how to write some code in each of them? Or did I also pick up some more general lessons? Turns out I did.

(clj 12) Core concepts of functional programming with Peg Thing

Joep Schuurkes — Sun, 06 Aug 2023 13:13:36 GMT

Chapter 5 of "Clojure for the Brave and True" explores two core concepts of functional programming: pure functions and immutable data structures. It wraps up with walking you through the code¹ of a game called "Peg Thing"², which uses "everything you've learned so far: immutable data structures, lazy sequences, pure functions, recursion - everything!"

So what is this Peg Thing?

For a full description and the code of Peg Thing, you can follow the links in the paragraph above. In this post I'll only share what's relevant to describe what I learned about functional programming through Peg Thing.

(clj 11) Moving on from some unsolved exercises

Joep Schuurkes — Thu, 29 Dec 2022 15:08:36 GMT

At the end of chapter 4 of "Clojure for the Brave and True" there are four exercises. This post is about me deciding to move on to chapter 5 after solving 1.5 of these exercises.

The challenge with these exercises

A good example to talk about the challenge with these exercises is the second one:

Write a function, append, which will append a new suspect to your list of suspects.

(clj 10) The mapify function of (clj 9) revisited

Joep Schuurkes — Wed, 13 Jul 2022 19:02:36 GMT

In my previous Clojure post I covered the code example at the end of Chapter 4 of "Clojure for the Brave and True". Or rather, I focused on a single function in the example, called mapify, and described how I figured out what it does. At the end of that post I shared my disappointment:

Having done all this work (and writing) I can't help but feel a bit disappointed. In the end, the function does not seem to do a lot.

And I shared a Python version of that same function, claiming that it basically does the same thing¹.

However, less than a week after publishing the post, I got a very kind email by someone named Martin. And "in defence of clojure and to maybe reduce your disappointment" Martin pointed out the two versions are not as equivalent as I claimed, because the Clojure version is more general than the Python version. So I looked at the two version again and the way they are different turned out to be quite interesting - interesting enough to write a follow-up post.

(clj 9) How to figure out what a function does

Joep Schuurkes — Sun, 12 Jun 2022 13:01:36 GMT

Chapter 4 of "Clojure for the Brave and True" concludes with a Vampire Data Analysis Program, serving as a summary of the chapter. The book shows some code, explains it, moves on to the next bit of code, etc. I'm not sure why, but I decided I wanted to figure out the code on my own and then read the explanation to see if I got it right. Afterwards I realized it might make a good blog post: both explaining what the program does and what techniques (for lack of a better word) I used to figure it out.

With most of the work in the program being done by a function called mapify, this blog post will focus on that single function. As it turns out, it took me more than 2000 words (footnotes not included) to describe what this function consisting of only 9 lines does. So feel free to read all of it, skim through it, or skip straight ahead to the techniques and some reflections.

(clj 8) Some notes on lazy sequences and function parameters

Joep Schuurkes — Mon, 18 Apr 2022 12:16:36 GMT

Almost done with the chapter 4 "Core Functions in Depth" of "Clojure for the Brave and True"! Before wrapping up the chapter with a longer example, a summary, and some exercises, the book goes into lazy sequences, the collection abstraction, and function functions. In this post I will share some notes on infinite lazy sequences and function parameters, making comparisons between Clojure and Python.

Infinite lazy sequences

A lazy sequence is a sequence whose members aren't computed until you try to access them. One advantage is that it's more efficient: the whole sequence doesn't have to be calculated and kept in memory from the start. Another advantage is that it allows you to create infinite sequences. Do that with a normal sequence and your program would never want to stop calculating.

(clj 7) Programming to abstractions with sequence functions

Joep Schuurkes — Sun, 05 Dec 2021 12:40:36 GMT

Looking at my progress so far, I realized it's time re-evaluate this whole learning Clojure-thing. After looking through the table of contents of "Clojure for the Brave and True" and giving it some thought, I decided to make two changes to how I'll proceed:

I will start writing shorter posts and write them more often.
My goal is to finish "Part II: Language Fundamentals". I don't have to do "Part III: Advanced Topics".

Completing Part II will still take quite some work. I've worked through the two first sections of chapter 4 (5 sections left in that chapter) and Part II goes up to chapter 8. So no time to waste: let's take a look at sequence functions and programming to abstractions.

(clj 6) Three chapters in one year

Joep Schuurkes — Sat, 08 May 2021 08:53:25 GMT

It's been a bit more than a year since I posted my first blog post about learning Clojure. And it's been five months since my last blog post about it. So far I've made it through the first three chapters¹ of "Clojure for the Brave and True". Instead of commenting on my learning pace at the start of every post, I've decided that this pace is the pace that works for me at this time, so there's no need to keep revisiting the topic.

Something I do want to mention is that one thing that triggered me to do some more Clojure was this episode of Gene Kim's excellent Idealcast podcast with Michael Nygard, in which they spend some time talking about Clojure.

Vim macros

The exercises at the end of chapter 3 got me to try out a lot of things, so I got bored having to type in the commands to copy a line (yy), paste it (p), replace it by its evaluation (c!$), comment it out (gcc), and add a "=>" to mark it as output. So I learned about Vim macros and recorded that sequence to run when I hit @c. At the end of my (clj 4) post I mentioned I might have to do this. Guess that moment came sooner than I expected.

(clj 5) Loop and recur, into and conj

Joep Schuurkes — Sat, 26 Dec 2020 09:09:08 GMT

Yet again it's been a while since I did some Clojure or blogged about it. This time I'm writing this blog post three months after working on the code on September 5, 6 and 12. I'm not going to dwell on that too long, because other things in my life were more important. I did feel a little sad when this year's Advent of Code launched and I realized my Clojure is nowhere near a state where I could attempt the puzzles. So I ended up doing the first 10 days in Python, which is twice as far as I got last year.

I also feel like my current approach to learning lends itself well enough to going slow. Taking my time to play around and make notes with while working through a section of Clojure for the Brave and True and then revisiting my code and notes later to write a blog post, does seem to result in stuff actually sticking in my memory. (Disclaimer: am writing this before writing the rest of this blog post.) Slow is smooth and smooth is fast, as they say.

The section I tackled in September is "Pulling It All Together" from Chapter 3, which describes the construction of a piece of code of about 50 lines in which - I'm sorry to say - a hobbit gets hit in different body parts.

(clj 4) Learning about when, maps and closures

Joep Schuurkes — Fri, 31 Jul 2020 20:25:15 GMT

It's been more than two months since I did any Clojure - for the obvious reasons. Luckily I did take notes as I proceeded with chapter 3 of "Clojure for the Brave and True". So the plan is to process these notes into a blog post, which means this post will cover the sections "Data Structures" and "Functions" of that third chapter. Leaving me ready to proceed with the rest of the chapter, i.e. "Pulling It All Together" and the summary and exercises.

Why is there a `when`?

The part about control flow is actually before the part about and and or which I talked about in my previous post, but according to my notes I returned to it. I don't remember why to be honest.

The book provides the following example of when:

(when true
    (println "Success!")
    "abra cadabra")
; => Success!
; => "abra cadabra"