Until now I've read:
- The Healthy Programmer
- Clean Code
- Test-Driven Development by Example
What should I add to my library?
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.
The Pragmatic Programmer: https://pragprog.com/book/tpp/the-pragmatic-programmer
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.
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.
"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...
[2]: http://www.informit.com/articles/article.aspx?p=1600886
I really like:
- Code Complete by Steve McConnell
- The Effective Engineer by Edmond Lau
- The Pragmatic Programmer by Andrew Hunt and David Thomas
Code: The Hidden Language of Computer Hardware and Software by Charles Petzold. I love this book.
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 SchneierSQL 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
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.
'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.
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.
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.
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. ```
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.
- 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.
Its odd that no one mentioned it but head first into design patterns is a great/light book on design patterns....
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.
I would recommend "Sorting and Searching" Volume 3 from Donald Knuth's "The Art of Computer Programming". Fantastic, in-depth read.
Gödel, Escher, Bach: An Eternal Golden Braid by Douglas Hofstadter is about the intersection of music, math, and computers.
"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...
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.
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.)
Can I plug my book, 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.
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.
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.
The Aosa series of books are brilliant imho:
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 lessAgile 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...
I think "The Practice of Programming" was and is very good.
https://www.amazon.com/Practice-Programming-Addison-Wesley-P...
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.
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.
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.
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...
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...
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...
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...
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.
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).
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.
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!)
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.
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/
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.
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.
The Psychology of Computer Programming by Gerald M. Weinberg
It's an old book but the most eye-opening one to me.
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.
"Types and Programming Languages" (aka "tapl")
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
* "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)
Any good book on statistics would be a huge asset, as well as a book about debugging strategies.
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.
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'.
'The Pragmatic Programmer' is a fantastic language-agnostic manual that still applies heavily today.
Any computer themed book of Gerald M. Weinberg is a must read: 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.
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.
"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.
"How to Solve It" by George PĂłlya
"Peopleware: Productive Projects and Teams" by DeMarco and Lister.
An old standard: The Mythical Man Month by Fred Brooks.
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...
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...
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.
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.
Martin Fowler's Refactoring
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.
"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.
Smalltalk Best Practices by Kent Beck. I feel the advice and experience this book provides goes well beyond Smalltalk.
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".
"The Art of Readable Code", by Dustin Boswell and Trevor Foucher. Simple ways to make code more readable.
The 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.
- 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.
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...
A really well written short glimpse of things every programmer must know.
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.
"The Pragmatic Programmer" by Andy Hunt and Dave Thomas
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.
"Programmers at Work: Interviews With 19 Programmers Who Shaped the Computer Industry" by Susan Lammers.
https://www.amazon.com/Programmers-Work-Interviews-Computer-...
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.
Effective Java (lots of good generic OOP advice)
Implementing Domain Driven Design
- 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
If I can suggest a talk rather than a book, "Hammock Driven Development" by Rich Hickey (creator of Clojure) is one of my favourites.
Best design pattern book i've read is "Head First Design Patterns: A Brain-Friendly Guide". It's fun and very informative.
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.
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.
Not exactly language-agnostic, nor about programming per se, nor a book, but [Google Style Guides](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.
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.
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...
"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.
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
Programming Pearls by Jon Bentley.
Algorithmics: the Spirit of Computing by David Harel[1] is really fantastic, can't recommend it enough.
I recognized my experience, and really liked:
Software Craftsmanship - The New Imperative, Pete McBreen
http://www.goodreads.com/book/show/1035377.Software_Craftsma...
A Pattern Language by by Christopher Alexander, Sara Ishikawa and Murray Silverstein. https://en.wikipedia.org/wiki/A_Pattern_Language
From a blog post ( http://the-whiteboard.github.io/book/review/2016/02/17/five-... ) 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.
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.
Release It! by Micheal Nygard. Excellent advice and patterns about building robust software.
Purely functional data structures by Chris Okasaki
Let Over Lambda forgot by whom
https://www.youtube.com/watch?v=0nbkaYsR94c Not technically a book, but watch it anyway.
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)
The Elements of Programming. They use C++ but it isn't about C++ at all
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.
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.
Concepts, Techniques, and Models of Computer Programming - Peter Van Roy
A plug but hopefully useful as it is basically the books read by the HN community - http://hackernewsbooks.com
The Practice of Programming
and take a look at this https://news.ycombinator.com/item?id=13448818
- 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
Code complete
Refactoring
Patterns of enterprise architecture
* Mythical Man Month
* Pragmatic Programmer
* Code Complete
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
"Dynamics of Software Development" by Jim McCarthy
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.
For our Algorithms class in Applied Mathematics we used:
Dasgupta, Papadimitriou and Vazirani: "Algorithms" (McGraw Hill)
Kleinberg, Tardos: "Algorithm Design" (Pearson)
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.
- Computer Systems: A Programmer's Perspective
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
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.
Working Effectively With Unit Tests is quite useful. It's focused on Java but the advice given applies well beyond that.
I'd also recommend Artificial Intelligence: A Modern Approach written by Stuart J. Russell and Peter Norvig.
"Fundamental Algorithms", Knuth.
this guy has a blog that recommends a lot of great books http://www.catonmat.net/blog/top-100-books-part-one/
Thinking FORTH (yes it's language agnostic, even though it's about FORTH)
Death March is a good one for understanding how and why projects fail.
Introduction to functional programming 1st edition by Richard Bird
Why New Systems Fail: Theory and Practice Collide by Phil Simon
"A Discipline of Programming" by Edsger Dijkstra.
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.
The Pragmatic Programmer by Andrew Hunt and David Thomas
Fred Brook's "The Mythical Man Month".
Pragmatic Practices of an Agile Developer!
I liked "founders at work"
Code, the Hidden... is a great read
The Annotated Turing by C. Petzold
The Pragmatic Programmer
[deleted]
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.
Check reading lists in https://www.joelonsoftware.com/
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
Advanced Programming in the Unix Environment , Stevens http://amzn.to/2qPOMjN
Algorithmics: the Spirit of Computing, Harel http://amzn.to/2rW5FNS
Applied Crytography, Wiley http://amzn.to/2rsULxS
Clean Code, Martin http://amzn.to/2sIOWtQ
Clean Coder, Martin http://amzn.to/2rWgbEP
Code Complete, McConnel http://amzn.to/2qSUIwE
Code: The Hidden Language of Computer Hardware and Software, Petzold http://amzn.to/2rWfR9d
Coders at Work, Seibel http://amzn.to/2qPCasZ
Compilers: Principles, Techniques, & Tools, Aho http://amzn.to/2rCSUVA
Computer Systems: A Programmer's Perspective, O'Hallaron and Bryant http://amzn.to/2qPY5jH
Data Flow Analysis: Theory and Practice, Khedker http://amzn.to/2qTnSvr
Dependency Injection in .NET, Seemann http://amzn.to/2rCz0tV
Domain Driven Design, Evans http://amzn.to/2sIGM4N
Fundamentals of Wireless Communication, Tse and Viswanath http://amzn.to/2rCTmTM
Genetic Programming: An Intrduction, Banzhaf http://amzn.to/2s9sdut
Head First Design Patterns, O'Reilly http://amzn.to/2rCISUB
Implementing Domain-Driven Design, Vernon http://amzn.to/2qQ2G5u
Intrduction to Algorithms, CLRS http://amzn.to/2qXmSBU
Introduction to General Systems Thinking, Weinberg http://amzn.to/2qTuGJw
Joy of Clojure, Fogus and Houser http://amzn.to/2qPL4qr
Let over Lambda, Hoyte http://amzn.to/2rWljcp
Operating Systems: Design and Implementation, Tanenbaum http://amzn.to/2rKudsw
Parsing Techniques, Grune and Jacobs http://amzn.to/2rKNXfn
Peopleware: Productive Projects and Teams, DeMarco and Lister http://amzn.to/2qTu86F
Programming Pearls, Bentley http://amzn.to/2sIRPe9
Software Process Design: Out of the Tar Pit, McGraw-Hill http://amzn.to/2rVX0v0
Software Runaways, Glass http://amzn.to/2qT2mHn
Sorting and Searching, Knuth http://amzn.to/2qQ4NWQ
Structure and Interpretation of Computer Programs, Abelson and Sussman http://amzn.to/2qTflsk
The Art of Unit Testing, Manning http://amzn.to/2rsERDu
The Art of Unix Programming, ESR http://amzn.to/2sIAXUZ
The Design of Design: Essays from a Computer Scientist, Brooks http://amzn.to/2rsPjev
The Effective Engineer, Lau http://amzn.to/2s9fY0X
The Elements of Style, Strunk and White http://amzn.to/2svB3Qz
The Healthy Programmer, Kutner http://amzn.to/2qQ2MtQ
The Linux Programming Interface, Kerrisk http://amzn.to/2rsF8Xi
The Mythical Man-Month, Brooks http://amzn.to/2rt0dAR
The Practice of Programming, Kernighan and Pike http://amzn.to/2qTje0C
The Pragmatic Programmer, Hunt and Thomas http://amzn.to/2s9dlvS
The Psychology of Computer Programming, Weinberg http://amzn.to/2rsPypy
Transaction Processing: Concepts and Techniques, Gray and Reuter http://amzn.to/
Types and Programming Languages, Pierce http://amzn.to/2qT2d6G
Understanding MySQL Internals, Pachev http://amzn.to/2svXuFo
Working Effectively with Legacy Code, Feathers http://amzn.to/2sIr09R
Zen of graphics programming, Abrash http://amzn.to/2rKIW6Q
moby dick by herman mellvile
the bible / unknown author
the new testament / various
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.