1. 8
  1. 8

    @roryokane had good recommendations, so I want to talk about a broader issue I see here. In a couple earlier posts you say

    As he [OP’s brother] is a seasoned programmer, he would guide me and help me through the process. One of the books was Miran Lipovaca’s Learn You a Haskell for Great Good! (A Beginner’s Guide) and the other one was Practical Clojure.

    Both of those books are for experienced programmers, not beginners. It’s really odd he’s recommending those.

    -“Exactly as I suspected” said he [brother]. “You use the default layout, which is QWERTY, and it is not very finger-friendly.” … -“There is a better layout out there, called Colemak.


    Most programmers touch-type just fine on QWERTY. He made you spend a week switching your keyboard layout for no reason.

    People are giving you bad, newbie-hostile programming advice. Not sure about the Clojure stuff, but your brother definitely is. A lot of your perception of what programming is like might be warped by that.

    1. 1

      Yes, those two books are definitely not for beginners. Perhaps he overestimated my ability as a programmer.

      I switched to colemak because it was more pleasant layout for typing in general, not just for the sake of typing code. I definitely can agree that it is not a priority, but nevertheless I am glad I made that switch.

      Thanks for the comment, it’s important for me to see different perspectives so I can get better picture about programming world and community

      1. 3

        I think the programming world has a big problem with this “incidental complexity” thing in introductory courses. A friend of mine who is a designer (and not technical at all) decided he wanted to learn HTML and CSS, so he started a course that came recommended. One of the things these guys had him do was sign up for a GitHub account and use that to host a website. You wanted to learn HTML and CSS, so now first you’re shaving the yak known as learning Git. WTF (I’m not just complaining, all this stuff was a big sticking point for him)

        SICP is great but it has this problem where in one of the first lessons they start with some mathy stuff like Newton’s method of division. It probably made sense for MIT students, but it’s probably also rather offputting for the not-so-mathematically inclined. And many other books start with the syntax first.

        I really liked The Little Schemer because it’s so basic that anyone with a basic high school education can work through it. Unfortunately, people think it’s not “serious” enough because you don’t actually get to write programs that do useful things with it, and some don’t like it’s playful “childish” tone.

        There’s just so much nonsense that comes into programming that really distracts beginners. Any language that requires a separate compiler and editor would be overkill, for example. Any language that requires boilerplate like static int main(void blah blah blah) { } is also not great because then you have to explain that first (or tell the student to just accept it for now).

        1. 2

          The motivation of the learner is the most important thing. Boilerplate is tolerable. More important is to build something useful in the first session.

          If the goal is to build websites then go straight for Javascript. If the goal is lightweight data analysis then Excel. For more hardcore data analysis R Studio or Python Jupyter. For game programming go for Unreal/Unity/Godot or maybe even just some level editor. Someone who is familiar with electronics would probably have more fun with an Arduino. For kids there is Scratch.

    2. 4

      There is no book that I know of that teaches Clojure to new programmers. As OP notes, all assume that the reader knows how to program, and focus on the language features. Most don’t cover “big idioms” like functional programming (FP) or data oriented(/driven?) programming. I had to figure these out through practice and being inspired by other people’s code (caveat: there is no authority on Clojure style, just a continually evolving zeitgeist).

      But… there have been past initiatives at teaching new programmers using lisps: SICP, HTDP, The Little Schemer (and conversions of these to Clojure can be found).

      …but, these books tend to diverge quite quickly from Clojure style and approaches (FP, DDP) and sometimes focus on (IMO) academic esoterica of some of the languages involved and not practical matters. (My bias is showing; I care mostly about “programming as engineering” rather that “programming as computer science”).

      In the Clojure community, the ClojureBridge effort has produced some good intro material. As has the work on Maria (search Maria Clojure).

      I teach new programmers at a bootcamp and I have to use JS (which is particularly bad for newcomers IMO) and it’s wild-west “style” of programming. But I’ve also started newcomers on Clojure, FP and DDP with Clojure, and I’ve found that it is very accessible. Many think that Clojure, Lisps, or FP are harder (than C-style syntax, imperative programming, or OOP), but my anecdotal observation is that lisp + FP are much easier to learn (I think that for typical experienced programmers, Clojure and FP require a lot of “unlearning”, which makes it seem hard. My father, who used to sling assembly and later C, back in the day, recently got curious about my use of Clojure, perused the syntax and asked me: “OK… Easy enoug. But… How do I make a loop that changes a variable?”… and was dumbfounded when I answered “Well… You can, but you almost never do that”).

      Clojure’s barebones syntax reduces initial barriers incredibly (compared to even python). Literal data structures are easily grokked too (I usually spend a lot of my early teaching time on representing various situations as data). Pure functions are pretty easy to grasp too. Sure there are a bunch of functions to learn and gradually add to your toolbox, but really, the key thing is learning “computational thinking”, and Clojure and FP tend to get out of the way. Overall, I think the “notional machine” (mental model of the machine that your code is controlling) that new programmers must learn for Clojure+FP is much simpler than almost all other alternatives. It’s also why I think many of us like using it professionally (it’s easier to “think in” and gets out of the way when trying to solve problems).

      Anyway… If you’ve read this far… I’m curious if you think there’s value in a Clojure + FP + DDP for New Programmers book (/ or other style resource), in the scope of something like HowToDesignPrograms? Would you buy it for a friend or son/daughter?

      It’s an idea I’ve been tinkering with… I have some initial scribbles at https://www.github.com/cognitory/introduction-to-programming . Would also love to collaborate with others.

      1. 1

        I also think that clojure (lisps in general) are “easier” to learn than C-style, imperative or OOP, and also you’re right IMO about the “unlearning” part. That’s why I chose Clojure: It’s a modern lisp, powerful, can get all the benefits from running on JVM, and last but not least: it seems that Clojure grows every year in usage in implementations, so that means more job opportunities.

        I would definitely be interested in a book that teaches you programming and also clojure in a way that you build something useful (app, game, web application etc.)

        Also, when writing such a book, one shouldn’t compare clojure/lisps/FP with other more popular styles/languages (JS/C++/Java/Python, OOP and so on) because that is not relevant for beginners IMO. It should be “this is Clojure, this is how you make stuff/solve problems with it”, using functional approach and style.

        Can you please elaborate on what do you mean by “programming as engineering” and “programming as computer science” because I’m not sure I understand the difference.

        1. 4

          I don’t have rigorous definition for “programming as engineering” and “programming as computer science” but I’ll give it a shot:

          “Programming as Computer Science”

          • how you’d be taught programming as part of a comp sci degree program
          • “programs are written for the compiler to read”
          • focus on “theory”, compilers, programming-language-features (type systems, tail-order-optimization, monads)
          • explaining FP as an “applied version of the lambda-calculus”

          “Programming as Engineering”

          • how you’d be taught programming as part of a bootcamp, college degree
          • “programs are written for other programmers to read”
          • focus on “practice”, getting-things-done
          • explaining FP as “use pure-functions, avoid state; think about programs differently than OOP”
          • how do we programs so that we can work on large projects with many people over time

          Related: https://josephg.com/blog/3-tribes/

          1. 1

            Thanks for clarification. I now understand what you meant

      2. 3

        When I learned clojure (admittedly as an already experienced programmer) I followed aphyr’s excellent blog series “clojure from the ground up” (https://aphyr.com/posts/301-clojure-from-the-ground-up-welcome). I tried Clojure for the Brave and True first, but somehow didn’t manage to stick with it, while aphyr’s guide was the one that did it for me, you should check it out!

        1. 2

          What seems to be missing, in my opinion, is a book that is written for beginners in programming, that teach you programming while teaching you the language.

          There are many such books out there, at least for other languages than Clojure. When I took a programming class in high school, I learned a lot from the free online textbook we were using, Introduction to Computer Science using Java by Bradley Kjell. I think that book would be good for self-learners, too. I liked its style of asking questions at the end of each page to keep you thinking. The downside is that the book teaches Java, a language that is often cumbersome to write in – certainly more cumbersome than Clojure. But learning any second programming language is relatively easy after you have learned your first.

          Though it may be easier to find beginners’ books for languages other than Clojure, I acknowledge that switching focuses from your original choice of language may be a bad idea. It is easy to get caught in a trap of always hearing about a better way of doing something and switching to it before you have learned much, causing you to spend all your time reading introductory materials and no time actually doing the exercises and learning things.

          Given that you want to learn Clojure, maybe there are more beginner-oriented books you haven’t considered. I noticed there’s a book Getting Clojure by Russ Olsen that was published a year ago. Reading the chapter excerpts linked on that page and the reviews on Goodreads, it looks like that book might be basic enough to be suitable for beginners. You can read the excerpts yourself and decide.

          1. 1

            Thanks for the time you took to write a post thorough like this. Yes, I agree that second language is relatively easy when you’ve learned your first, but I’m still struggling with my first :) Not for long, I hope.

            The thing about switching languages and keep getting stuck reading introductory materials is what I got trapped in, I think. But that’s why I’m going to stick with Clojure and not get distracted by trying to do something in other languages, at least for now.

            Getting Clojure is a book that several people recommended, alongside Clojure for the brave and true. I’ll definitely check it out.

          2. 2

            Not clojure or lisp, but this is a book I would have liked to have read starting out:


            Otherwise, what drove me and a lot of self taught people was having a project I wanted to do, and learning programming was the only way to do it. For me that was game development. Spoiler: game development is really hard!