Busy (Clojure) Developer Guide to Podcasts

In this post, I’ll share with you the list of my favorite podcasts. Some of them are focusing on Clojure, but others are more general. This is just a very brief summary. In the future, I’d like to write more posts highlighting my favorite episodes.

In the fast-pacing technology world, it’s very hard to stay up to date and very easy to get overwhelmed with the number of new articles, blog posts, conference talks, frameworks. A podcast is an attractive medium and can be a great supplement to other learning resources.

What follows is the list of the podcasts I listen to on a regular basis.

1. Cognicast

This is my favorite (mostly) Clojure podcast by Cognitect, and it should be on the radar of every serious Clojure developer.

It’s maintained by authors of Clojure. The quality of episodes stays high, and they are rich sources of information.

In the past, it was hosted by Craig Andera. Since Craig left Cognitect, the podcast has gotten three new hosts: Timothy Baldridge, Carin Meier, and Stuart Sierra.

They cover a variety of topics, and the podcast has an unusual format:

  • They always start by asking a guest to share an interesting experience of art whatever it means to the guest.
  • They always end by asking a guest to share a piece of advice

You can find the list of all episodes with show notes and full transcription (starting with episode 94) at http://blog.cognitect.com/cognicast/.

2. Software Engineering Radio

This is my favorite general SW engineering podcast.

It covers lots of topics, and unlike Software Engineering Daily comes with new episodes at a reasonable pace (every two weeks or so). The topics include software development, testing, social aspects like communication and leading teams, distributed systems, performance, clean code, and more.

There are even some episodes covering Clojure, e.g. Episode 257: Michael Nygard on Clojure in Practice or Episode 158: Rich Hickey on Clojure.

You can find the list of episodes with brief summaries at http://www.se-radio.net/.

3. Defn.audio

This is an alternative and fun Clojure-only podcast hosted by Vijay Kiran and Ray McDermot from Holland and Belgium. Unlike most of other podcasts, it has two hosts, and there’s a ton of humor in each episode :).

They interview very interesting people from Clojure community: the list of former hosts include Alex Miller, James Reeves, and Stuart Halloway.

Again, the list of all episodes with short summaries is available online at https://defn.audio/.

4. Functional Geekery

Unlike Cognicast or Defn Podcast, this podcast doesn’t focus on any particular programming language. Its topic is functional programming in general, and it’s a good supplement to Clojure centric podcasts.

The podcast’s host Proctor asks very interesting questions and people like this podcast quite a lot.

Usually, there’s a comprehensive list of links for each episode at https://www.functionalgeekery.com/.

5. CaSE: Conversations about Software Engineering

I discovered this podcast only recently, after attending EuroClojure 2017 when they recorded the episode with Alex Miller. They cover a full range of topics including Software architecture, Microservices, or Legacy Software.

There are only ten episodes so far, so now it’s a good time to start listening and catch up on previous episodes.

How to stay up to date

Usually, I listen to podcasts during the morning walk with my dog. That means I can finish three podcasts a week on average. Alternating between mostly Clojure (Cognicast and Defn) and more general (Software Engineering Radio, CaSE, and Functional Geekery) gives me a wide variety of topics and broadens my horizons.

If you’re just starting with podcasts, I suggest picking only one or two. As you already know, I recommend the combo Cognicast + Software Engineering Radio.

Call for Action

Now it’s your turn. Take your time to pick a favorite podcast or two and start listening tomorrow!

Future Posts: Podcasts Summaries

In the future posts, I’d like to write the reviews of the podcasts’ episodes that I liked with brief notes for each episode.

Stay tuned! 

Clojure Development Workflow with Spacemacs and CIDER

This is a follow-up to my previous post What’s the Best Clojure IDE? I’ll show you my usual Clojure development workflow using Spacemacs+CIDER as primary tools.

I’ve already described my tour through the various Clojure IDEs/editors and why I’ve chosen the Spacemacs. If you haven’t read the previous post, you may want to go back and read at least the Spacemacs to the rescue part.

In this post, I’ll try to dig deeper and show you the complete development workflow. I’ve chosen video screencast as a primary format for this because I think it’s more useful to see everything in action.

We’ll create a simple clojure-repl project containing the jmethods function for listing all public methods of java classes.

You can find the video in the Curious Programmer YouTube channel.

Below is a brief summary of topics/tips presented in the screencast.


  • Generate new leiningen project: lein new clojure-repl
  • Open Spacemacs
  • Create new layout: SPC l 2; enter layout name: clojure-repl
  • Open clojure-repl/project.clj by pressing SPC f f and looking up the file on a file system
  • Open Neotree buffer via SPC p t to explore project structure
    • You can navigate in this buffer via standard vim key bindings: j, k, l, h. You can also press ? to open the help
  • Clean the initial project skeleton and commit them via magit: SPC g s
    • Expand/collapse the changes by pressing TAB
    • Stage the changes for commit by pressing s
    • Commit the staged changes by c c
  • Create java.clj file in the Neotree buffer by pressing c (“create”) and entering the name of the file.
  • Run cider-jack-in by , '
  • Switch between REPL and java.clj buffer using C-c C-z
  • Evaluate the java.clj buffer via , e b
  • Evaluate the function at a point by , e f
  • Send results from java.clj buffer to the REPL using , s e while keeping cursor right after the form you want to evaluate
  • Use clojure.core/bean function to examine the properties of java class
  • Reformat a buffer with , = to make sure that your code is compliant with Clojure style guide
  • Use SPC k s for “forward slurp”
  • Use cljr-add-missing-libspec , r a m to add a require unknown symbols (e.g. clojure.string/join) automatically
  • Show documentation popup with , h h
  • Navigate to source code by , g g


Additional tips mentioned at the end of the video:

  • Describe key bindings via SPC ?
  • Start with M-x and type in the “cider-” and/or use menu bar (F10) to search for CIDER commands and explore CIDER capabilities
  • Add new dependencies to project.clj and hot-load them into the REPL via , r a p
  • cider-inspect-last-result
    • press ENTER to deep dive
    • press C-z to switch into the Emacs mode and then l to go up
  • Use SPC / for a quick search within the project
    • You can also use C-c C-e to enter the edit mode and replace the text
  • Type * for a quick search/highlight of a symbol under the cursor
  • Display online java doc for Java class with , h j
  • Add Clojure sources to the project.clj/profiles.clj to be able to navigate to clojure.core java classes, e.g. clojure.lang.PersistentVector
  • Not covered in video
    • cider-browse-ns , h n to list all the functions in given namespace together with a documentation preview
    • cider-refresh  , s x to test everything in a fresh environment
    • CIDER debugger – debug function at the point: , d b


What’s the Best Clojure IDE?

In this article, I’ll evaluate the Emacs, Cursive, and Spacemacs, and explain why I ended up with Spacemacs for most of the projects I’m currently working on.

It’s been a while since I started coding in Clojure, but the “IDE dilemma” was there from the beginning. Although some people might think that it’s a waste of time and you can just pick any editor you want, I disagree. There’s definitely a big difference in terms of productivity if you can use the best tool for the job.

My Tour Through the Clojure IDEs’ Country

Emacs LIVE

In the beginning, I did a quick research and found out that many people in Clojure community use Emacs.

I had never really used Emacs. However, I found one particular Emacs incarnation, Emacs LIVE, specially crafted for beginners. Of course, there still was a big learning curve for me. I spent countless hours getting used to Emacs editing style, shortcuts, and quirks of Emacs LIVE.

On the one hand, it was packed up with useful plugins. On the other hand, its config was bloated, and it was slow to start.

Eventually, I was not able to distinguish if my problems (such as broken keyboard shortcuts for slurp and barf) were related to the specifics of Emacs LIVE or if they were some general issues with Emacs or my Mac OS X configuration.


In the meantime, I also played with Cursive.

As a long-time IntelliJ IDEA user, I happened to be familiar with the environment. I really love the features like Full-text search, Project tree window, Symbol navigation, Refactoring, Git integration, Live Templates, Database Plugin, and more.

However, for smaller projects, Cursive feels too heavy-weight:

  • Its start up time is slower.
  • ClojureScript and Figwheel integrations aren’t very good (yet).
  • Regarding plain old text editing, Vim and Emacs provide a better experience.

I love Cursive’s features and need them to be productive. I do think that Colin Fleming is doing a great job. But I also need something more lightweight which doesn’t consume a lot of resources.

Emacs – From the Scratch

Being unable to fix some issues in Emacs LIVE, I finally stepped back and started with plain Emacs, adding only plugins I needed. Step by step, I added projectile, project-tree-explorer (later replaced by NeoTree since project-tree-explorer was painfully slow for large projects), auto-complete, company-mode, and more.

You can find my old Emacs configuration on GitHub. One interesting piece is the configuration for Figwheel.

;; Cider figwheel integration
(require 'cider)
;; more elaborate cider-cljs-lein-repl than in official documentation
;; this tries to match the project type
;; copied from https://lambdaisland.com/episodes/figwheel-emacs-cider
(setq cider-cljs-lein-repl
 (and (resolve 'user/run) (resolve 'user/browser-repl)) ;; Chestnut projects
 (eval '(do (user/run)
 (require 'figwheel-sidecar.repl-api)
 (resolve 'figwheel-sidecar.repl-api/start-figwheel!)
 (catch Throwable _))
 (eval '(do (figwheel-sidecar.repl-api/start-figwheel!)
 (require 'cemerick.piggieback)
 (resolve 'cemerick.piggieback/cljs-repl)
 (catch Throwable _))
 (eval '(cemerick.piggieback/cljs-repl (cljs.repl.rhino/repl-env)))
 (throw (ex-info \"Failed to initialize CLJS repl. Add com.cemerick/piggieback and optionally figwheel-sidecar to your project.\" {})))")

Previously, I struggled a lot with a proper setup for ClojureScript projects including browser-connected REPL, Figwheel and CIDER integration.
That Lambda Island episode finally got me some setup that worked.

Again, it took me non-trivial amount of time to configure my Emacs and learn new shortcuts. Yet I still had some issues with code formatting and usability. I was never quite happy with using Emacs for large projects, especially for the ones I wasn’t familiar with. Therefore, I ended up using Cursive for every larger code base I encountered.


Spacemacs to the Rescue

Recently, I visited The second Brno Clojure meetup and had a great discussion with Karel Miarka about many topics, including Clojure editors. Instead of using plain Emacs, he recommended the Spacemacs distribution.

Getting Started with Spacemacs

I found following resources to be perfect for getting started with Spacemacs:

  1. Spacemacs documentation
    1. Quickstart
    2. Full Documentation
  2. Clojure development with Spacemacs from Practical.li

The Introductory video is fascinating and made me curious. If that’s how the Spacemacs works, maybe I can use Emacs again without frustration even for large real-world projects.

The downside: I had to learn a little bit different workflow and shortcuts once again.
The upside: easy and almost automatic configuration and good pre-configured plugins.

My Spacemacs Configuration

Since Spacemacs configuration is almost automatic, I did a very little custom configuration:

  • I uncommented following dotspacemacs-configuration-layers in .spacemacs file (use shortcut SPC f e d for quick edit of .spacemacs file and SPC f e R for quick reload)
    • helm
    • auto-completion
      • By using this layer, you can automatically expand code snippets like defn via M-/ (yas-expand) to simulate Cursive’s Live Templates
    • better-defaults
      • few enhancements of standard commands like C-a, C-e, C-w, C-y, M-q
    • git
      • magit provides an incredible Git experience inside the editor.
      • Start with magit-status: SPC g s
      • Unlike many developers who use the Git only from command line, I believe there’s value in having strong Git integration within IDE. I used to use IniteliJ “Commit dialog” a lot and now I have a similar (and maybe even better) experience with magit.
  • I activated hybrid-mode instead of default-mode: dotspacemacs-editing-style 'hybrid
    • This means that you can use emacs shortcuts like C-a and C-e when you are in vim editing mode – very useful!
  • I turned on line numbers by default: dotspacemacs-line-numbers t
    • I can always turn them off via SPC t n


There’s a nice shortcut , (comma) which serves as a prefix for all Cider commands. For instance , t a will run all unit tests for current namespace. Alternatively, you can use SPC m prefix: SPC m t a

Other than that, Cider integration is just seamless and very similar to the ordinary Emacs.


Layouts are one of the more useful features that I didn’t use from the very beginning.

Basically, the layout is a set of related buffers. Something you could call a project in more traditional IDEs. The layout will help you to organize your buffers.

There is always at least one layout called Default. To create a new layout, press SPC l and then 2. Type the name of the new layout and you’re all set up. You can start creating new buffers. When you press SPC l b, you’ll see only buffers assigned to the current layout (except the Default one which contains all buffers).

Final Thoughts

Nowadays, Spacemacs is my tool of choice for all Clojure projects – both small samples and large code bases with thousands lines of code. I think it’s a great development environment with tons of useful features like Cider REPL, Git integration, Neotree explorer, layouts, and more. I found it more approachable for non-expert Emacs users than vanilla Emacs.

If I work on some project with lots of Java/JavaScript code in the future, I will probably switch back to Cursive.

How About the Atom + Proto REPL?

A Few days ago, I watched the Clojure/conj talk Proto REPL, a New Clojure Development and Visualization Tool by Jason Gilman and it completely blew my mind. The debugging and visualization capabilities of Proto REPL are brilliant.

However, when I tried Atom with Proto REPL it just didn’t feel right to me. To be honest, I didn’t spend much time with it (I have other things to do besides testing all possible Clojure editors). For now, I feel more productive and organized with Spacemacs, so I’ll stick with it. I’m pretty sure I’ll revisit Atom + Proto REPL at some point in the future.



My Bookshelf: Create a Project Skeleton for Clojure Web Application

In the last post, I discussed my Clojure learning strategy in general and introduced my new hobby project My Bookshelf.

This is the very first post in the My Bookshelf series in which I’ll describe how to create a skeleton of a simple Clojure web application based on Luminus template.

Getting Started

When I presented My Clojure Learning Strategy, I mentioned the importance of practical experience and learning just enough to get started. This is exactly what Step 7 of 10-step learning process is about.

As a preparation, I read the first chapter in Web Development with Clojure, 2nd ed. This was more than enough to get ready for creating a new project for My Bookshelf.


To be able to generate the project skeleton with Luminus template you need Java JDK and Leiningen.

I installed Leiningen via brew:

brew install leiningen

You’ll also need to install a database of your choice. I chose PostgreSQL:

# install PostgreSQL
brew install postgresql
# Run PostgreSQL as a service whenever the computer is started.
brew services start postgresql

After that, you’re ready to go.

Generate a Project Skeleton

Luminus is a handy template providing an opinionated selection of high-quality Clojure libraries. It’s really useful for beginners. It’ll save you plenty of time and a terrible headache which you’d get trying to explore all available Clojure web development libraries.

Having that said, it’s trivial to create a new project:

lein new luminus my-bookshelf +postgres

We’ve just generated simple web app using the +postgres switch which instructs Luminus to add PostgreSQL dependencies and generate db.core namespace.

You can, of course, select another database if you want. You’ll find the list of many possible options in Application Profiles documentation.

Set Up a Database

To be able to connect to the database you need to perform an initial setup:

  • create a database user for your application
  • create a database itself

Both these steps are trivial with PostgreSQL. Run following commands in a shell:

# creates a new user 'bookworm' which will be used by our application to connect to the DB
createuser --createdb bookworm

# create 2 databases - one for development, another one for testing
createdb -O bookworm my_bookshelf_dev
createdb -O bookworm my_bookshelf_test

DB config

Database connection info is stored in profiles.clj in project root directory. This file is automatically generated by luminus template and contains database url for dev and test profiles:

{:profiles/dev  {:env {:database-url "jdbc:postgresql://localhost/my_bookshelf_dev?user=bookworm&password=password"}}
 :profiles/test {:env {:database-url "jdbc:postgresql://localhost/my_bookshelf_test?user=bookworm&password=password"}}}

The database url can always be overriden via DATABASE_URL environment variable.

Migrate the Database

Luminus uses Migratus library for handling database migrations.

To migrate the database just run the following command:

lein migratus migrate

Migratus will scan the resources/migrations directory and look for the .sql files which have to follow naming convention ^(\d+)-([^\.]+)\.(up|down)\.sql

In our case, it’ll find the 20170218124009-add-books-table.up.sql file and execute the SQL found there:

 title VARCHAR(30),
 author VARCHAR(60),
 issued DATE,
 status VARCHAR(30));

Note: If you leave the password in profiles.clj blank (jdbc:postgresql://localhost/my_bookshelf_dev?user=bookworm&password=password”) you’ll get an obscure error when trying to migrate the database:

2017-03-07 09:37:12,682 [main] ERROR migratus.database - Error creating DB connection for postgresql://localhost/my_bookshelf_dev?user=bookworm&password=
java.lang.IllegalArgumentException: Vector arg to map conj must be a pair
        at clojure.lang.ATransientMap.conj(ATransientMap.java:37) ~[clojure-1.8.0.jar:na]
        at clojure.java.jdbc$parse_properties_uri.invokeStatic(jdbc.clj:178) ~[na:na]
        at migratus.database.Database.connect(database.clj:338) [na:na]
2017-03-07 09:37:12,683 [main] INFO  migratus.core - Ending migrations
Exception in thread "main" java.lang.NullPointerException, compiling:(/private/var/folders/hn/tgwyrdmj1tb5pmmbdkd1g_qc0000gn/T/form-init7084456921097733207.clj:1:125)
Caused by: java.lang.NullPointerException
        at migratus.database$connect_STAR_.invokeStatic(database.clj:223)
        at migratus.database$connect_STAR_.invoke(database.clj:217)
        at migratus.database.Database.connect(database.clj:338)

So make sure that some password is set.

Run the Application

Now we are ready to run our application skeleton. Go to the terminal and execute lein run.

This will compile the application and start an embedded web server listening on port 3000.

Configure a Different Port For a Web Application

Since many Clojure web applications use port 3000 by default, it can be useful to change the port to another one if you want to avoid conflicts.

For instance, I use the port 3003. You can change this setting in config.edn file.

Add a Simple Welcome page

As a first step, we just want to modify the main page to show a title of our shiny new web application.

To make it easy, we’ll use Hiccup to generate HTML on a server:

(defn render-home [books]
    [:body [:h1 "My Bookshelf"]]))

Notice, that we ignore the input argument books for now. We just want to show a static text.

Now run the application (if you haven’t run it already) and open the main page in a browser:


That’s it!

We managed to generate a skeleton for a new Clojure web application, set up a PostgreSQL database and display our first primitive HTML page rendered by Hiccup.

In the next post, we’ll add a basic functionality like showing the list of books to the user.

Source code

You can find complete source code for My Bookshelf in master branch. Beware that this is the latest version and it might be confusing to use it while reading this article.

The version corresponding to this post is tagged (git tag) as 01-skeleton and you can find it in Releases tab on GitHub.


My (Clojure) learning strategy

In this post, I’ll discuss the general learning strategy and show an example how to apply it to Learning the Clojure programming language.
I was heavily inspired by 10-step learning process from John Sonmez which I first encountered in his book Soft Skills: The software developer’s life manual and the process outlined in the book Novice to Expert: 6 Steps to Learn Anything, Increase Your Knowledge, and Master New Skills by Steve Scott.

The past

I used to approach learning new things without a strategy.
When I found a cool piece of technology that I’d like to know more about, I  spent a weekend by reading about it. I might have tried to play with some code a little, but mostly only by copying exercises from the tutorial into console/editor. Once the weekend was over, I just ran out of time or got distracted by some other cool technology and never got to the former one again. I might even have forgotten that I read about that thing at all.
I burnt thousands of hours without actually learning too much. I thought that I could rush through the tons of information and actually learn it.
It doesn’t work that way – not for me.

A better approach

If you really want to learn something you need consistency. You have to accept that it will be boring. You must prepare yourself for the hard work – there are no shortcuts.
Having that said, what are my tips for learning Clojure or any other topic?

Focus on a single learning project at a time

  • Learning new complex topic is already hard, and you’ll make it a lot harder if you try to learn many different things at once.
  • Especially, if you have a full-time job try to focus on a single topic. This approach will increase your chance to finish it in a foreseeable future.
  • Trying to learn many new things at once will probably result in frustration, and you will end up failing at all of them.

Create learning plan

  • To succeed you need to start with a clear S.M.A.R.T (Specific. Measurable. Achievable. Relevant. Time-boxed.) end goal in your mind.
    • An example of a bad goal: “I want to learn Clojure and ClojureScript”
    • An example of a better goal: “I’ll learn enough of Clojure, ClojureScript and web development libraries so that I can build the first version of a non-trivial Clojure web application with REST API and simple UI within three months”
      • Here I’m playing with an idea to create My Bookshelf application for simple book management (I love books).
  • Another key point to realize is that you don’t need to achieve mastery in everything you want to learn. Try to always identify the desired level from 1-10 (1 – very basic overview; 10 – mastery).
  • More details later in section 10-step learning process

Execute the plan on a daily basis

  • A consistent, deliberate practice is essential for success
  • Reserve at least 0.5 h each day for mastering new skill
    • The minimal duration can vary, but I’d rather recommend spending at least 1 hour working on your project each day
  • Work on each step in iterations until you finish all steps – one step at a time
  • Two tasks daily rule
    • one repeating task
      • You can practice Clojure programming skills via Exercism.io, 4Clojure, or Clojure Koans.
      • You can also decide to spend time by reading a relevant book and trying out the examples
    • one task from a project list
      • Pick one task from your project and try to complete it.
      • For example: “Create a project structure for My Bookshelf application. Create git repository and push the skeleton.”
  • Focus on practical experience rather than just cramming a huge amount of information from books and the internet into (and out of) your head
    • Create a learning project to practice everything you want to learn

Example of 10-step learning process

What follows, is my implementation of 10-step learning process outlined in Soft Skills: The software developer’s life manual by John Sonmez.
The example demonstrated here is for My Bookshelf Clojure web application:

Step 1: Get the big Picture – 50,000 ft view

  • I’ve already written some Clojure/ClojureScript code in the past and read lots of articles and Living Clojure book.
  • Following are my observations:
    • I know what I want to do: Create a web application for book management.
    • I know what other options I have (GoodReads, Libib, etc.) but none of these options seems to be suitable for my needs.
    • I know a little bit of Clojure/ClojureScript so I can get started.

Step 2: Determine the scope of what you want to learn

  • I want to build a real application that I can use for my own book management.
  • I’ve identified various features – this will be an ongoing project.
    • I even have Trello board for tasks related to this project
  • As a first milestone, I want to implement MVP using some libraries mentioned in Web Development with Clojure book.
  • I want to embrace REPL driven development combined with TDD – I’ll write a lot of tests.

Step 3: Define how the success will look like

  • My Bookshelf is up and running (at least on my local computer) and I’m able to add new books to bookshelf database, update or delete existing book, list all books, show book detail.
    • MUST-HAVE: basic attributes like “Title”, “Author”, “Year”, and “Status” (to distinguish books which I want to read/buy and those which I’ve already read/bought)
    • COULD-HAVE: further attributes can be added if useful for practical usage
    • NICE-TO-HAVE: the ability to search books by keywords on Amazon, show the results and be able to select the book which I want to add.
  • Book database is persisted across different runs of the application.
  • There’s at least primitive UI which can show me a list of books that I’ve added.
  • I have an automated acceptance test checking the supported features.

Step 4: Find resources

Step 5: Create a learning plan

  1. DONE. Define learning strategy & resources
  2. Read the first parts of Clojure applied and Web Development with Clojure, 2nd ed. to know how to start
  3. Create application skeleton – client and server part -> Display hello world
  4. Create the first draft of application domain; in-memory store
  5. Write some tests
  6. Primitive read-only UI showing the book list
  7. Persist entities to survive application restart
  8. UI for adding a new book
  9. UI for updating & deleting existing books
  10. Redesign domain/data model based on recent experience
    • Use Clojure.spec?
  11. Add possibility to store details (notes) about the book
  12. Book tags
  13. Add basic search
  14. Track/watch books
  15. Iterate adding new features; evaluating different options/libraries/frameworks

Step 6: Filter the resources

Most important resources from step 4. Find resources:

Step 7: Learn enough to get started

One example could be Reading the first chapter in Web Development with Clojure, 2nd ed. and then generating new project structure from leiningen template.

Step 8: Play around

For example: Examine the application skeleton generated in the previous step and play with the application in REPL. Try to execute some DB queries and make sure you are familiar with each important part of the project structure.

Step 9: Learn enough to do something useful

The result of this step should be adding a new feature to your project, e.g. Implementation of “Add a New Book” feature.

Step 10: Teach

Teach what you learned to others. This is a great way to make sure you have a solid understanding of the material you’ve learned. The other persons can be your colleagues, friends, local meetup group, readers of your blog, or even your spouse.

6 steps

While outlining the 10-step learning process and executing it on a daily basis, it can help you to think about 6 steps which Steve Scott mentions in his book Novice to Expert: 6 Steps to Learn Anything, Increase Your Knowledge, and Master New Skills.
This book deserves its own blog post, so I’ll just very briefly summarize the 6 steps:
  1.  Identify your learning style
    • Different people tend to favor different learning styles – social, solitary, visual, aural, verbal, physical, logical.
    • Try to identify 2-3 learning styles which suit you best and embrace them.
  2. Pick a skill you’d like to master
    • Choose a single skill – identify #1 goal you’d like to accomplish.
    • Focus on one skill at a time.
    • Pick your desired level of expertise.
  3. Build the learning habit
    • The quickest path to skill mastery is to focus on this area completely.
    • Focus on daily training.
    • Practice just-in-time learning – research information related to the next step, ignore everything else.
  4. Take actionable notes
    • Check out Cornell Method. It’s a very useful way to capture, understand and review a learning material.
  5. Build a project around a skill
    • In order to learn something, you need to practice it.
    • Create a real-world project for the skill you want to master and apply the things you’ve learned in the project.
  6. Deliberate practice
    • Deliberate practice is the most important thing; talent is usually of minor importance.

Final thoughts

I’ve provided you with an example how to create a learning strategy for Clojure project. I’ll definitely write more blog posts about my My Bookshelf learning project in the future.
For more on How to discover your learning style, Pickup the skill you’d like to master, Building the learning habit, Taking actionable notes, Building a project around a skill and Deliberate practice, you can read the Novice to Expert book or just wait until I write a blog post about it :).
Now, go ahead and pick a new skill you’d like to learn. Then create your learning plan and start executing it.

Random excerpts from Brno Clojure Meetup

Last week, I was quite happy to attend (:brno Clojure) meetup. There were only five people including me. Nevertheless, we had a great time and covered a lot of topics. There was no main theme, just live free and spontaneous discussion about our experience with Clojure. We discussed following topics:
  • server-side template duct
    • easy-to-use template for getting started with Clojure web
    • how is it different from chestnut?
  • liskasys
    • Karel Miarka’s own project
    • Uses Datomic
  • Emacs/Spacemacs vs. Cursive
    • Spacemacs has lots of preconfigured plugins => easier to use
      than plain Emacs
  • Korma SQL
  • “Specs” for re-frame application state db
    • It can be better to not enforce using spec for app-db because the additional value is not so high and it can lead to tedious updates of spec whenever you add something to app-db
  • Usefulness of namespaced keywords
    • avoid conflicts: same keywords in different namespaces
  • Pitfalls of debugging CLJS
    • unclear error messages
    • hard to find root cause
  • Logging
    • log whole Clojure data structure instead of standard log
      • you can then process logs with clojure (search, filter, …)
  • Using Ansible for automatic deployment
  • Component reloaded workflow
    • figwheel-like experience on backend
  • Figwheel
    • re-load on save vs. reload explicitly (triggered by keyboard shortcut)
    • explicit reload gives us a better control
  • Ideas for next meetups
    • Applications / System showcases
      • demonstrate the apps we are working on
      • discussion, best practices
    • Coding dojo – we can work together on 4clojure problems or similar
    • Invite Pavel Tisnovsky
      to Brno Clojure meetup
I’m really looking forward to the next Brno Clojure meetup.
I’d be love to see more people there as well.

Why do I want to learn Clojure and why you should too

Since 2010, I’ve been interested in functional programming and non-Java JVM languages, most notably Scala & Groovy.

However, whenever I tried to learn Scala, I ended up confused. I started with a passion, but the complexity of the language perplexed me. I love the ideas of Functional Programming:

  • pure functions
  • avoiding mutable state
  • no side effects

But I’ve found it difficult to write clean code in Scala. I never really understood the language. I felt it was a way harder to learn it properly than it should be.

On the other side, Groovy is easier to understand, but I can’t see much of value to justify using it in production. Sure, I’ve used it quite a lot for unit testing and even for some scripting, but I’ve never gotten much further.

My way to Clojure

Around 2013, I heard about Clojure and got interested. This was the first time I met a strange LISP-like language with all those braces. I read a chapter about Clojure in the book The Well-Grounded Java Developer. At the beginning, I wasn’t very convinced that Clojure code is more beautiful or readable than Java code., but I was getting curious.

From time to time, I read some article about Clojure, played a little bit with it and even watched some of Rich Hickey’s talks. I discovered fantastic and thriving Clojure community (Clojurians slack is awesome). I bought a copy of The Joy of Clojure, started to read it – and failed eventually. I wasn’t prepared.

For some reason, I still felt the growing need to explore and learn about this new world:

  • Why is that everyone in Clojure community is so excited about the language?
  • Does it really bring fun to programming again?
  • What are these immutable data structures and why are they so useful?
  • What does it feel like to use a dynamic language on a large scale?
  • Can we indeed write a concurrent code in a less painful and a more reliable way?
  • How can I leverage the power of Macros?
  • What are the benefits of using (almost) the same language on backend and frontend? (Clojure vs. ClojureScript)
  • Are the big systems written in Clojure, in fact, so much more compact than their Java counterparts while still being readable and maintainable?

This blog is my attempt to answer those questions.