
Ask HN: What language-agnostic programming books should I read? - robschia
Until now I&#x27;ve read:<p>- The Healthy Programmer<p>- Clean Code<p>- Test-Driven Development by Example<p>What should I add to my library?
======
DoofusOfDeath
Some of the _most interesting_ books I've read in support of my software-
development work are:

* "Compilers: Principles, Techniques, & Tools" by Aho et al. (i.e., "the dragon book")

* "Data Flow Analysis: Theory and Practice" by Khedker et al.

* "Understanding MySQL Internals" by Sasha Pachev.

* "Transaction Processing: Concepts and Techniques" by Gray and Reuter.

* "Fundamentals of Wireless Communication" by Tse and Viswanath.

* "Genetic Programming: An Intrduction" by Banzhaf et al.

* "Applied Crytography" by Schneier.

EDIT: A few additional comments:

(1) Although these books are problem-domain specific, some of them had
benefits outside of their problem domains:

* The Dataflow book has some great coverage of fixpoint algorithms. It's really helpful to recognize when some problems are best solved by fixpoint analysis.

* The "dragon book" takes a lot of the mystery out of compilers. That's somewhat helpful when writing code that needs to be fast. It's _super_ helpful if you want to work with compiler-related technologies such as LLVM.

* Understanding the fundamental challenges of transaction processing helps you avoid massive misadventures when dealing with databases or concurrent / multithreaded systems.

(2) YMMV, but I've found it hard to soldier through these books _unless_ I had
a need to for my job or for school.

~~~
barrkel
Don't read the dragon book if you're interested in compilers. It's lex and
parse heavy, and is not up to date with more recent best practice on codegen.
Further, the lex and parse end of it is focused on the kind of theory you need
to build tools like lex and yacc, rather than stuff you need to know if you
want to write a compiler.

For a good intro of modern back end development, check out Engineering a
Compiler. It's also got the lexical and parsing end of things, but a bit
better done, but still quite theoretical.

One of the best books I read on programming is "Concepts, Techniques, and
Models of Computer Programming"; it's not strictly speaking language agnostic,
based as it is on Oz, but Oz isn't a language you'd ever use in production and
is a reasonable base to introduce you to ways of programming that will
probably be completely unfamiliar, like constraint programming, dataflow,
concurrent logic, etc.

~~~
beat
Don't read _only_ the Dragon book if you're interested in compilers (or
parsing in general). But it _should_ be read, in addition to whatever else you
read on the subject. It's classic for a reason.

Most programmers don't understand parsing worth a crap, imho. Some compiler
theory would do most of us some good. I read it because I was doing data
stream parsing back in the olden days before XML (which was before JSON), when
we had to write our own stream formats. It really changed my whole way of
thinking about a fundamental class of programming problems.

~~~
eru
I found the Dragon Book unbearable---and I am one of those people interested
in theory. Pick something better, plenty of choice available.

'Essentials of Programming Languages' and 'Types and Programming Languages'
are good choices. (But slightly off-topic for this particular subthread, since
they don't deal with parsing.)

------
mikekchar
Working Effectively with Legacy Code by Michael Feathers. It's a bit hard to
wrap your brain around the Java and C++ examples unless you have experience
with them, but the techniques are timeless. You may need to practice them
extensively before you understand how important they are, though. In a recent
book club we did at work, a common complaint was, "This just looks like common
sense". Indeed it does... though the common sense is uncommonly hard to find
when you are staring at the actual situations this book helps you with.

~~~
sepent
I just finished reading this book yesterday. I am not an expert in refactoring
but the book seems too old, although most advises could be still useful.
Anyway, today I found a new book by the author: Brutal Refactoring: More
Working Effectively with Legacy Code. Unfortunately, I couldn't find a good
review of the book on the Internet. But I think it could be more useful.

~~~
fsloth
"the book seems too old"

2004 is old now? Really?

Honestly, good books don't age as long as their core domain stays valid.
Structurally C++ is pretty much the same as when the book came out.

~~~
johndubchak
Modern IDEs can deliver many of the recommendations of the book. Our
productivity has increased a great deal. Back then there was no intellisense,
code navigation through clicking on method names/classes etc. highlighted
syntax errors, built-in unit test frameworks etc.

It was written for a different type of developer and a different type of
development environment and a specific language, C++.

You haven't looked at C++ lately if you think it's the same as it was in 2004.
The ISO has released new versions of the language in 2011, 2014 and ratified a
new standard here in 2017. If you're writing C++ code that is consistent with
2004 C++ then you're writing a really bad version of "C with classes", not
C++.

Edit:

Modern C++ contains native support for the filesystem, threads, lambda
expressions, variants, upcoming networking library, coroutines (at least in
Visual Studio), no more new/delete memory management, parallel algorithms and
a ton more. This is a completely different language now and the code you write
looks nothing like 2004 C++ code.

~~~
fsloth
"You haven't looked at C++ lately if you think it's the same as it was in
2004."

"If you're writing C++ code that is consistent with 2004 C++ then you're
writing a really bad version of "C with classes", not C++."

I applaud your attempt at an authoritative voice. But you focus on mostly
technical trivia that are thin scaffolding on top of the language. I agree
modern C++ is nice but it's the same language still.

"This is a completely different language now and the code you write looks
nothing like 2004 C++ code."

Are you trolling? This reads like a transcript from a TV commercial.

~~~
khedoros1
They sound like they're echoing the kinds of things that are normally said
about C++11.

> I agree modern C++ is nice but it's the same language still.

Well...in the same sense that _any_ language is the same language after you
add a bunch of things to it that weren't there before and shift to using those
new features as idiomatic parts of the language. I _would_ expect C++ written
in 2004 to use different patterns than C++ written in 2017. Not "completely
different"...but different.

~~~
fsloth
_Idiomatic_ sounds like preference to _dogmatism_ rather than _pragmatism_
which is generally the worse tradeoff.

I would say generally C++ style has evolved through last decades with people
understanding class based architecture as an antipattern and data pipelines
based on preferably immutable data as the more robust and understandable
approach. This has nothing to do with language standards or 'idiomatic'
constructs - both can be expressed as perfectly elegant C++, using the '98 or
'11 or '17 variant.

But anyway, within this context - refactoring old code - I would not expect a
legacy codebase to resemble 2017 C++ as much as 1997 C++. This is the main
reason I find the claim of methods to understand circa 2004 C++ to be outdated
to be silly.

~~~
khedoros1
> Idiomatic sounds like preference to dogmatism rather than pragmatism which
> is generally the worse tradeoff.

That's never been the way that I've read it, and it's not how I meant it. New
language constructs allow for more-natural ways for the code to express the
intent of the programmer, replacing the use of older constructs _in the places
that they were clumsy_.

The entire point is to make the language more practical. Patterns of use in a
language aren't idiomatic because of dogma (or at least, they shouldn't be).
They're idiomatic because they're a clear and elegant way (or at least the
most elegant way available) to implement something.

> I would not expect a legacy codebase to resemble 2017 C++ as much as 1997
> C++.

Agreed, but then we come back to the fact that we might refactor a 1997
codebase differently in 2004 than in 2017.

~~~
fsloth
"Agreed, but then we come back to the fact that we might refactor a 1997
codebase differently in 2004 than in 2017."

Well, if the original code is of the worst kind of a mess, Feather's circa
2004 collection of methods to make it more understandable but functionally the
same work just fine for the first part of the refactoring. In my experience
this is the most difficult part as well. To what dialect of the language the
code is ported after it is understandable, is a relatively trivial syntax
transform after this.

I speak from experience from having recently had to implement features to a
production codebase with millions of lines of code, some of which date back to
Fortran, and that took the final step of evolving into C++ sometimes in the
late 90's.

I prefer the definition of legacy code that it's any code that does not have
unit tests. In this case every transformation to a production codebase needs
to retain the original behavior - without exact understanding what that
behavior is.

I think this comment should have been my original response to this thread
instead of the relatively cheeky responses I wrote earlier.

------
otodic
The Pragmatic Programmer: [https://pragprog.com/book/tpp/the-pragmatic-
programmer](https://pragprog.com/book/tpp/the-pragmatic-programmer)

~~~
suyash
Plus 1 to this one and another one by the same Publisher is 'Pragmatic
Thinking & Learning Refactor your Wetware'

~~~
beat
That's by Andy Hunt, one of the Pragmatic Programming authors. Pragmatic
Programmer, as a publisher, has produced dozens of books. They're like another
O'Reilly.

------
d0m
Structure and Interpretation of Computer Program (it's written in scheme but
it's mostly for convenience and its lack of syntax).

Definitely the best book I've read on programming.

~~~
chii
I'd find it quite hard to apply lessons from SCIP using java or c...

~~~
jerf
These are indications of the weakness of Java and C, not SICP.

I do not mean this as empty snark; it is something you can see across the
board in programming language evolution. It is virtually impossible to propose
a new general-purpose programming language today that does not have closure
support, which is the biggest thing you're finding missing from C and Java to
use the techniques in SICP. (It is not the _only_ thing, but it is the
_biggest_ thing.) You'll note Java is going to bolt them on soon, or recently
bolted them on, but it'll be another decade before Java is using them fluently
either way.

I've often recommend SICP to self-taught programmers; it is not a complete
substitute for a computer science education, but it is a concentrated dose of
the stuff you're probably missing out on. Expect it to be the work of some
months to work through it. However, in the end, a self-taught programmer who
has also worked through SICP systematically and carefully is probably a better
programmer than 80% of the modern computer science graduates nowadays. (If you
want to avoid that fate, oh ye who are still in school, take the freaking
compilers course at the very least. Do your peers complain that it is hard?
Then maybe it is a good one.)

~~~
pvg
They're indications the book is also not 'language-agnostic', for all of its
merits. The language is there for pedagogic purpose.

~~~
jerf
I don't think a book is "not language agnostic" because two particular
languages aren't very good at it. C's lack of closure support is unique among
any language still in use, for a variety of reasons. Java... was Java. If you
weren't there you may not remember or understand, but at the time OO was at
its most dogmatic and either it was an object or it was not included. Anything
you could do with a closure could be done with an anonymous inner class.
(Which is, technically, true. But the amplification factor on the effort and
the sheer quantity of _text_ involved to do so in Java is astonishing.) You
can hear some of the echos of this in the older Ruby rhetoric, though I
haven't heard it in a while.

Any other general-purpose language you'd be inclined to pick up right now
would be fine.

IIRC, you end up implementing a scheme, which you can do nearly in the
language of your choice, then the book covers that language you are
implementing.

~~~
pvg
The book is not language agnostic because it's not language agnostic, mostly.
The fact that many other languages are a poorer fit for what it's trying to
teach is pretty much the definition of 'not language-agnostic'.

~~~
jerf
I don't know what task could possibly exist for which there are not
significantly better and worse languages. Even today's "list of practical
projects that anyone can solve in any programming language" [1] I can see at a
casual glance that any of them that are not simply trivial will have better
and worse languages. A definition of "lanugage agnostic" that either covers no
tasks, or covers only very trivial tasks, isn't very useful. (Although in the
latter case one can attain some insight by pondering why only such trivial
tasks might be considered "lanugage agnostic".)

[1]:
[https://news.ycombinator.com/item?id=14481941](https://news.ycombinator.com/item?id=14481941)

~~~
pvg
I'm not sure what any of these logical contortions have to do with SICP being
'language agnostic'. It isn't. The first section of the first chapter talks
about why a Lisp dialect is used. This is the first figure.

[https://mitpress.mit.edu/sicp/full-
text/book/ch1-Z-G-1.gif](https://mitpress.mit.edu/sicp/full-
text/book/ch1-Z-G-1.gif)

Etc.

------
petercooper
_Programming Pearls_ by Joe Bentley. And its followup. It's old but it does
get you thinking about things.

I'd also recommend _The Linux Programming Interface_ by Michael Kerrisk as it
teaches so much about what makes modern Unix what it is but.. it's arguably
quite oriented around C by necessity. It's not a "C book" by any means though.

~~~
kristjan
Correction: Jon Bentley

[https://en.wikipedia.org/wiki/Jon_Bentley_(computer_scientis...](https://en.wikipedia.org/wiki/Jon_Bentley_\(computer_scientist\))

------
henrik_w
I really like:

\- Code Complete by Steve McConnell

\- The Effective Engineer by Edmond Lau

\- The Pragmatic Programmer by Andrew Hunt and David Thomas

~~~
stinos
Second the Pragmatic Programmer, however: I read it when I just started
programming (like not much more experienced than basic hello world and some
fiddling) and, looking back, didn't really get it. I mean, I got the
principles, but couldn't apply it as there was just not enough experience for
the higher level abstract stuff. I recently read it again and it makes
complete sense now, but I ddn't learn much new from it. So I'd suggest that if
you read it, do so after a couple of years of programming.

~~~
danielbarla
Indeed, the Pragmatic Programmer book's subtitle is "from Journeyman to
Master", and that's exactly what journeyman is supposed to mean - someone
who's a few years into it, not bad, but not great (yet?).

------
eriknstr
"The Design of Design: Essays from a Computer Scientist" by Frederick P.
Brooks [1] is language-agnostic and worth reading.

It's about software engineering but also about hardware and some different
kinds of design outside of IT.

From an interview about the book [2]:

> Eoin: Your new book does talk about software design in places, but it’s
> really about design generally, and the case studies span buildings,
> organizations, hardware and software. Who is the book aimed at? Are you
> still writing primarily for people who design software or are you writing
> for a broader audience?

> Fred: Definitely for a broader audience. I have been surprised that The
> Mythical Man-Month, aimed at software engineers, seems to have resonated
> with a broader audience. Even doctors and lawyers find it speaks to some of
> their team problems. So I aimed this one more broadly.

Brooks is also the author of The Mythical Man-Month which is often mentioned
on HN.

[1]: [http://www.informit.com/store/design-of-design-essays-
from-a...](http://www.informit.com/store/design-of-design-essays-from-a-
computer-scientist-9780201362985)

[2]:
[http://www.informit.com/articles/article.aspx?p=1600886](http://www.informit.com/articles/article.aspx?p=1600886)

~~~
codemac
Just purchase this book after finding a pdf, it's really quite great, until
you get to View/360 and get jealous.

------
kris-s
Code: The Hidden Language of Computer Hardware and Software by Charles
Petzold. I love this book.

~~~
throwaway7645
Very good. A good book to go with it is: Learning Computer Architecture with
the Raspberry Pi.

~~~
bogomipz
This looks amazing(and affordable). I had not heard of this. Thanks for
sharing!

~~~
throwaway7645
No problem. It is surprisingly advanced too and was co-authored by Eben Upton
who started the Raspberry Pi. Nice whirlwind tour of computing architecture
and history.

------
brightball
SQL Performance Explained - Markus Winand

\- Excellent book that gets into the internals of what developers need to know
about SQL and covers each part as it relates to the 4 major SQL databases
(Oracle, SQL Server, Postgres, MySQL)

\- Also has an online version: [http://use-the-index-luke.com/sql/table-of-
contents](http://use-the-index-luke.com/sql/table-of-contents)

The Code Book - Simon Singh

\- It's just a good read that covers cryptography and message hiding
throughout history. Probably a solid book for somebody around high school age.

~~~
stephenwilcock
+1 for SQL Performance Explained. One of the best vendor agnostic resources
for understanding how databases work.

------
alfiedotwtf
Books I'll treasure forever:

    
    
        - Advanced Programming in the Unix Environment by Stevens
        - Operating Systems: Design and Implementation by Tanenbaum
        - The Art of Unix Programming by ESR
        - Parsing Techniques by Grune and Jacobs
        - Applied Cryptography by Schneier

~~~
microsage
I'll second The Art of Unix Programming - despite the title, it has many broad
programming and software architecture lessons, and "The Unix Philosophy" is
applicable far beyond Unix.

~~~
sethrin
I have a pretty negative opinion on ESR these days. I could find technical
arguments about many aspects of his good pieces of writing, and much of his
writing is not good. His abilities as a coder are not generally remarkable,
either. But mostly I don't think he's a good person. I would probably not say
"Don't read ESR", but I think it has to be "Read ESR* "

*but be aware that he's a polarizing figure and opinions of his merits differ

(and if you happen to have a differing opinion, please use the reply button
instead of the downvote button)

~~~
eru
I share your sceptical opinion about ESR, but I concur with the other
commenters that The Art of Unix Programming is still worth reading. (In
contrast eg to his thing about Bazaar vs Cathedral.)

~~~
sethrin
The Cathedral and the Bazaar was not an excellent piece of writing, but it was
sort of necessary at the time. It has served its evangelical purpose well, to
the point where it's no longer necessary. Open Source won the day, in no small
part due to ESR. (I think it vital to give my enemies their due praise).

TAoUP is a good book on the Unix Philosophy, but it's worth noting that the
ultimate expression of these ideas (Plan 9) was a failure, and the 'everything
is a file' metaphor is arguably incorrect. I hope I didn't give the impression
that it was not worth reading, especially in the sense that there are few
other good sources for that information (even using Unix is not likely to
teach you much about its whys and wherefores). I just think that it should be
read in the proper context, and that recommendations should try to include
that context.

~~~
alfiedotwtf
Yep.

And I'd bet that a lot of programmers wouldn't be working on and with Linux
right now if they hadn't have read that book long ago.

Both of them changed my career path from Dos/Windows to Linux

------
pjmorris
'Implementation Patterns', Kent Beck. A semi-language-agnostic extension of
his 'Smalltalk Patterns'for how to clearly and consistently express what
you're saying when you code.

'Facts and Fallacies of Software Engineering', Robert Glass. Glass presents a
list of things everybody knows, or ought to know, and gives both academic and
opinionated support and/or critique for why they are and aren't so.

'Making Software', Oram and Wilson. An edited collection of papers on
evidence-based software engineering.

'The Deadline', Tom DeMarco. A thinly disguised commercial for his advice on
how to organize software development teams and organizations, packaged as
light, light novel.

------
gtrubetskoy
One that hasn't been mentioned yet: "Coders at Work". A very enlightening book
about how some of the best programmers in the world approach the craft in
their own words.

~~~
LostInTheWoods2
Also noteworthy in that series is Founders at Work, and Gamers at Work.

------
solatic
Nobody recommended The Phoenix Project yet by Gene Kim?

Unless you have some understanding of your system's architecture, how it's run
in production, and why a production environment is Really Different and a Big
Freaking Deal, and how operations is supposed to look like, you'll never be an
effective programmer, no matter whether you run your own operations in a small
start-up or work for a large enterprise with dedicated operations teams.

------
qpre
Not a book per say, but "Out of The Tar Pit" by Moseley and Marks is
definitely a must-read.

Abstract:

``` Complexity is the single major difficulty in the successful development of
large-scale software systems. Following Brooks we distinguish accidental from
essential difficulty, but disagree with his premise that most complexity
remaining in contemporary systems is essential. We identify common causes of
complexity and discuss general approaches which can be taken to eliminate them
where they are accidental in nature. To make things more concrete we then give
an outline for a potential complexity-minimizing approach based on functional
programming and Codd’s relational model of data. ```

Link:
[http://shaffner.us/cs/papers/tarpit.pdf](http://shaffner.us/cs/papers/tarpit.pdf)

------
deepaksurti
\- The Elements of Computing Systems: Build the virtual hardware and software
from scratch. Software includes writing a compiler in a language of your
choice, so agnostic in that sense. \- The Art of Metaobject Protocol:
Extremely insightful treatment of OOP! Alan Kay called it as the 'best book in
ten years' at OOPSLA 97.

~~~
lotophage
Also in MOOC form now too:

[https://www.coursera.org/learn/build-a-
computer](https://www.coursera.org/learn/build-a-computer)

------
fazkan
Its odd that no one mentioned it but head first into design patterns is a
great/light book on design patterns....

~~~
matt_s
I'd second the Head First Design Patterns. The style of writing is light and
fun. There are definitely concepts about abstraction, etc. that may take a
while to grok and the different approaches help.

~~~
fbomb
YMMV. I found the style extremely distracting to the subject matter.

------
fatjonny
I've been thoroughly enjoying "Designing Data-Intensive Applications" by
Martin Kleppmann. It primarily deals with the current state of storing data
(databases, etc) starting with storing data on one machine and expanding to
distributed architectures...but most importantly it goes over the trade-offs
between the various approaches. It is at a high level because of the amount of
ground it covers, but it contains a ton of references to dig in deeper if you
want to know more about a specific topic.

~~~
silentsea90
+1. Great for getting a lay of the land on distributed systems problems. I
haven't ever studied distributed systems formally though, so I wonder how this
differs from that.

------
i_feel_great
Structure and Interpretation of Computer Programs.

I have attempted some of the problems in Lua, Python, Erlang and Ada. It is
very doable. So not just for Scheme.

~~~
jaddood
Agreed. Scheme itself is "not much of s language." It's like a language-
agnostic language.

------
0xbadf00d
I would recommend "Sorting and Searching" Volume 3 from Donald Knuth's "The
Art of Computer Programming". Fantastic, in-depth read.

~~~
twohlix_
I also emphatically suggest D.Knuth's "The Art of Computer Programming". Super
dense, not like a sit down and read from cover to cover, but really good set
to have around.

~~~
xemdetia
Another Knuth-related one that is less programming that I found rewarding to
read was 'Concrete Mathematics.' It is per its own description a lengthier
version of the TAOCP, but it's mostly or entirely exempt of actual code. But
because of the subject matter it spawned from it tends to cover math of 'what
comes later' so there is a very specific perspective of Knuth style that comes
from it and its easier to see the eventual application.

~~~
_asummers
I had a professor who would joke that it was called Concrete Mathematics both
because it was foundational math for computer science, but also because it was
as hard as concrete.

------
mtreis86
Gödel, Escher, Bach: An Eternal Golden Braid by Douglas Hofstadter is about
the intersection of music, math, and computers.

~~~
randcraw
And it's playful. It seems like, 20+ years ago, there were a lot more authors
who wrote playful tech books. I miss 'em.

~~~
mtreis86
Any to recommend?

~~~
pjmorris
'A Fortran Coloring Book', Kaufmann (MIT Press) 'Starting Forth', and
'Thinking Forth' by Leo Brodie.

I'd say the 'Head First' books are modern equivalents with a similar spirit.

------
smcgraw
"Thinking Recursively" by Eric Roberts. Completely changed the way I think
about recursive programming and easy to pick up.

[https://cs.stanford.edu/people/eroberts/books/ThinkingRecurs...](https://cs.stanford.edu/people/eroberts/books/ThinkingRecursively/)

~~~
jrapdx3
Yes it's a classic and very well written. When I read this more than 25 years
ago it was a real eye-opener and made the workings of recursion clear to me.
Curiously acquiring an understanding of recursion in programming allows me to
"think recursively" in regard to many other matters as well, so important for
thinking "outside the box".

I'd venture that besides recursion, the other key concepts in programming have
been pointers and first-class functions. Getting a grasp on these 3 ideas has
been essential to learning.

------
binarymax
Programming Pearls.

Great short book to get you thinking creatively and how to dissect algorithmic
problems, language agnostic with pseudocode examples.

Non-programming but still highly relevant for a professional programmer:
Mythical Man Month, and Peopleware.

~~~
eckza
MMM is a must-read, for anyone that wants to effectively engage in the
software development lifecycle, IMO. Developer, project manager, doesn't
matter.

------
MikeTaylor
Definitely, definitely, Kernighan and Plauger's 1976 book _Software Tools_.
The code is in RATFOR (a structured dialect of FORTRAN) but all the ideas are
language-independent. It remains, four decades on, the best book I have ever
read on how to solve the real problems of real program development. Very
practical, and covers a vast amount of ground. (As it happens, I am re-reading
it right now.)

~~~
bewuethr
There is also an edition using Pascal, "Software Tools in Pascal" from 1981,
which might be a little more accessible than the RATFOR edition. I fully agree
with the recommendation as such, though.

~~~
rpeden
The code from "Software Tools in Pascal" mostly just works in FreePascal, too.
So it's pretty easy to jump in and work through the examples in the book.

------
bphogan
Can I plug my book, Exercises for Programmers?
[https://pragprog.com/book/bhwb/exercises-for-
programmers](https://pragprog.com/book/bhwb/exercises-for-programmers)

It's a collection of programming exercises I used when I taught introduction
to programming. They start out incredibly trivial, ("prompt for a name, print
"hello [name]" back to the screen. But the trivial part is, in my opinion, the
fun part when you work with a new language.

That program is a two line program in Ruby. But it might be much more
complicated if you implemented that as your first GUI app in Swift for iOS.

I wrote the book to teach beginners, but I and others use those exercises to
learn new languages. The book has no answers, just the problem statements.

------
sgt
Thinking Forth

[http://thinking-forth.sourceforge.net/](http://thinking-
forth.sourceforge.net/)

Teaches you to think simple and elegant.

~~~
protomyth
Thinking Forth is a great suggestion since the approach goes way beyond Forth.
I also would read the Brad Cox (objc creator) books if you can get them.

------
sateesh
_The Cuckoo 's Egg_ by _Clifford Stoll_. This book taught me how important it
is to keep a log of events. These logs come in very handy when the problem one
trying to debug spawns multiple complex systems.

~~~
hyperdeficit
Seconded. This is also a great read on how to track down a deep problem, going
through all of the steps required to figure out where it was coming from.
That's on top of it being an entertaining view of early computer networking.

------
agentultra
_Programming in the 1990s_ by Edward Cohen. A rather practical introduction to
the calculation of programs from their specifications. Plenty of introductions
to computer programming involve guessing your program into existence. This is
one of those rare books that give a solid, pragmatic approach (with examples)
of developing software from solid, mathematically sound specifications and
avoiding errors by design.

Even if you don't adopt formal methods in your day-to-day work (often we're
not building sky-scrapers) it's a useful book to give you insight into the
kinds of questions one should be asking and thinking about when designing
software systems.

------
devnonymous
The Aosa series of books are brilliant imho:

[http://aosabook.org/en/index.html](http://aosabook.org/en/index.html)

Titles :

    
    
      * The Architecture of Open Source Applications (volumes I and II)
      * The Performance of Open Source Applications
      * 500 lines or less

------
__bearMountain
Agile Software Development, Principles, Patterns, and Practices - by Uncle Bob
Martin

One of the most influential programming books I've ever read. The code is in
Java, but it's east to follow even for a non-Java developer, and the truths
are universal. Learn the most fundamental design and encapsulation patterns.
Uncle Bob Martin is a legend. This book has probably made me tens of thousands
of dollars.

[https://www.amazon.com/Software-Development-Principles-
Patte...](https://www.amazon.com/Software-Development-Principles-Patterns-
Practices/dp/0135974445)

------
JustSomeNobody
I think "The Practice of Programming" was and is very good.

[https://www.amazon.com/Practice-Programming-Addison-
Wesley-P...](https://www.amazon.com/Practice-Programming-Addison-Wesley-
Professional-
Computing/dp/020161586X/ref=sr_1_1?ie=UTF8&qid=1496666291&sr=8-1&keywords=the+practice+of+programming)

------
zimmund
Introduction to algorithms[1] is a great book to improve how you think about
code and the way you implement your solutions. Even if you are a seasoned
programmer you'll find it useful.

[1]: [https://mitpress.mit.edu/books/introduction-
algorithms](https://mitpress.mit.edu/books/introduction-algorithms)

~~~
flor1s
We used it in my algorithms class in uni, I found it a bit heavy on the math
side of things. For me a more code oriented book such as Skiena's The
Algorithm Design Manual works better.

------
dustingetz
Joy of Clojure & SICP. To a lesser extent, Learn You a Haskell. 7 Languages in
7 Weeks is an excellent good baby step book if these are too daunting. 7in7
was my first intro to many new ideas.

Any language worth learning has this property of influencing the way you think
forever. TDD, Code Complete &co are all very integrated into mainstream
industry and are no longer novel. If you find yourself needing to recommend
your colleagues to read Code Complete you might consider working on the skills
to get a better job.

------
lcuff
An Introduction to General Systems Thinking. Gerald Weinberg. This book, now
over 40 years old, addresses the 'core within the core' of the reality of
systems. Unbelievably good, with a very light-hearted tone.

~~~
swah
Why this was downvoted?

~~~
swah
Why was this downvoted?

------
ctrlp
If you consider C to be language-agnostic, here are some gems. These are
personal favorites as much for their excellent writing as for their content.

The Unix Programming Environment was published in 1984. I read it over 20
years later and was astonished at how well it had aged. For a technical book
from the 80's, it is amazingly lucid and well-written. It pre-dates _modern_
unix, so things have changed but much that goes unstated in newer books (for
brevity) is explicit in UPE. (Plus, the history itself is illuminating.) It
gave me a much deeper understanding of how programs actually run over computer
hardware. Examples in C are old-school and take a bit of close reading but oh
so rewarding. [https://www.amazon.com/Unix-Programming-Environment-
Prentice...](https://www.amazon.com/Unix-Programming-Environment-Prentice-
Hall-Software/dp/013937681X)

Mastering Algorithms in C. Another fantastically well-written book that shows
(with practical examples) how to implement common algorithms. This is just
such a great book! [https://www.amazon.com/Mastering-Algorithms-Techniques-
Sorti...](https://www.amazon.com/Mastering-Algorithms-Techniques-Sorting-
Encryption/dp/1565924533)

Also:

Code (Petzold). This one is truly language-agnostic. Others have mentioned it
already. Can't recommend enough if you're iffy on the internals of computers
and programming. [https://www.amazon.com/Code-Language-Computer-Hardware-
Softw...](https://www.amazon.com/Code-Language-Computer-Hardware-
Software/dp/073560505X)

Write Great Code (Volumes I and II). Randall Hyde's books are fantastic
explications of the underlying computer operations. Examples are in assembly
or pseudo-code but easy to understand. [https://www.amazon.com/Write-Great-
Code-Understanding-Machin...](https://www.amazon.com/Write-Great-Code-
Understanding-Machine-ebook/dp/B0096FEJGQ/)

~~~
drio
+1 to Code (Petzold). I would absolutely start with that. One of my favorite
books. The build a computer course from coursera
([https://www.coursera.org/learn/build-a-
computer](https://www.coursera.org/learn/build-a-computer)) is the natural
next step after reading code.

------
Rannath
Not really programming books, but these have helped me with programming jobs.

-How to make friends and influence people. Anyone who works collaboratively with people needs to be able to communicate effectively.

-The Elements of style. Writing understandable code is similar to any other type of writing.

~~~
chuckdries
> How to make friends and influence people

I swear I've had this book recommended to me at least a thousand times, I'm
almost suspicious though I don't know that suspicious is the right word

~~~
beat
The title seems, well, creepy, in modern language. Like it's manipulative.

It's not.

It was written in the 1930s, and has been continuously in print since then.
How many books have achieved that honor? That's because it's one of the best
books you will ever read. Absorbing its lessons will make you a better person.

------
bandrami
_Let Over Lambda_. Not entirely agnostic, but delves into Forth, Smalltalk, C,
Scheme, and Perl while overall being about Lisp. Fascinating book; really a
look at metaprogramming (macros) and closures (that's what "let over lambda"
is).

~~~
weavie
Whilst being a great book, you are definitely correct in your assertion that
this book is not agnostic!

~~~
bandrami
True, but it goes into a lot of different languages, which can amount to the
same thing

------
happy-go-lucky
No one has mentioned The Little Schemer.

Edit: Written in a question-answer style, it’s geared toward luring you into
recursion and functional programming.

~~~
xyjprc
Love the Little Schemer! Lots of interesting and challenging questions!

------
Insanity
In addition to those already mentioned here, I enjoyed the book 'Algorithms'
by Robert Sedgewick & Kevin Wayne.

The algorithms are explained, and demonstrated (in java). But with the
knowledge of how the algorithm works you should be able to use them in another
language.

(And even though henrik_w already mentioned it, Code Complete2 is a really
good book to read!)

~~~
cessor
Good advice! I have an older version, in which the implementations are
explained in Pascal. I understand that newer issues cover java. I'd believe
the book goes well with his coursera course:

[https://www.coursera.org/learn/algorithms-
part1](https://www.coursera.org/learn/algorithms-part1)

------
RossBencina
I see you read Kent Beck's TDD book. A good follow-up might be Roy Osherove's
"The Art of Unit Testing." I found it to have a lot of pragmatic, practical
advice. It's not the final word, but it is a good next step after Kent Beck's
book. It has some C#-specific material, but that stuff is interesting to read
about even if you're working in other languages.

Lot's good suggestions in this thread, here's one I didn't see:

"Software Runaways - lessons learned from massive software project failures,"
by Robert L. Glass.

------
demircancelebi
I have been reading Game Programming Patterns lately. It explains the design
patterns with examples from games, and it is really well written by an
engineer at Google (Bob Nystrom):
[http://gameprogrammingpatterns.com/](http://gameprogrammingpatterns.com/)

After I complete this book, I think I'll read his other book: Crafting
Interpreters. This one teaches about implementing a programming language from
scratch, once in Java and a second time in C.

------
petra
Sanzy Metz is a great teacher of object-oriented design. Read her ruby book.

"Introduction to algorithms : a creative approach" by Udi Manber. ". Great
book to learn algorithm design.

------
euske
The Psychology of Computer Programming by Gerald M. Weinberg

It's an old book but the most eye-opening one to me.

~~~
pjmorris
From its preface: "This book has only one major purpose - to trigger the
beginning of a new field of study: computer programming as a human activity,
or, in short, the psychology of computer programming."

Still a worthy topic, still worth your time. As was mentioned about 'The
Pragmatic Programmer', I think reading this works best once you have a few
years of experience.

------
paublyrne
Practical Object-oriented Design in Ruby is a great read with a lot of advice
on approaching design problems, approaching refactoring and thinking about how
to model. It's in Ruby but I feel a lot of its advice is general.

~~~
beat
aka "Why duck typing is better than inheritance". Yes, great book, but if
you're using a language that doesn't support duck typing, some of the concepts
will frustrate you and make you wish you were using Ruby instead.

~~~
rimliu
You can do some (most) of the stuff using interfaces/protocols in languages
that support these.

~~~
beat
It's not quite as natural, though. On the other hand, making it explicit is
often a Good Thing.

------
csneeky
"Types and Programming Languages" (aka "tapl")

~~~
ericssmith
Although the OP seems to be asking for "engineering" not "programming" books,
I'm going to second this. Benjamin Pierce's "Types and Programming Languages"
will help you get down to what programming is really about. If you are not
familiar with lambda calculus and its notation, it may be rough going at
first. But lambda calculus is VERY simple, and Pierce takes you through it.
The book progresses methodically to the concepts found in most common
programming languages.

This is one of the few truly language agnostic books on programming. SICP is
close, but it is limited in relevance at times due to the limitations of a
particular language (Scheme).

------
pjmlp
A few ones:

"Algorithms and Data Structures" from Niklaus Wirth.

"Introduction to Algorithms, 3rd Edition" from Thomas H. Cormen, Charles E.
Leiserson, Ronald L. Rivest, Clifford Stein.

"The Garbage Collection Handbook: The Art of Automatic Memory Management" from
Richard Jones and Antony Hosking

"Code Complete" from Steve McConnell

"From Mathematics to Generic Programming" from Alexander Stepanov and Daniel
Rose

------
masterzachary
* "Clean Code" Robert C. Martin (978-0132350884)

* "Refactoring: Improving the Design of Existing Code" Martin Fowler (978-0201485677)

* "Computer Systems: A Programmers Perspective" Randal E. Bryant (978-0134092669)

------
jacquesm
Any good book on statistics would be a huge asset, as well as a book about
debugging strategies.

~~~
TeMPOraL
> _as well as a book about debugging strategies_

Any examples of books focused on that? I can't think of any.

~~~
randcraw
[https://news.ycombinator.com/item?id=9242384](https://news.ycombinator.com/item?id=9242384)

------
vitomd
If you liked Clean Code, read Clean Coder. A quick summary:

Robert C. Martin introduces the disciplines, techniques, tools, and practices
of true software craftsmanship. This book is packed with practical
advice–about everything from estimating and coding to refactoring and testing.
It covers much more than technique: It is about attitude.

~~~
gonzofish
I feel that books like Clean Coder should be recommended reading for people in
their first job. I really feel like it made me think about how I do my job in
a more professional, quality-focused manner than even Clean Code did.

------
OJFord
Sipser's _Theory of Computation_. It covers automata and languages,
computability, and complexity - and is brilliantly written, the proof style in
particular: clear 'proof idea's followed by the details that can be easily
skipped if you're not interested, or it is clear from the 'idea'.

------
BFatts
'The Pragmatic Programmer' is a fantastic language-agnostic manual that still
applies heavily today.

------
neves
Any computer themed book of Gerald M. Weinberg is a must read:
[https://leanpub.com/u/jerryweinberg](https://leanpub.com/u/jerryweinberg)

If at first sight my may think that they are outdated and superficial, but you
can't be more wrong.

~~~
pjmorris
While he'd been successful writing language-specific books, he stopped writing
them in the early 70's, because he recognized that the important principles
didn't change. Super important thinker about software and the people who make
it.

------
ranko
_Growing Object-Oriented Software Guided by Tests_ , by Steve Freeman and Nat
Pryce. The examples are, IIRC, in Java, but the ideas about TDD are applicable
to any OO language. It'll make you think more about how you write testable
code and the test themselves.

------
IndrekR
"The Elements of Style" by Strunk & White. Not exactly a standard programming
book. Not really language-agnostic either -- quite English-centric.

I here assume your source code will be read by others; or by yourself after
more than three months has passed.

~~~
SomeHacker44
As someone married to an journalist and now EIC and one who prides himself on
concise and solid writing, I really detest this book. It's full of terrible
recommendations that the authors themselves don't even follow in their own
book. I strongly recommend any English authors stay miles away from it.

If you want this sort of thing, read a well-respected publication's style
guide (e.g., from the AP, NYT or Economist).

------
unfocused
"How to Solve It" by George Pólya

------
g051051
"Peopleware: Productive Projects and Teams" by DeMarco and Lister.

------
OliverJones
An old standard: The Mythical Man Month by Fred Brooks.

~~~
humanrebar
Eh. I read it but a lot of the particulars of how code is made doesn't really
apply anymore.

The _concepts_ and _terminology_ are absolutely invaluable to understand, but
you can pick those up other ways.

------
fastbeef
Not a programming book per se, but seeing that you had "The Healthy
Programmer" in your list I'll throw it out there:

"The underachievers manifesto" \- a short book that does wonders for your
mental health in a world that values productivity and superficial, short-
sighted goals over everything else.

[https://www.amazon.com/Underachievers-Manifesto-
Accomplishin...](https://www.amazon.com/Underachievers-Manifesto-
Accomplishing-Little-Feeling/dp/0811853683)

------
dyarosla
I've really enjoyed "Dependency Injection in .NET"\- despite the name, the
book itself is really 95% about Dependency Injection and relatively language
agnostic. It exhibits a bottom-up approach to using inversion of control in a
way that makes sense and is scalable.

[https://www.manning.com/books/dependency-injection-in-dot-
ne...](https://www.manning.com/books/dependency-injection-in-dot-net)

------
jordigh
It's not language-agnostic, but it's still a great book: The D Programming
Language. The reason I recommend it is because Alexandrescu is a great writer
who knows a lot about programming languages and the kinds of tradeoffs that a
low-level, practical, and safe programming language like D must do.

Even if you never intend to program in D, I encourage you to read this book to
get a different view on metaprogramming, memory safety, and concurrency.

------
timclark
Domain Driven Design by Eric Evans

Implementing Domain Driven Design by Vaughn Vernon

Clean Code by Robert Martin

I think you will find some code in all of the books but the ideas are
applicable almost everywhere.

------
stcredzero
Martin Fowler's _Refactoring_

------
fd5773
If you can find a copy, get the 1st Edition of Bertrand Meyer's "Object
Oriented Software Construction". (1st ed. is a classic; 2nd ed. is much larger
and worse for it, IMO.)

If you can, forget about the title and just read it; most of the good stuff in
this book is less about objects and much more a fantastic seminar on
programming in general.

------
gmiller123456
"The Elements of Computing Systems" and the accompanying course Nand2Tetris on
Coursera. It's a course that starts with just nand gates, and leads you
through the development of higher level logic gates, then an ALU, then a CPU,
the an assembler, then a high level language compiler, and finally an
operating system.

I've seen the "dragon book" mentioned several times, and I think it (and
similar books) are good if you really do plan to (re-)invent a real world,
large scale, programming language. If you really just want to get a feel for
what's going on under the hood, the language presented in Nand2Tetris is
specifically designed to have the necessary complexity to cover most of the
details, but not so many special cases that you end up "chasing dragons". And
the course is modular enough that you can jump right in and just implement the
compiler if you want.

------
mytec
Smalltalk Best Practices by Kent Beck. I feel the advice and experience this
book provides goes well beyond Smalltalk.

------
cakeface
I really liked "Building Microservices" by Sam Newman. It's a good review on
current software architecture and software development process in addition to
going over microservices. Honestly microservices are a topic in the book but
it could just be called "Software Architecture in 2016".

------
hikarudo
"The Art of Readable Code", by Dustin Boswell and Trevor Foucher. Simple ways
to make code more readable.

------
Jeaye
The Reasoned Schemer: [https://mitpress.mit.edu/books/reasoned-
schemer](https://mitpress.mit.edu/books/reasoned-schemer)

Learning more and more about imperative programming, OOP, design patterns, etc
is good, but branching out into declarative programming and the functional and
logic paradigms will stretch your mind for the better.

The great thing, I think, about The Reasoned Schemer is that it tackles a
complex topic with almost no prose. The whole book is basically one code
example after another, in a Q/A style. "What does this do?" <allow you to
think about it> "Here is what it does, and here's why." Rinse and repeat. I
think more technical books should try this.

~~~
vram22
The Reasoned Schemer sounds like it was part of a series, is that right? I
remember reading about The Little Schemer and maybe The Seasoned Schemer. Are
those all parts of the same series? Haven't read any of them yet, but hope to
do so some day.

I like reading the classics of the field. Not only because they are classics,
but also because they tend be well-written and hence more readable as well
(than your average text). But maybe that is a tautology :) - they are classics
because they are well-written ...

Update: Answering my own question - I saw here:

[https://mitpress.mit.edu/books/reasoned-
schemer](https://mitpress.mit.edu/books/reasoned-schemer)

that it _is_ part of a series, which includes the books I mentioned above.

------
mathnode
\- The Pragmatic Programmer

\- The Practice of Programming

\- The Mythical Man Month

\- The Cathedral and the Bazaar

\- The Art of Motorcycle Maintenance

\- Introduction to Algorithms

\- Hackers and Painters

Some of these do contain mixed language code examples, but they are expressed
in a way to be agnostic. A problem is a problem; in any language.

~~~
optimuspaul
The Art of Motorcycle Maintenance?

~~~
inerg
I believe he was talking about Zen and the Art of Motorcycle Maintenance: An
Inquiry Into Values ([https://www.amazon.ca/Zen-Art-Motorcycle-Maintenance-
Inquiry...](https://www.amazon.ca/Zen-Art-Motorcycle-Maintenance-
Inquiry/dp/0060589469/)).

It's a nice fiction book that goes into how different people view the world.
At least that's what I've gotten out of it so far, I'm only about a quarter of
the way through it so I might be missing some of the things it covers.

~~~
optimuspaul
yes, I assumed that to be the book they meant. I read it 25 years ago. I am
just surprised that it would be included in this list. I see no connection to
the question posed.

~~~
inerg
I'm not sure why he included it in his list. However I do think that it does a
very good job of bringing to light that your customers/users may not be
appreciative of buggy code. They want something that "just works" and to not
have to deal with vague error messages.

I started reading the book about a year into my first development job and it
really brought to light the frustrations my users were having as I was seeing
as it was just another interesting problem to me. As I said in my past post I
haven't been diligent in reading it so I'm only a quarter of the way through
but here's hoping I'll get more insights out of it when I pick it back up.

I do think that what this book talks about can be discovered in other ways,
but for people who are just starting in the technology field it's a good
primer to be aware of how others experience what you implement.

~~~
randcraw
In a way, the entire book is about debugging, but the target is the author's
thought process rather than code. While Robert Pirsig fictionalizes the story,
in fact it's closely based on his own life, in which he sought understanding
of values (via zen and academics) but somehow went wrong and ended up
catatonic and in shock therapy. The plot is a revisit of the mind trek he was
on then and a quest to see where he went wrong. Pirsig approaches this not as
a psychologist, but as a reductionist philosopher/scientist, trying to
identify _what_ troubled him and caused him to fail -- a debugging of the
mind.

------
rajadigopula
A short book (25 pages), but I find it worth mentioning here - 6 Things About
Programming That Every Computer Programmer Should Know -
[https://www.amazon.co.uk/Things-Programming-Computer-
Program...](https://www.amazon.co.uk/Things-Programming-Computer-Programmer-
Should-
ebook/dp/B010C6DWFG/ref=sr_1_1?ie=UTF8&qid=1496664834&sr=8-1&keywords=6+things+about+programming)

A really well written short glimpse of things every programmer must know.

------
l0stkn0wledge
If you are writing code, you are doing yourself (and anyone using your code) a
disservice if you do not read something on secure coding. There are not a ton
of code agnostic resouces, but you may want to start with "Software Security:
Building Security In"

I would then look for language specific options as well, because programming
for security can vary a lot amongst languages. Writing securely for native
applications running on a system is much different than writing secure web
apps.

------
ishmaelahmed
"The Pragmatic Programmer" by Andy Hunt and Dave Thomas

------
tmaly
Understanding the Four Rules of Simple Design by Cory Haines

I like the 4 simple rules, I think he originally got these from Kent Beck. It
is easier to keep this system in your mind if it is just a few basic
principles.

Working Effectively with Legacy Code by Michael Feathers

As others also mentioned this. I think this is becoming more important as
people transition to new jobs where they have to take on existing software.
Having a process to deal with code that lacks documentation and tests is
really important.

------
svec
"Programmers at Work: Interviews With 19 Programmers Who Shaped the Computer
Industry" by Susan Lammers.

[https://www.amazon.com/Programmers-Work-Interviews-
Computer-...](https://www.amazon.com/Programmers-Work-Interviews-Computer-
Industry/dp/1556152116)

This book is from 1989, but it's a timeless and fascinating look at the minds
of Bill Gates, Andy Hertzfeld (apple/mac), Dan Bricklin (visicalc), and 16
others.

------
patricklouys
Effective Java (lots of good generic OOP advice)

Implementing Domain Driven Design

~~~
einpoklum
Although I liked Effective Java a lot, and it does contain a lot of advice
relevant to many OO languages - it is the opposite of language agnostic: It's
very Java-specific. Much of the content is irrelevant except in Java itself;
and some of it is the opposite of "Effective language X". For example, it has
a section named "Prefer lists to Arrays"; any C++ programmer will tell you the
opposite (and that goes down to some of the arguments, such as Java not
supporting generic arrays while C++ supports them).

So - good book, but not for this purpose.

~~~
javabean22
But it also tells you why to prefer x over y, every time it gives any
recommendations. And it's always explained well. So I think reading this book
will help you make conscious decisions while using other languages. It's just
a very well written book.. Which is pretty rare..

------
maksa
\- Pragmatic Programmer, From Journeyman To Master

\- Code Complete 2nd Ed.

\- Quality Software Management Vol 1-4, by Gerald M. Weinberg

I'd also throw in: Code Reading - The Open Source Perspective

------
heeton
If I can suggest a talk rather than a book, "Hammock Driven Development" by
Rich Hickey (creator of Clojure) is one of my favourites.

------
vblord
Best design pattern book i've read is "Head First Design Patterns: A Brain-
Friendly Guide". It's fun and very informative.

------
arashThr
I also like to add "Pragmatic Thinking and Learning: Refactor Your Wetware" by
Andy Hunt It can be considered as a followup of pragmatic programmer. For me
the main challenge is to how to stay relevant in days of constant change, and
the best answer seems to be constant learning. So, let's learn how to learn!
And this is exactly the main topic of this book.

------
aHernandezI
I loved cracking the coding interview, even if you want to practice for an
interview or not, with this book you can get a friendly reminder of data
structures and algorithms, time complexity and related topics (and you can
improve your problem-solving skills too). For me at least it was useful for
feeling again a great interest in these topics and to love even more my job.

------
m-j-fox
Not exactly language-agnostic, nor about programming per se, nor a book, but
[Google Style
Guides]([https://github.com/google/styleguide](https://github.com/google/styleguide))
offer a lot of specific, opinionated, practical advice that you can apply
immediately. It's like an MLA manual for programmers.

------
steego
A really fun read is The New Turing Omnibus. I'd call it fun reading rather
than required reading.

Basically, it's a collection of small fun loosely related chapters about
various ideas in computer science. It's the kind of book where you can open it
up in the middle and start reading.

Over the years, I must have purchased 5 or 6 copies because I keep giving them
away.

~~~
SourPatch
Great recommendation! His book The Armchair Universe is pretty much what made
me want to be a programmer. I enjoy books that keep the fun in programming.

------
mighty_warrior
Apprenticeship Patterns - A great book more focused on being an good software
engineer and less on software specific details. Online for free at
[http://chimera.labs.oreilly.com/books/1234000001813/index.ht...](http://chimera.labs.oreilly.com/books/1234000001813/index.html)

------
sAbakumoff
"Practices of an Agile Developer: Working in the Real World" \- this book was
like the Bible for me when I started my career in IT 10 years ago. I re-read
it multiple times and I still stick to the practices described in this book.
They are language agnostic, they are pretty clear and easy to follow and they
can really improve your skills.

------
aaronmu
A couple fun ones that weren't mentioned yet:

JavaScript Allongé, the "Six" Edition by Reginald Braithwaite

Are Your Lights On? by Gerald M. Weinberg

------
cstavish
_Programming Pearls_ by Jon Bentley.

------
le-mark
Algorithmics: the Spirit of Computing by David Harel[1] is really fantastic,
can't recommend it enough.

[1]
[http://www.goodreads.com/book/show/2378136.Algorithmics](http://www.goodreads.com/book/show/2378136.Algorithmics)

------
amadvance
I recognized my experience, and really liked:

Software Craftsmanship - The New Imperative, Pete McBreen

[http://www.goodreads.com/book/show/1035377.Software_Craftsma...](http://www.goodreads.com/book/show/1035377.Software_Craftsmanship)

------
shagie
A Pattern Language by by Christopher Alexander, Sara Ishikawa and Murray
Silverstein.
[https://en.wikipedia.org/wiki/A_Pattern_Language](https://en.wikipedia.org/wiki/A_Pattern_Language)

From a blog post ( [http://the-
whiteboard.github.io/book/review/2016/02/17/five-...](http://the-
whiteboard.github.io/book/review/2016/02/17/five-books-michaelt.html) ) I
wrote a bit ago...

\---

The first thing that will come to mind when seeing that title is “ug, another
book on patterns.” Or maybe “I thought it was named Design Patterns - Elements
of Reusable Object-Oriented Software”

This isn’t anything like that book. Or maybe it should be. The full title of
the book is A Pattern Language: Towns, Buildings, Construction. Yes, this is a
book about architecture - but not software architecture. It is about the
houses and buildings that we walk live and work in.

The description of A Pattern Language is one that will sound very familiar to
people familiar with Design Patterns:

> It is shown [in The Timeless Way of Building], that towns and buildings will
> not become alive, unless they are made by all the people in society, and
> unless these people share a common pattern language, within which to make
> these buildings, and unless this common pattern language is alive itself.

> In this book we present one possible pattern language, of the kind called
> for in The Timeless Way. This language is extremely practical. It is a
> language that we have distilled from our own building and planning efforts
> over the last eight years. You can use it to work with your neighbors, to
> improve your town and neighborhood. You can use it to design a house for
> yourself, with your family; or to work with other people to design an office
> or a workshop or a public building like a school. And you can use it to
> guide you in the actual process of construction.

> The elements of this language are entities called patterns. Each pattern
> describes a problem which occurs over and over again in our environment, and
> then describes the core of the solution to that problem, in such a way that
> you can use this solution a million times over, without ever doing it the
> same way twice. This is the book that inspired Gamma, Helm, Johnson and
> Vissides.

By reading A Pattern Language you will be able to understand what the authors
of Design Patterns were trying to do and how design patterns were intended to
work.

It’s a good book too, who knows what else you will find useful in it. Pattern
#146 describes a flexible office space. Pattern #148 describes a workspace for
small work groups, #151 is about small meeting rooms, #152 is a half private
office. Everyone who works in today’s world of computers and cubes, can use
these ideas to conceptualize and consider improvements to the office.

~~~
beat
Since reading that book, I apply it every time I look at a new public space or
building interior. It's utterly brilliant.

------
smyatkin_maxim
Excellent question btw. Language-agnostic books don't get out-dated that fast
and I'd give them higher priority. Personally:

\- Code complete

\- Pragmatic programmer

\- Design patterns

\- Programming pearls

\- If you're going for hardcore programming: the dragon book, something on
modern hardware and something on OS internals.

------
swanandp
Release It! by Micheal Nygard. Excellent advice and patterns about building
robust software.

------
candiodari
Purely functional data structures by Chris Okasaki

Let Over Lambda forgot by whom

[https://www.youtube.com/watch?v=0nbkaYsR94c](https://www.youtube.com/watch?v=0nbkaYsR94c)
Not technically a book, but watch it anyway.

~~~
c3534l
> Purely functional data structures by Chris Okasaki

Is that really language agnostic? I don't know how you could follow along with
it without knowing some ML or Haskell.

~~~
weavie
You would need a cursory knowledge of ml to be able to understand it, but you
can implement the examples in plenty of other languages. The principles taught
are fairly universal. (At least for the first half, I haven't made it beyond
that yet...)

------
gameguy43
Something on data structures and algorithms.

I like /coding interview/ resources for this, because they skip the proofs and
get to the point faster.

Cracking the coding interview is good So is interviewcake.com (disclosure: I
made it)

------
mempko
The Elements of Programming. They use C++ but it isn't about C++ at all

------
bstamour
Though it uses a subset of C++ for the code examples, Elements of Programming
by Stepanov and McJones. It shows how algebra can serve as an effective
foundation for engineering generic, reusable programs.

------
beat
Okay, here's some I haven't seen mentioned yet, although these may be pretty
far afield for you:

 _Drift into Failure_ , by Sidney Dekker. Studies failure analysis in complex
systems, and basically argues that our classic reductionist/scientific method
approach is the wrong way to study complex engineering failures.

 _How Buildings Learn_ , by Stewart Brand. This isn't about programming. It's
about architecture, in the build-a-building sense. It studies what happens to
buildings over the course of their lives, as opposed to just when they're
first built.

 _Enterprise Integration Patterns_ , by Gregor Hohpe and Bobby Woolf. Learn
how to use message queues and service busses correctly. Honestly, just read
the first couple of chapters (65 pages or so), and the rest is reference, to
look up as needed, so it's not as imposing as it sounds.

 _Advanced Programming in the UNIX Environment_ , by W. Richard Stevens. This
book was my bible back in the olden days before http and ssh and stuff (I'm
olde). Knowing _how_ sockets really work can be an absolute lifesaver, even in
this modern world of giant protocol stacks. Especially in this modern world.

 _The Art of Computer Programming_ , vols 1-3, by Donald Knuth. Only a madman
would actually read them all, but they're good to have to remind you that
there are mountains you can't even begin to climb.

 _A Deepness in the Sky_ , by Vernor Vinge. A science fiction novel that is
really about hacking, set thousands of years in the future, when Moore's Law
is long defeated and programmers are basically archeologists.

 _Design Patterns_ (aka Gang of Four), by Gamma/Helm/Johnson/Vlissides. There
are lots of good books on design patterns, but you should really read the one
that started it all. (For extra credit, read _A Pattern Language_ , by
Christopher Alexander - a book about urban architecture that inspired it.)

 _Continuous Delivery_ , by Jez Humble and David Farley. Stop thinking about
your program in isolation, and learn how to deploy effectively!

 _Influence: The Psychology of Persuasion_ , by Robert Cialdini. This is DHH's
favorite book. Learn how people think, and how to use that to design better
products.

 _How to Win Friends and Influence People_ , by Dale Carnegie. Not creepy at
all, despite how the title sounds in today's language. This book is the bible
of how to get along with others. It's been in continuous print since before
WWII, for good reason.

 _The Lean Startup_ , by Eric Ries. The best work you do is the work you find
you don't need to do. Learn how to fail fast and save time on projects and
product development, by building what customers want rather than what you
think they need.

~~~
MR_HANDS
these are all great! thanks

------
aracarie
Concepts, Techniques, and Models of Computer Programming - Peter Van Roy

------
leandot
A plug but hopefully useful as it is basically the books read by the HN
community - [http://hackernewsbooks.com](http://hackernewsbooks.com)

------
mrwnmonm
The Practice of Programming

and take a look at this
[https://news.ycombinator.com/item?id=13448818](https://news.ycombinator.com/item?id=13448818)

------
cestith
\- The Practice of Programming ; Kernighan and Pike

\- The Advent of the Algorithm ; Berlinski

\- Engineering a Compiler ; Torczon and Cooper

\- Advanced Programming in the Unix Environment ; Stevens and Rago

\- Databases, Types, and the Relational Model ; Date

\- Code ; Petzold

------
LoSboccacc
Code complete

Refactoring

Patterns of enterprise architecture

------
joshdev
* Mythical Man Month

* Pragmatic Programmer

* Code Complete

------
ninjakeyboard
Domain Driven Design by Evans PoEAA by Fowler (read his blog posts for the
sequel that never came into existence such as event sourcing and cqrs as well)
Refactoring by Fowler Event Storming by Brandolini

------
trimbo
"Dynamics of Software Development" by Jim McCarthy

------
timwaagh
Beautiful Code is nice (O'Reilly, various authors). I'd recommend it. It is
written in a lot of languages so will help open your eyes to new worlds.

------
thanatropism
For our Algorithms class in Applied Mathematics we used:

Dasgupta, Papadimitriou and Vazirani: "Algorithms" (McGraw Hill)

Kleinberg, Tardos: "Algorithm Design" (Pearson)

------
cyrusfusion
Unix Network Programming, vols 1 & 2, by W. Richard Stevens

Yea, I know the code examples are written in C, but he goes into detail about
how networks and ipc work.

------
known
Check reading lists in
[https://www.joelonsoftware.com/](https://www.joelonsoftware.com/)

------
whorleater
\- Computer Systems: A Programmer's Perspective

------
cessor
Here are my recommendations. Each is a placeholder for a complete discussion
:)

Psychology of Programming

=========================

1\. "Psychology of Computer Programming" \- Gerald M. Weinberg

2\. "Software Design – Cognitive Aspect" by Francoise Detienne

3\. "Thinking Fast and Slow" by Kahneman and Tversky

4\. "Drive: The Surprising Truth About What Motivates U" by Daniel Pink

Book 1 is a really nice read and touches a lot of the social and workplace
aspects of computer programming. Book 2 is more focused on modern research of
program comprehension in relation to cognition. It's a little older, and often
just scratches the surface, but they both nicely show that a lot of social and
psychological factors are relevant for programming, independent of the
programming languages developers use. 3. and 4. add some more background infos
to it if you want to dive deeper.

Career Development

==================

\- "Hackers and Painters" \- Paul Graham

\- "The Passionate Programmer" \- Chad Fowler

In addition to the Pragmatic Programmer which has been mentioned in other
comments, these books really helped me understand where I wanted to be as a
programmer.

Technology

==========

With a stronger focus on technology I recommend:

\- "Language Implementation Patterns" \- Terence Parr

\- "A Retargetable C Compiler: Design and Implementation" \- Hanson, Fraser

I found them more helpful than the Red Dragon Book. The latter is good, but as
a beginner I felt a little lost and Terence Parr's book was much more helpful.

Practice & Karate

=================

\- "Elegant Objects" by Yegor Bugayenko

\- "Working Effectively With Legacy Code" \- Michael Feathers

\- "Growing OO Software, Guided by tests" \- Pryce, Freeman

\- "Test Driven Development" by Kent Beck

And, this last one I can't recommend enough:

"XUnit Test Patterns" by Gerard Meszaros

Kent Beck's TDD is good book to start with. Even if you feel like you have got
testing figured out, you should try TDD. It has more to do with discipline and
getting things done, rather than writing code fast or smart or efficiently.
Someone I follow on twitter once called it "thinking at sustainable pace",
which is really what TDD is about. A lot of people are simply offended by the
idea to "test first". To me, "test first" is roughly equivalent to "think
before you code". Maybe this is what others find offensive.

As for an advanced view on testing, Gerard Meszaros's book is really good. It
is a catalogue of testing patterns that helps to structure testing code in a
nice way.

Depending on OP's skill I would recommend the following: Be very carefull with
the following books:

\- Design Patterns - Gang of Four

\- Patterns of Enterprise Application Architecture

\- {Doing Anything with} Domain Driven Design

These books are really valuable, but somewhat problematic. Sometimes they will
give you a hammer and make everything look like a nail. Sometimes they make it
easy to focus on the wrong things. They come over as precise and clear, but
really aren't, which will cause discussions and poor choices. On the surface,
they sound nice, simple and friendly, but on a deeper level, they are really
difficult to understand.

If you want to read them, I encourage you to do so with your colleague and
discuss them critically. Maybe you can have a wednesday afternoon bookclub
meeting at your company. We once did that for "Working Effectively with Legacy
Code".

I collected some more suggestions on a trello board a while ago, which should
be accessible here:

[https://trello.com/b/lw96ei6d/books](https://trello.com/b/lw96ei6d/books)

If you wish to contribute, just let me know. Then initial collection started
when we got together after an open space.

BTW: Thank you all for your suggestions! I will add some of your
recommendations to the trello board.

------
JCzynski
Working Effectively With Unit Tests is quite useful. It's focused on Java but
the advice given applies well beyond that.

------
suyash
I'd also recommend Artificial Intelligence: A Modern Approach written by
Stuart J. Russell and Peter Norvig.

------
dzuc
[http://computationbook.com/](http://computationbook.com/)

------
Animats
"Fundamental Algorithms", Knuth.

------
badperson
this guy has a blog that recommends a lot of great books
[http://www.catonmat.net/blog/top-100-books-part-
one/](http://www.catonmat.net/blog/top-100-books-part-one/)

------
tomxor
Thinking FORTH (yes it's language agnostic, even though it's about FORTH)

------
deathtrader666
Death March is a good one for understanding how and why projects fail.

------
leozhang
Introduction to functional programming 1st edition by Richard Bird

------
bluetwo
Why New Systems Fail: Theory and Practice Collide by Phil Simon

------
lamg
"A Discipline of Programming" by Edsger Dijkstra.

------
agumonkey
meta advice: read many, some book, even great and famous, don't click at
first, read something else that clicks, reread the others later. iterate.

------
kentf
The Pragmatic Programmer by Andrew Hunt and David Thomas

~~~
ryan-allen
One of the first books I read that led me on to craploads of other books. It
mentioned Peopleware, Mythical Man Month and just opened up a whole world of
books about programming and being a programmer that were not 'do this then
that to achieve Y'.

Gonna have to pick that one up again and see what else I can glean from it
years later :)

------
eru
Fred Brook's "The Mythical Man Month".

------
kitplummer
Pragmatic Practices of an Agile Developer!

------
danschumann
I liked "founders at work"

------
mezuzi
Code, the Hidden... is a great read

------
type0
The Annotated Turing by C. Petzold

------
bybjorn
The Pragmatic Programmer

------
autoreleasepool
[deleted]

~~~
kfrzcode
What is 'watch this?'

~~~
autoreleasepool
Sorry, I accidentally commented on the wrong post somehow. Unfortunately, I
can't delete the comment.

------
javabean22
Programming Pearls (2nd Edition) by Jon Bentley

Effective Java (2nd Edition) by Joshua Bloch. It's a Java book but it's
language-agnostinc in a way. A great book.

------
W0lf
I've gathered all the book titles in this thread and created Amazon affiliate
links (if you don't mind. Otherwise you still have all the titles together :-)
)

A Pattern Language, Alexander and Ishikawa and Silverstein
[http://amzn.to/2s9aSSc](http://amzn.to/2s9aSSc)

Advanced Programming in the Unix Environment , Stevens
[http://amzn.to/2qPOMjN](http://amzn.to/2qPOMjN)

Algorithmics: the Spirit of Computing, Harel
[http://amzn.to/2rW5FNS](http://amzn.to/2rW5FNS)

Applied Crytography, Wiley [http://amzn.to/2rsULxS](http://amzn.to/2rsULxS)

Clean Code, Martin [http://amzn.to/2sIOWtQ](http://amzn.to/2sIOWtQ)

Clean Coder, Martin [http://amzn.to/2rWgbEP](http://amzn.to/2rWgbEP)

Code Complete, McConnel [http://amzn.to/2qSUIwE](http://amzn.to/2qSUIwE)

Code: The Hidden Language of Computer Hardware and Software, Petzold
[http://amzn.to/2rWfR9d](http://amzn.to/2rWfR9d)

Coders at Work, Seibel [http://amzn.to/2qPCasZ](http://amzn.to/2qPCasZ)

Compilers: Principles, Techniques, & Tools, Aho
[http://amzn.to/2rCSUVA](http://amzn.to/2rCSUVA)

Computer Systems: A Programmer's Perspective, O'Hallaron and Bryant
[http://amzn.to/2qPY5jH](http://amzn.to/2qPY5jH)

Data Flow Analysis: Theory and Practice, Khedker
[http://amzn.to/2qTnSvr](http://amzn.to/2qTnSvr)

Dependency Injection in .NET, Seemann
[http://amzn.to/2rCz0tV](http://amzn.to/2rCz0tV)

Domain Driven Design, Evans [http://amzn.to/2sIGM4N](http://amzn.to/2sIGM4N)

Fundamentals of Wireless Communication, Tse and Viswanath
[http://amzn.to/2rCTmTM](http://amzn.to/2rCTmTM)

Genetic Programming: An Intrduction, Banzhaf
[http://amzn.to/2s9sdut](http://amzn.to/2s9sdut)

Head First Design Patterns, O'Reilly
[http://amzn.to/2rCISUB](http://amzn.to/2rCISUB)

Implementing Domain-Driven Design, Vernon
[http://amzn.to/2qQ2G5u](http://amzn.to/2qQ2G5u)

Intrduction to Algorithms, CLRS
[http://amzn.to/2qXmSBU](http://amzn.to/2qXmSBU)

Introduction to General Systems Thinking, Weinberg
[http://amzn.to/2qTuGJw](http://amzn.to/2qTuGJw)

Joy of Clojure, Fogus and Houser
[http://amzn.to/2qPL4qr](http://amzn.to/2qPL4qr)

Let over Lambda, Hoyte [http://amzn.to/2rWljcp](http://amzn.to/2rWljcp)

Operating Systems: Design and Implementation, Tanenbaum
[http://amzn.to/2rKudsw](http://amzn.to/2rKudsw)

Parsing Techniques, Grune and Jacobs
[http://amzn.to/2rKNXfn](http://amzn.to/2rKNXfn)

Peopleware: Productive Projects and Teams, DeMarco and Lister
[http://amzn.to/2qTu86F](http://amzn.to/2qTu86F)

Programming Pearls, Bentley [http://amzn.to/2sIRPe9](http://amzn.to/2sIRPe9)

Software Process Design: Out of the Tar Pit, McGraw-Hill
[http://amzn.to/2rVX0v0](http://amzn.to/2rVX0v0)

Software Runaways, Glass [http://amzn.to/2qT2mHn](http://amzn.to/2qT2mHn)

Sorting and Searching, Knuth [http://amzn.to/2qQ4NWQ](http://amzn.to/2qQ4NWQ)

Structure and Interpretation of Computer Programs, Abelson and Sussman
[http://amzn.to/2qTflsk](http://amzn.to/2qTflsk)

The Art of Unit Testing, Manning
[http://amzn.to/2rsERDu](http://amzn.to/2rsERDu)

The Art of Unix Programming, ESR
[http://amzn.to/2sIAXUZ](http://amzn.to/2sIAXUZ)

The Design of Design: Essays from a Computer Scientist, Brooks
[http://amzn.to/2rsPjev](http://amzn.to/2rsPjev)

The Effective Engineer, Lau [http://amzn.to/2s9fY0X](http://amzn.to/2s9fY0X)

The Elements of Style, Strunk and White
[http://amzn.to/2svB3Qz](http://amzn.to/2svB3Qz)

The Healthy Programmer, Kutner
[http://amzn.to/2qQ2MtQ](http://amzn.to/2qQ2MtQ)

The Linux Programming Interface, Kerrisk
[http://amzn.to/2rsF8Xi](http://amzn.to/2rsF8Xi)

The Mythical Man-Month, Brooks
[http://amzn.to/2rt0dAR](http://amzn.to/2rt0dAR)

The Practice of Programming, Kernighan and Pike
[http://amzn.to/2qTje0C](http://amzn.to/2qTje0C)

The Pragmatic Programmer, Hunt and Thomas
[http://amzn.to/2s9dlvS](http://amzn.to/2s9dlvS)

The Psychology of Computer Programming, Weinberg
[http://amzn.to/2rsPypy](http://amzn.to/2rsPypy)

Transaction Processing: Concepts and Techniques, Gray and Reuter
[http://amzn.to/](http://amzn.to/)

Types and Programming Languages, Pierce
[http://amzn.to/2qT2d6G](http://amzn.to/2qT2d6G)

Understanding MySQL Internals, Pachev
[http://amzn.to/2svXuFo](http://amzn.to/2svXuFo)

Working Effectively with Legacy Code, Feathers
[http://amzn.to/2sIr09R](http://amzn.to/2sIr09R)

Zen of graphics programming, Abrash
[http://amzn.to/2rKIW6Q](http://amzn.to/2rKIW6Q)

------
tomerbd
__moby dick by herman mellvile

 __the bible / unknown author

 __the new testament / various

~~~
emodendroket
The New Testament is part of the Bible.

~~~
tomerbd
i see in my native language (hebrew) it's not.

~~~
emodendroket
Oh. We call that one the Old Testament or the Hebrew Bible.

