What do you think?
Rate this book
Getting Clojure
Behind every programming language lies a vision of how programs should be built. The vision behind Clojure is of a radically simple language framework holding together a sophisticated collection of programming features. Learning Clojure involves much more than just learning the mechanics of the language. To really get Clojure you need to understand the ideas underlying this structure of framework and features. You need this book: an accessible introduction to Clojure that focuses on the ideas behind the language as well as the practical details of writing code.
260 pages, Paperback
Published April 20, 2018
65 people are currently reading
192 people want to read
Ratings & Reviews
Friends & Following
Create a free account to discover what your friends think of this book!
Community Reviews
Displaying 1 - 21 of 21 reviews
December 31, 2018
A good intro to Clojure, but nothing more than that. There's nothing of value in the book for an experienced Clojure developer.
"Getting Clojure" has a slightly different structure than most intro Clojure books - doesn't focus so much on concurrency and offers only a minimal coverage of more complex features (e.g. dealing with state and macros), which is a good idea for an intro book IMO. Generally concurrent programming is barely covered here and I recall that older Clojure books made a lot of fuss about it. Lesson learned I guess - Russ had the opportunity to observe how Clojure's actually used in the wild and focus on what matters the most.
Russ's writing style is fluid, clear, fun and engaging. I loved his Ruby work in the past and I'm happy to see him in the Clojure realm these days. If you've read any of his Ruby books (e.g. "Eloquent Ruby") you'll find lots of similarities with "Getting Clojure". I can certainly recommend the book to anyone looking to learn Clojure!
"Getting Clojure" has a slightly different structure than most intro Clojure books - doesn't focus so much on concurrency and offers only a minimal coverage of more complex features (e.g. dealing with state and macros), which is a good idea for an intro book IMO. Generally concurrent programming is barely covered here and I recall that older Clojure books made a lot of fuss about it. Lesson learned I guess - Russ had the opportunity to observe how Clojure's actually used in the wild and focus on what matters the most.
Russ's writing style is fluid, clear, fun and engaging. I loved his Ruby work in the past and I'm happy to see him in the Clojure realm these days. If you've read any of his Ruby books (e.g. "Eloquent Ruby") you'll find lots of similarities with "Getting Clojure". I can certainly recommend the book to anyone looking to learn Clojure!
September 14, 2018
There are only a handful of tech authors that I blindly recommend to everyone. Russ is one of them. And this book again shows why. Good storytelling and great introduction into Clojure. Can't wait for his next book. Whatever that will be, I am sure I will read and love it :) .
March 23, 2018
This is an excellent book for Clojure newcomers!
It's divided into three parts (Basics, Intermediate, Advanced) and twenty chapters. It covers many important topics like syntax, (lazy) sequences, core data structures, higher-order functions, polymorphism (multimethods and protocols), local bindings (let), vars, managing state, java interop, spec.
Mostly, it doesn't go into very much detail, but I do think it's an excellent start.
The things that distinguish it from other Clojure books for beginners:
* The practical examples (ring, clojure.core, Overtone, etc.) that really help to understand the features.
* "Staying out of Trouble" sections
* Chapter 19. Read and Eval - or how easy is to write very basic Clojure interpreter. I've heard this mentioned so many times yet so few books will actually show you what does it really mean in practice.
* Property-based testing (chapter 14) - this was the first I really touched the property based testing, other than using basic clojure.spec.test.alpha APIs
One thing I really wish was covered more is Spec and how to approach domain modeling in Clojure.
You also don't find a lot of advice how to actually structure bigger applications, but I guess that's a sweet spot for intermediate Clojure books like "Clojure Applied".
To sum up: I think this book is an excellent addition to the existing Clojure books and it may be worthwhile to read it together with "Living Clojure" or a similar book.
DISCLAIMER: I'm not a beginner. I've read some Clojure books and I've been seriously programming in Clojure for at least 1 year. Yet I still find this book valuable and nice to read.
It's divided into three parts (Basics, Intermediate, Advanced) and twenty chapters. It covers many important topics like syntax, (lazy) sequences, core data structures, higher-order functions, polymorphism (multimethods and protocols), local bindings (let), vars, managing state, java interop, spec.
Mostly, it doesn't go into very much detail, but I do think it's an excellent start.
The things that distinguish it from other Clojure books for beginners:
* The practical examples (ring, clojure.core, Overtone, etc.) that really help to understand the features.
* "Staying out of Trouble" sections
* Chapter 19. Read and Eval - or how easy is to write very basic Clojure interpreter. I've heard this mentioned so many times yet so few books will actually show you what does it really mean in practice.
* Property-based testing (chapter 14) - this was the first I really touched the property based testing, other than using basic clojure.spec.test.alpha APIs
One thing I really wish was covered more is Spec and how to approach domain modeling in Clojure.
You also don't find a lot of advice how to actually structure bigger applications, but I guess that's a sweet spot for intermediate Clojure books like "Clojure Applied".
To sum up: I think this book is an excellent addition to the existing Clojure books and it may be worthwhile to read it together with "Living Clojure" or a similar book.
DISCLAIMER: I'm not a beginner. I've read some Clojure books and I've been seriously programming in Clojure for at least 1 year. Yet I still find this book valuable and nice to read.
November 19, 2018
Small and concise chapters, guiding you through a concept at a time. You can end the book understanding if Clojure could be your next gig or not. Spoiler: it will be. You will be fascinated on what this prog lang could do without learning loads of information and function names. Russ has a great way to present all this new data without make the reader suffer to reach the end of the book.
May 25, 2020
A fantastic introduction to Clojure! My biggest takeaway from the book has been the ability to read Clojure code. I'm still not fluent at writing Clojure (that perhaps requires more effort and practice on my end) but this book has definitely given me a solid grounding to start exploring the whimsical world of Clojure.
October 15, 2018
Best book summary of the ideas behind Clojure, and really sets the context for understanding clojure.spec for both validation and test data generation.
Compares favorably with the goofier Clojure for the Brave and True and the older Joy of Clojure. My current choice for a one-book guide to Clojure.
Compares favorably with the goofier Clojure for the Brave and True and the older Joy of Clojure. My current choice for a one-book guide to Clojure.
May 24, 2019
Absolutely brilliant book about beautiful programming language.
Very well written. Pure reading joy.
Very well written. Pure reading joy.
May 10, 2023
As a polyglot programmer, the process of going through how-to-define-a -variable, how-to-define-a -function, how-to-use-text-editor, etc. when reading through an introductory book of a new programming language becomes really tedious. What I care about is not what do the language features do, but how are they designed that way, what problems would occur if these features are abused/misused/misunderstood, etc. To answer these questions, I often find myself wandering around GitHub libraries for hours reading code and jotting down "exemplary code snippets" in which language features are well-demonstrated. I don't often expect someone to curate these examples for me.
"Getting Clojure" and the Haskell book (coincidentally, written by a former Clojurist who now found sanctuary in Haskell) have been the only 2 times I could count on a introductory material for the whole process of learning a new programming language.
With that being sad, this book worth more than just 5/5 stars!
"Getting Clojure" and the Haskell book (coincidentally, written by a former Clojurist who now found sanctuary in Haskell) have been the only 2 times I could count on a introductory material for the whole process of learning a new programming language.
With that being sad, this book worth more than just 5/5 stars!
Read
November 21, 2018cuốn mới nhất của tác giả, sau mấy cuốn ruby đình đám(mà intro quá đọc ko phê :3). Sau khi bị SICP thuốc đã nhảy sang lisp land, làm 1 core contributor cho clojure trong khi bình thường dân ruby hay nhảy qua elixir.
phần giới thiệu khẳng định luôn clojure là dream language của lão :))
http://russolsen.com/articles/2018/04...
phần giới thiệu khẳng định luôn clojure là dream language của lão :))
http://russolsen.com/articles/2018/04...
October 18, 2018
Simply excellent. Russ Olsen starts with the very basics but builds up to more advanced concepts while never letting the reader feel lost.
The book is comparable to Clojure for the Brave and True but has less silliness and I must say I feel this is the better book.
The book is comparable to Clojure for the Brave and True but has less silliness and I must say I feel this is the better book.
May 26, 2018
Computering can be difficult. Our minds don’t naturally work in the way programming languages prefer. This is especially true when changing paradigms, such as from imperative or object-oriented programming to functional programming. The best medicine for this difficulty is a guide, mentor, and friend to help you through the rough spots, to make things understandable and relatable.
With ‘Getting Clojure’, Russ Olsen becomes that friend. He engages with a wry humor and conversational tone, pulling them effortlessly from topic to topic. In place of dry facts and bare, thin syntax, he provides just enough context to understand the why as well as the how, while helpfully pointing out the tripwires and bear traps on each topic. If you have been wishing for a smooth transition into Clojure, this book should be your first choice.
The details:
The book builds content in exactly the order you’re likely to fall down, except for state and mutability. Most imperative programmers are going to bump their face on the topic of mutability/state way earlier than it’s addressed in the book, for two reasons: first, we tend to build toward statefulness much too early. Second, Clojure’s language choices discourage its widespread use. In a functional style, mutable state goes in as late as possible. Don’t fret—if you’re reading and start wondering where you can stick your changes, skip ahead and read the ‘State’ chapter, then come back to where you left off.
The topics list, starting with the ‘basics’ section: capturing and organizing data, making decisions and controlling flow, functions and functional flexibility, scopes from local to global. On to intermediate content: sequencing and laziness, firmer and definable data structures, testing and specification. Finally, the grab bag of advanced topics: java interop, concurrency, state/consistency within mutation, and finally, macros. The first two sections build nicely. At some point, as an author you have to decide which advanced topics you’re going to take on—Olsen makes good choices here.
Finally:
It’s an enjoyable read. If it had been available when I was trying to learn Clojure, I wouldn’t have done so in fits and starts, with much frustration. It’s just enough information, in good order, and never boring. While learning a new language is never easy, Getting Clojure gives you a friendly native guide.
With ‘Getting Clojure’, Russ Olsen becomes that friend. He engages with a wry humor and conversational tone, pulling them effortlessly from topic to topic. In place of dry facts and bare, thin syntax, he provides just enough context to understand the why as well as the how, while helpfully pointing out the tripwires and bear traps on each topic. If you have been wishing for a smooth transition into Clojure, this book should be your first choice.
The details:
The book builds content in exactly the order you’re likely to fall down, except for state and mutability. Most imperative programmers are going to bump their face on the topic of mutability/state way earlier than it’s addressed in the book, for two reasons: first, we tend to build toward statefulness much too early. Second, Clojure’s language choices discourage its widespread use. In a functional style, mutable state goes in as late as possible. Don’t fret—if you’re reading and start wondering where you can stick your changes, skip ahead and read the ‘State’ chapter, then come back to where you left off.
The topics list, starting with the ‘basics’ section: capturing and organizing data, making decisions and controlling flow, functions and functional flexibility, scopes from local to global. On to intermediate content: sequencing and laziness, firmer and definable data structures, testing and specification. Finally, the grab bag of advanced topics: java interop, concurrency, state/consistency within mutation, and finally, macros. The first two sections build nicely. At some point, as an author you have to decide which advanced topics you’re going to take on—Olsen makes good choices here.
Finally:
It’s an enjoyable read. If it had been available when I was trying to learn Clojure, I wouldn’t have done so in fits and starts, with much frustration. It’s just enough information, in good order, and never boring. While learning a new language is never easy, Getting Clojure gives you a friendly native guide.
June 16, 2019
Started reading this book on a Thursday and finished on a Sunday, enjoying every page.
For background, I'm a novice-intermediate at Clojure ... good enough to write web apps in it, good enough to be functionally minded even! But it's clear that my code is pretty hamfisted at times and my functions often feel like slabs rather than the supposedly beautiful shapes that Lisp developers tend to advertise themselves as writing. Things like spec intrigue me and frighten me and confuse me. Propert Based Testing is something that I could only understand as awesome but never really understood how to use.
This book is git a sweet spot in that it didn't linger too long over the basics or even the gist of the advanced topics it was trying to explain, but showed just enough to get into the philosophical crux of why one would want to hone skills in those areas. The beauty of this book is that it actually does a good job of explaining to someone who _does not yet think_ in Clojure the steps and orientation they should begin to have (I feel that a lot of authors who have it this point do so in a utopian way but are too far enlightened to articulate that enlightenment in the coarse thinking many of us yet require)
This book has made me far less afraid of spec, of property based testing, of lazy sequences, and of macros. I feel motivated to jump into the REPL and just _play_, rather than feeling bad because I don't know what a transducer is. This book doesn't explain what those particular things are (which I only know about because Clojurists gush about them all the time) but I feel more comfortable with the idea that there is a simple explanation and use case and mental framework for them just waiting to be expressed.
I highly recommend this book as part of one's "thinking in Lisp" bookshelf; it doesn't wrestle you into the great leaps of cognition that the academic exemplars (SICP, The Little Schemer) do, but it is an approachable book that comforts you and promises you that there are practical and enjoyable rewards for going down this path. It's a great little approachable read to recenter yourself on when your brain has discombobulated, and a comforting read when yo don't want to read a book you feel like taking a break from the feeling of being a brain navigating the cosmos.
For background, I'm a novice-intermediate at Clojure ... good enough to write web apps in it, good enough to be functionally minded even! But it's clear that my code is pretty hamfisted at times and my functions often feel like slabs rather than the supposedly beautiful shapes that Lisp developers tend to advertise themselves as writing. Things like spec intrigue me and frighten me and confuse me. Propert Based Testing is something that I could only understand as awesome but never really understood how to use.
This book is git a sweet spot in that it didn't linger too long over the basics or even the gist of the advanced topics it was trying to explain, but showed just enough to get into the philosophical crux of why one would want to hone skills in those areas. The beauty of this book is that it actually does a good job of explaining to someone who _does not yet think_ in Clojure the steps and orientation they should begin to have (I feel that a lot of authors who have it this point do so in a utopian way but are too far enlightened to articulate that enlightenment in the coarse thinking many of us yet require)
This book has made me far less afraid of spec, of property based testing, of lazy sequences, and of macros. I feel motivated to jump into the REPL and just _play_, rather than feeling bad because I don't know what a transducer is. This book doesn't explain what those particular things are (which I only know about because Clojurists gush about them all the time) but I feel more comfortable with the idea that there is a simple explanation and use case and mental framework for them just waiting to be expressed.
I highly recommend this book as part of one's "thinking in Lisp" bookshelf; it doesn't wrestle you into the great leaps of cognition that the academic exemplars (SICP, The Little Schemer) do, but it is an approachable book that comforts you and promises you that there are practical and enjoyable rewards for going down this path. It's a great little approachable read to recenter yourself on when your brain has discombobulated, and a comforting read when yo don't want to read a book you feel like taking a break from the feeling of being a brain navigating the cosmos.
Read
December 4, 2020Достойная книга для изучающих Clojure. В отличие от Programming Clojure практически все примеры работают. Среди прочего книга помогает понять логику некоторых решений, принятых при проектировании языка.
September 10, 2019
Good enough introduction to Clojure. I was expecting much, much more examples, though. If you are entirely new to Clojure (and to a point, Lisp), it is a good starting book. If you have some experience already, perhaps it will be too basic.
February 3, 2019
I knew i bit to much Clojure to benefit much from this book, but still a great read
May 13, 2020
Excellent even as a first book to learn Clojure and to understand it's full extension. The author takes you on a trip from beginner to advanced topics.
October 20, 2021
A fine book
January 29, 2022
Clear introduction to Clojure programming language.
September 6, 2022
Well written and will be my go-to recommendation for those that want to get into Clojure.
June 20, 2023
A wonderful introduction to Clojure.
October 21, 2024
Quick read and enlightening book to get started on Clojure. Recommended!
Displaying 1 - 21 of 21 reviews