This book offers a wonderfully clear introduction to Clojure, effectively highlighting its strengths in concurrency and handling immutable data. It's a great starting point for anyone looking to understand the core benefits of the language.
This book offers a solid, no-nonsense introduction to Clojure. While the examples felt a bit whimsical and weren't my favorite, they didn't detract from the overall learning experience. Higginbotham really shines when breaking down complex topics like macros, making them much more accessible.
This series is absolutely fantastic! I've really enjoyed diving into each book and can't wait to see what happens next.
This book is a solid choice for grasping Clojure's core concepts, and it does so with a refreshing lightness. While Chapter 2 points towards Emacs, don't hesitate to explore other editors like VS Code with the Calva plugin – I found it to be quite effective.
This book serves as an excellent primer for Clojure and the fundamentals of functional programming, hitting just the right length for a language as concise as Clojure. While a personal dip in motivation made progress slow, the effort was ultimately rewarding, delivering exactly what I aimed to learn. Be aware, however, that the pop-culture allusions might not resonate with everyone.
This book served as a decent, albeit somewhat quirky, introduction to Clojure. While the author's penchant for silliness occasionally muddied the examples, the core concepts were generally clear. I found the later chapters, particularly those on macros, to be the most valuable, as they covered new ground for me. Despite skipping a few sections, it provided a helpful crash course and I'll certainly keep it handy for future reference.
This book is an excellent resource for anyone looking to dive into Clojure. If you're interested in a Lisp-like language and want to have a blast honing your programming abilities with a functional style, I can't recommend it enough!
This book served as a fantastic refresher after a long break from Clojure. It efficiently covers a broad spectrum of topics with a light, engaging approach. While the early chapter on Emacs might not appeal to everyone, its content is easily skippable for those who prefer more contemporary IDEs.
This is a solid introductory book, perfect if you're new to both programming and Clojure. It offers amusing programming challenges and clearly explains how Clojure builds upon Lisp. I'd definitely recommend it for programmers familiar with other languages who want to broaden their horizons.
This book is a fantastic starting point for anyone looking to dive into Clojure and Emacs. The explanations are clear, and the practical examples make it a breeze to follow along, even for beginners. I've been using Clojure for a few months now, and I still find myself revisiting the online version for quick lookups. It's definitely a resource I'd recommend to anyone curious about the language.
This book is absolutely fantastic! I can't imagine another technical read making me laugh as much; the content is both hilarious and incredibly immersive. I picked up so much about Clojure, Leiningen, core.async, and even a bit of Java. For anyone looking to dive into Clojure, this is definitely the most accurate guide you'll find.
This trio of books from No Starch Press, featuring Land of Lisp, Clojure for the Brave and True, and Realm of Racket, offered a mixed bag. While Land of Lisp was a solid 5-star read and Clojure for the Brave and True earned a respectable 4 stars, Realm of Racket was a bit of a letdown at 3 stars. It was particularly disappointing given that the book was written by the founder of Racket, who also co-authored 'The Little Schemer'.
This book served as my gateway into Clojure and the Lisp family, and it's a truly solid introduction. The included Emacs tutorial was a lifesaver for setting up my environment, a step many other books conveniently skip. While I did find myself a bit lost in the later chapters during my first read-through, the real magic happens when you dive into the programming exercises. Although I admit I found the exercises a tad tedious and started skipping them, which definitely made the more complex topics harder to grasp later on. Still, given that all the information is freely available online, this is undoubtedly the best starting point for anyone curious about Clojure.
This book offers a solid starting point for Clojure and functional programming, managing to be both well-organized and engaging with its humor and clear examples. However, it falls short by omitting several crucial topics like the 'for' special form, agents, the expression problem, and strategies for handling complexity, not to mention a lack of explanation for currying, lambda calculus, and list comprehensions. For a more thorough understanding of these areas, seeking out additional resources is definitely recommended.
While the author clearly tried to inject some humor and make this programming manual engaging, it ultimately felt like a bit of a slog. The explanations often lacked depth, repeating the same points without much elaboration on the underlying principles. The examples, though amusing, sometimes sacrificed practical context, making it harder to grasp the core concepts. Despite these issues, the book does introduce some genuinely interesting ideas, and the language itself is worth exploring, particularly if you're curious about macros.
This book offers a solid foundation for anyone looking to dive into Clojure. While some sections might feel a bit wordy, the exercises are genuinely helpful for reinforcing the concepts. It's a great starting point for beginners, and for continued practice, Project Euler is an excellent resource. Plus, the full text is legally available for free online, which is a huge bonus!
This book offers a fantastic introduction to Clojure, though I found the humor and narrative style a bit hit-or-miss; sometimes it was engaging, other times I just wanted to skip ahead. Still, the lighthearted approach was a welcome change from typical dry programming texts. I really appreciated the topic progression and the concise explanations, which allowed me to quickly grasp the fundamentals and cover a broad range of the language, setting me up to explore specific areas later. My only minor quibble was the occasional use of functions not yet introduced, which briefly disrupted my reading flow.
This book's appeal really hinges on your preferred learning style for programming texts. It leans heavily into being entertaining and humorous, sometimes at the expense of clarity, which might mean longer, less direct code examples. If you're someone who values concise, straightforward examples, you might find yourself gravitating towards other resources like O'Reilly's offerings, which I personally found to be a better fit.
This book was a fantastic read, offering insights that extend far beyond just Clojure to programming as a whole. The author masterfully breaks down complex ideas with accessible language, engaging examples, and clever metaphors that truly stick. Plus, the exercises included in most chapters are invaluable for solidifying understanding. I'd definitely recommend this to anyone looking to sharpen their programming skills and expand their perspective.
This book definitely isn't for total newbies to programming; it dives right in without much preamble. The organization felt a bit scattered, jumping around in a way that made it tough to build a solid understanding of Clojure's core ideas. Plus, it could've really used more in-depth exploration of advanced features and practical, real-world uses. While it's a starting point, it needs some serious work on clarity and depth to truly be helpful.
This book is a solid starting point for anyone diving into Clojure. While some might find the humorous analogies distracting, I actually found them incredibly helpful for grasping the concepts and keeping the technical explanations engaging. The main drawback is its tendency to present examples before diving into the underlying reasoning, which can leave you wondering about the 'why' behind Clojure's unique features. Despite this, if you're new to the language or need a refresher, it's definitely a worthwhile read.
This book turned out to be an absolute gem, discovered quite by chance! It's packed with humor and incredibly practical examples, making it a joy to read chapter after chapter. Unlike most technical books that can feel like a chore, 'Clojure for the Brave and True' keeps you engaged with fun projects, from vampire hunting to building hot dog stands, making you feel like you're discovering programming all over again. The author masterfully guides you through Clojure's concepts, from the basics to macros and concurrency, and I can confidently say you'll be productive in the language after finishing it. It's easily one of the most enjoyable and educational technical books I've ever encountered.
This book is a fantastic starting point for anyone diving into Clojure. It clearly explains the fundamental concepts, and I was even able to immediately apply what I learned to implement a new feature at my job, which was incredibly rewarding. The abundance of examples and practice problems at the end really solidify the material, making it an overall excellent read for beginners.
As my first dive into Clojure, this book served as a decent introduction. The author's humor made it an enjoyable read, though I found myself wishing for more in-depth discussions on code design. Specifically, I'd have loved to explore the nuances of Records, Multi Methods, and Protocols in relation to OOP versus FP paradigms, as this felt like a topic ripe for deeper exploration within the Clojure community.
While I appreciate Higginbotham's writing, this book wasn't quite what I was looking for. Having already explored functional programming via Haskell and Lisp (Racket), and being drawn to Clojure for its practical reputation, I found it didn't quite hit the mark for me. Still, I'm grateful for the introduction to Emacs!
This booklist curated by Rich Hickey is a fantastic resource for anyone looking to expand their reading horizons. It's packed with insightful recommendations that are sure to spark new ideas and deepen understanding across a variety of topics. I've already added a few titles to my own must-read list!
This book is a fantastic starting point for anyone looking to dive into Clojure, covering everything from the basics of the language to essential build tools. While the author's unique humor might be a bit divisive, I personally found it to be a wonderfully refreshing change of pace.
This book serves well as an introductory text to both Clojure and functional programming. Working with Elixir now, I found many of the examples prompted me to rethink my approach to problems.
This book is a real gem! It's not just informative, but surprisingly enjoyable for a technical read. The author has done a fantastic job of structuring the content, offering just the right amount of detail to get you going without feeling swamped.
This book about Lisp is an absolute gem! It manages to be incredibly informative while also being genuinely funny, making it one of the most enjoyable computer books I've encountered.
