What are your favorite books?

Ben Lovy on November 06, 2018

There is an absolute wealth of technical knowledge found in books out there, but nobody has time to read them all. What's on the top of your "must... [Read Full]
markdown guide

Mazes for Programmers, looks an amazing Ruby book, I want to read. Thanks share. I need a great book to learn algorithm, maybe this is a fun and not boring one.

Authors I like include: Robert.M(3 Clean Books), Pragmatic(DRY), Kent.B(TDD), Fowler(Refactoring), Eric.E(Domain Driven)

Eloquent Ruby, is my ruby aha book.


Thanks for the author list! I've heard good things about Eloquent Ruby - it's definitely on the list if I keep exploring the language.

The mazes book wont replace a rigorous study of algorithms (there's no proofs or anything), but it's a great way to see them in action and start to figure out how to apply them.


Could you share some example code of mazes book so let us know if we can understand it?

Sure, here's a partial (but functional) implementation of the Cell class used in the book. It is not advanced Ruby, but the author does not spend any time teaching Ruby concepts - this code snippet appears early on in the first chapter and the assumption is the reader can understand it:

class Cell
  attr_reader :row, :column
  attr_accessor :north, :south, :east, :west

  def initialize(row, column)
    @row, @column = row, column
    @links = {}

  def link(cell, bidi=true)
    @links[cell] = true
    cell.link(self, false) if bidi

  def unlink(cell, bidi=true)
    cell.unlink(self, false) if bidi

  def links

  def linked?(cell)

  def neighbors
    list = []
    list << north if north
    list << south if south
    list << east if east
    list << west if west

And the simplest algorithm:

class BinaryTree
  def self.on(grid)
    grid.each_cell do |cell|
      neighbors = []
      neighbors << cell.north if cell.north
      neighbors << cell.east if cell.east

      index = rand(neighbors.length)
      neighbor = neighbors[index]

      cell.link(neighbor) if neighbor


Basic building blocks, but you do need to know what, for example, attr_accessor means

I'm following along in TypeScript and finding the translation straightforward.


_why's Poignant Guide to Ruby made programming fun for me again, years ago.

Michael Feathers's Working Effectively with Legacy Code is long and a bit dense, but it's an intensely practical look at navigating systems that are complicated, untested, and too big to fit in your head at once.

Sandi Metz's Practical Object-Oriented Design in Ruby looks like a simple primer on what OO is, but if one goes into it expecting to learn things it emerges as something much more multi-layered. I figure out something new every time I reread it. Her follow-up with Katrina Owen (99 Bottles of OOP) is also brilliant and is specifically structured to hack away at one's preconceptions.

James Coglan's JavaScript Testing Recipes is dense and not really what one would expect from a recipes book -- it's not "here's what to type in," it's about the theory of testing JS effectively. Because testing well changes the shape of your code, I learned a whole bucket about how to write effective, composable JS by paying attention to the edges of the book. I'm really looking forward to James's upcoming book on rewriting the Git internals in Ruby. (Disclaimer: he's a friend of mine.)

And then of course there's my book, Untangling Asynchronous JavaScript, which ought to be coming out in February or so. :)


Excellent! It seems like dropping everything and running towards whatever Sandi Metz has written is a pretty good policy, and I think the Poignant Guide probably gets the dubious honor of being the first programming text I ever read.

Testing theory is a huge gap in my knowledge, I'm definitely looking forward to exploring that book, and a HUGE congrats on getting so close to publishing! Let us know when we can buy it, yeah?


Awesome! That's 3 for Pragmatic Programmer, and thanks for the more general suggestions too - these sound like books everyone could benefit from.


For good reason, it's a fantastic book!

I noticed you lean toward FP, an area that I'm just starting to explore. I'm not sure how much Domain Driven Design will help in that realm.

Clean Code and Clean Architecture should have plenty of wisdom nuggets for both FP and OOP languages.


"First-Order Logic" by Smullyan. "Software Abstractions" by Jackson. "An Introduction to Mathematical Reasoning: numbers, sets, and functions" by Eccles.

There are a few more but those are at the top of the list. I think investing in general problem solving and thinking patterns always pays off and most of the time those skills are found in more mathematical disciplines. Not trying to discount the social sciences because they also have valuable lessons.


That certainly makes a lot of sense in this field. Looks like quite the list, thank you for the recommendations!


I've found Adaptive Code: Agile coding with design patterns and SOLID principles by Gary McLean Hall really good. I'm also currently reading The Pragmatic Programmer at the moment. It has loads of really good reviews but I've literally just started so I can't speak from experience.


The Pragmatic Programmer comes up a lot - I should probably get around to it sometime.

Thanks for the suggestions!


Ah that thread is actually very cool. Thank you so much Ben for starting it.

I purchased so many books during the last years (~100 mostly from manning and pragprog). OFC, I didn't read them all yet but I have already plenty to do with this.

I would absolutely recommend:

I've read that a some people recommend The Art of Computer Programming. I didn't read them myself but I've seen recommendations when I was looking at some reviews from other MIT Press books.


Awesome List! Grokking Algorithms is definitely worthwhile, I really like his style. I'm not familiar with the rest of your list, thanks for the suggestions!


Effective C++ by Scott Meyers. The guy is a C++ titan and has a lot of great insight on that language. This book is perfect for any c++ intermediate developer looking to make their code more efficient.


This book taught me how little I know about C++. I'm going to have to come back to it a little more equipped, but this seems to be a universal recommendation. Thanks!


At first it can seems daunting, but you only have to read the entire tutorials on cplusplus dot com and you should be fine to understand the book pretty well.


First these 3 in order. They are all about code quality. The order is in increasing depth and reasoning. (And number of pages).

  1. Building Maintainable Software
  2. Clean Code
  3. Code Complete, Second Edition

And then these (in any order) which are more about the process of programming.

These about pitfalls of software projects.

Some books I still need to read, but I think are probably good ones:


Wow! Amazing list, I love how many general book about the craft we've compiled. Thank you!


Seems like a good place to use some of an article I was writing on books I like:

Technopoly (1992) by Neil Postman

Technopoly cover

Technopoly is the most important book about technology of the 20th Century.

The book is short and dense with information and frameworks for how to think about the increasing abuse of technology to shape culture in ways that benefit the few at the great expense of the many's very humanity.

Technopoly is social criticism about technology, but it is not an anti-technology book; it is an anti-Technopoly book. Technopoly is a collection of radical normative claims about how technology should shape the world that people have increasingly adopted since invention became tied to commercialism and efficiency. It may seem obvious to us, as technologists, that more efficiency is inherently good, but this mindset that pervades our culture belies a gross disregard for other people. The Technopolist encourages others to disregard and denigrate the past in order to push their new products, disregarding alternative opinions as "Luddite." It places that efficiency of operation above consideration of the abilities of human beings, leading to the creation of new systems that don't serve humans well and the increasing estrangement of us from functional older systems in ways that make our lives strictly worse.

This happens because the Technopolist does not care about leveraging technology intelligently to pursue a better world. Instead, they pursue new technology as the end in and of itself, claiming that will be the cure to human suffering because because human suffering is caused by human inefficiencies. This leads to creating things without consideration of any negative consequences that reveal themselves later. Basically, they say "move fast and break things," because they very wrongly believe that the things that break couldn't matter. It is morbid misanthropy couched in techno-utopianism.

Further, as much as they phrase these ideals as the cure to society's ills for PR purposes, the reality is that our most difficult problems are social and cannot adequately be solved by the addition of new technology. Indiscriminate applications of technology can make them exponentially worse. One of the key reasons for this is that, technology does not sit neutrally in our world. The fact that technology can radically change the way that someone approaches one problem at hand is only the most germane possible consequence. A change to technological conditions can also radically change a person's sense of self. For example, consider how the addition of a vehicle fundamentally changes someone's sense of how big the world is, or how people in skilled jobs that are increasingly automated begin to view themselves as unskilled monitors. On top of that, it's important to realize that technology is designed, and we must be vigilant in understanding that the technologists behind it may want to direct that change to benefit themselves above others, such as how Facebook made itself somewhat indispensable by fundamentally changing the way interpersonal networking functioned with its emotional labor machine.

Technopoly reminds us that technology exists to serve us; humans do not exist to serve technology. It is important to actually analyze and evaluate the effects of new technologies instead of blindly moving from one to the next and assuming the answer must be a new technology. Furthermore, we must keep our guards up against Technopolists' encouragement to abandon our cultural memory. Often you'll find that many new applications of technology that have caused massive social welfare problems in our time are shockingly new.

  • Every company's leveraging of the internet to insert itself into your life or curtail your expectations of privacy must have come after the Internet, which only became commercially available about 30 years ago.
  • Andrew Wakefield's fraudulent anti-vaccination paper, which inspired much of the current wave of anti-vaccination insanity, was published in 1998.
  • Movie theatres once treated your ticket as the only payment necessary to see the film, and they only began requiring you to watch pre-film commercials in the mid-1990s.
  • The Originalist approach to the United States Constitution, used to provide inappropriate second-hand legitimacy to extreme conservative politics in the judiciary, was essentially invented and formalized in the 1970s, boosted by the Powell Manifesto.

These are blips in the cultural consciousness, but their creators want you to believe they are immutable and inextricable features of our world, that have always been this way and always shall be. They did not, and constant reevaluation of their place is essential so that their real consequences may be understood and properly mitigated. Technology, whether tool or toy or ideology, must be treated seriously and critically, not as a sacred cow.


This is a great write-up, and a very interesting topic. Mindfulness through progress is paramount yet difficult to maintain, and texts like this serve as much-needed anchors. This is some excellent food for thought, and definitely going on my reading list. Thank you!


The books I read was Head First Python, C# 2nd and 3rd edition - but i didnt finished them yet.

Also this year i started to read The Pragmatic Programmer but still not finished.

And i am planning to read the Eric Evan´s book about domain driven design.

Any hints?


That's two votes for the Pragmatic Programmer!


I agree with you, Ben.
Reading is not everything on development, but is actually something 😀
How about Hackers & Painters by Paul Graham?
I think you might like it because he's a Lisp programmer.
I haven't read any of your list ever but they seem interesting!


Neat! I enjoyed his On Lisp but hadn't heard of Hackers & Painters. I'll have to check it out!


Gonna +1 for The Pragmatic Programmer, as I credit reading that to much of my approach to development. I have a copy that gets passed from dev to dev in my office; the book is well worn but loved.

Release It! by Michael Nygard has also been a great read (not quite finished, but has been massively helpful already.


Awesome! Because of this thread I've started reading it and even just two chapters in I think I understand the hype.

Release It! seems like a great resource too for filling in some common sense that's hard to build on your own, thank you for the suggestion!


I wrote a small collection in LinkedIn long back about this. and i keep adding when more to the collection. please have a look.


Clean Code: A Handbook of Agile Software Craftsmanship (Robert C. Martin)

Code Complete Paperback by Steve

Refactoring: Improving the Design of Existing Code by Martin Fowler (Author), Kent Beck (Author),
John Brant (Author), William Opdyke (Author), Don Roberts (Author)

Test Driven Development: By Example By Kent Beck

The Art of Unit Testing: with examples in C# by Roy Osherove

Design Patterns: Elements Of Reusable Object-Oriented Software by Gamma

Patterns of Enterprise Application Architecture By Martin Fowler

The Pragmatic Programmer By Hunt


Nice post and discussion.

I'm Developer, but this book change the way I think about security.
That's histories are terrific and complemented with a lot of recommendations.

The Art of Intrusion: The Real Stories Behind the Exploits of Hackers, Intruders and Deceivers by Kevin Mitnick

And this one, teach to think different. It's a journey through agile methodologies.

Agile Principles, Patterns, and Practices in C# by Uncle Bob


Very cool! The Mitnick title is pretty different from the rest of these suggestions, definitely going to keep that one in mind. Thank you for posting!


Both Land of Lisp and Realm of Racket are excellent books on the two most relevant Lisp dialects. I also bought "21st Century C", but it sucks.


I forgot about Land of Lisp! Great read, I like project-oriented texts like that. Is Realm of Racket a translation of the former into Racket?


That's great, I didn't know such a book existed. That's going on my list next, thank you.

code of conduct - report abuse