Ask HN: What language-agnostic programming books should I read? - <AUTHOR> Until now I've read:<p>- The Healthy Programmer<p>- Clean Code<p>- Test-Driven Development by Example<p>What should I add to my library? <comment><USER4> 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.

<comment><USER5> 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.

<comment><USER6> 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.

<comment><USER7> 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.)

</comment></comment></comment></comment><comment><USER8> 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.

<comment><USER9> 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.

<comment><USER10> "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.

<comment><USER11> 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.

<comment><USER10> "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.

<comment><USER12> 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.

<comment><USER10> _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.

<comment><USER12> > 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.

<comment><USER10> "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.

</comment></comment></comment></comment></comment></comment></comment></comment></comment><comment><USER13> The Pragmatic Programmer: [https://pragprog.com/book/tpp/the-pragmatic- programmer](https://pragprog.com/book/tpp/the-pragmatic-programmer)

<comment><USER14> Plus 1 to this one and another one by the same Publisher is 'Pragmatic Thinking & Learning Refactor your Wetware'

<comment><USER6> 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.

</comment></comment></comment><comment><USER15> 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.

<comment><USER16> I'd find it quite hard to apply lessons from SCIP using java or c...

<comment><USER17> 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.)

<comment><USER18> They're indications the book is also not 'language-agnostic', for all of its merits. The language is there for pedagogic purpose.

<comment><USER17> 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.

<comment><USER18> 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'.

<comment><USER17> 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)

<comment><USER18> 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.

</comment></comment></comment></comment></comment></comment></comment></comment><comment><USER19> _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.

<comment><USER20> Correction: Jon Bentley

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

</comment></comment><comment><USER21> I really like:

\- Code Complete by Steve McConnell

\- The Effective Engineer by Edmond Lau

\- The Pragmatic Programmer by Andrew Hunt and David Thomas

<comment><USER22> 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.

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

</comment></comment></comment><comment><USER24> "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)

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

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

<comment><USER26> Very good. A good book to go with it is: Learning Computer Architecture with the Raspberry Pi.

<comment><USER27> This looks amazing(and affordable). I had not heard of this. Thanks for sharing!

<comment><USER26> 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.

</comment></comment></comment></comment><comment><USER28> 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.

<comment><USER29> +1 for SQL Performance Explained. One of the best vendor agnostic resources for understanding how databases work.

</comment></comment><comment><USER30> 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

<comment><USER31> 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.

<comment><USER32> 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)

<comment><USER7> 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.)

<comment><USER32> 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.

<comment><USER30> 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

</comment></comment></comment></comment></comment></comment><comment><USER33> '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.

</comment><comment><USER34> 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.

<comment><USER35> Also noteworthy in that series is Founders at Work, and Gamers at Work.

</comment></comment><comment><USER36> 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.

</comment><comment><USER37> 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)

</comment><comment><USER38> \- 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.

<comment><USER39> Also in MOOC form now too:

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

</comment></comment><comment><USER40> Its odd that no one mentioned it but head first into design patterns is a great/light book on design patterns....

<comment><USER41> 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.

<comment><USER42> YMMV. I found the style extremely distracting to the subject matter.

</comment></comment></comment><comment><USER43> 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.

<comment><USER44> +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.

</comment></comment><comment><USER45> 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.

<comment><USER46> Agreed. Scheme itself is "not much of s language." It's like a language- agnostic language.

</comment></comment><comment><USER47> I would recommend "Sorting and Searching" Volume 3 from Donald Knuth's "The Art of Computer Programming". Fantastic, in-depth read.

<comment><USER48> 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.

<comment><USER49> 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.

<comment><USER50> 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.

</comment></comment></comment></comment><comment><USER51> Gödel, Escher, Bach: An Eternal Golden Braid by Douglas Hofstadter is about the intersection of music, math, and computers.

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

<comment><USER51> Any to recommend?

<comment><USER33> '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.

</comment></comment></comment></comment><comment><USER53> "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/)

<comment><USER54> 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.

</comment></comment><comment><USER55> 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.

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

</comment></comment><comment><USER57> 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.)

<comment><USER58> 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.

<comment><USER59> 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.

</comment></comment></comment><comment><USER60> 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.

</comment><comment><USER61> Thinking Forth

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

Teaches you to think simple and elegant.

<comment><USER62> 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.

</comment></comment><comment><USER63> _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.

<comment><USER64> 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.

</comment></comment><comment><USER65> _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.

</comment><comment><USER66> 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

</comment><comment><USER67> 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)

</comment><comment><USER68> 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)

</comment><comment><USER69> 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)

<comment><USER70> 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.

</comment></comment><comment><USER71> 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.

</comment><comment><USER72> 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.

<comment><USER73> Why this was downvoted?

<comment><USER73> Why was this downvoted?

</comment></comment></comment><comment><USER74> 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/)

<comment><USER75> +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.

</comment></comment><comment><USER76> 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.

<comment><USER77> > 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

<comment><USER6> 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.

</comment></comment></comment><comment><USER78> _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).

<comment><USER79> Whilst being a great book, you are definitely correct in your assertion that this book is not agnostic!

<comment><USER78> True, but it goes into a lot of different languages, which can amount to the same thing

</comment></comment></comment><comment> 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.

<comment><USER80> Love the Little Schemer! Lots of interesting and challenging questions!

</comment></comment><comment><USER81> 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!)

<comment><USER82> 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)

</comment></comment><comment><USER83> 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.

</comment><comment><USER84> 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.

</comment><comment><USER85> 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.

</comment><comment><USER86> The Psychology of Computer Programming by Gerald M. Weinberg

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

<comment><USER33> 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.

</comment></comment><comment><USER87> 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.

<comment><USER6> 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.

<comment><USER88> You can do some (most) of the stuff using interfaces/protocols in languages that support these.

<comment><USER6> It's not quite as natural, though. On the other hand, making it explicit is often a Good Thing.

</comment></comment></comment></comment><comment><USER89> "Types and Programming Languages" (aka "tapl")

<comment><USER90> 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).

</comment></comment><comment><USER91> 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

</comment><comment><USER92> * "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)

</comment><comment><USER93> Any good book on statistics would be a huge asset, as well as a book about debugging strategies.

<comment><USER94> > _as well as a book about debugging strategies_

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

<comment><USER52> [https://news.ycombinator.com/item?id=9242384](https://news.ycombinator.com/item?id=9242384)

</comment></comment></comment><comment><USER95> 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.

<comment><USER96> 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.

</comment></comment><comment><USER97> 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'.

</comment><comment><USER98> 'The Pragmatic Programmer' is a fantastic language-agnostic manual that still applies heavily today.

</comment><comment><USER99> 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.

<comment><USER33> 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.

</comment></comment><comment><USER100> _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.

</comment><comment><USER101> "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.

<comment><USER102> 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).

</comment></comment><comment><USER103> "How to Solve It" by George Pólya

</comment><comment><USER104> "Peopleware: Productive Projects and Teams" by DeMarco and Lister.

</comment><comment><USER105> An old standard: The Mythical Man Month by Fred Brooks.

<comment><USER106> 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.

</comment></comment><comment><USER107> 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)

</comment><comment><USER108> 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)

</comment><comment><USER109> 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.

</comment><comment><USER110> 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.

</comment><comment><USER111> Martin Fowler's _Refactoring_

</comment><comment><USER112> 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.

</comment><comment><USER113> "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.

</comment><comment><USER114> Smalltalk Best Practices by Kent Beck. I feel the advice and experience this book provides goes well beyond Smalltalk.

</comment><comment><USER115> 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".

</comment><comment><USER116> "The Art of Readable Code", by Dustin Boswell and Trevor Foucher. Simple ways to make code more readable.

</comment><comment><USER117> 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.

<comment><USER118> 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.

</comment></comment><comment><USER119> \- 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.

<comment><USER120> The Art of Motorcycle Maintenance?

<comment><USER121> 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.

<comment><USER120> 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.

<comment><USER121> 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.

<comment><USER52> 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.

</comment></comment></comment></comment></comment></comment><comment><USER122> 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.

</comment><comment><USER123> 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.

</comment><comment><USER124> "The Pragmatic Programmer" by Andy Hunt and Dave Thomas

</comment><comment><USER125> 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.

</comment><comment><USER126> "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.

</comment><comment><USER127> Effective Java (lots of good generic OOP advice)

Implementing Domain Driven Design

<comment><USER128> 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.

<comment><USER129> 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..

</comment></comment></comment><comment><USER130> \- 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

</comment><comment><USER131> If I can suggest a talk rather than a book, "Hammock Driven Development" by Rich Hickey (creator of Clojure) is one of my favourites.

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

</comment><comment><USER133> 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.

</comment><comment><USER134> 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.

</comment><comment> 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.

</comment><comment><USER135> 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.

<comment><USER136> 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.

</comment></comment><comment><USER137> 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)

</comment><comment><USER138> "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.

</comment><comment><USER139> 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

</comment><comment><USER140> _Programming Pearls_ by Jon Bentley.

</comment><comment> 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)

</comment><comment><USER141> 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)

</comment><comment><USER142> 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 - <USER3> 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.

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

</comment></comment><comment><USER143> 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.

</comment><comment><USER144> Release It! by Micheal Nygard. Excellent advice and patterns about building robust software.

</comment><comment><USER145> 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.

<comment><USER146> > 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.

<comment><USER79> 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...)

</comment></comment></comment><comment><USER147> 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)

</comment><comment><USER148> The Elements of Programming. They use C++ but it isn't about C++ at all

</comment><comment><USER149> 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.

</comment><comment><USER6> 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.

<comment><USER150> these are all great! thanks

</comment></comment><comment><USER151> Concepts, Techniques, and Models of Computer Programming - Peter Van Roy

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

</comment><comment><USER153> The Practice of Programming

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

</comment><comment><USER154> \- 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

</comment><comment><USER155> Code complete

Refactoring

Patterns of enterprise architecture

</comment><comment><USER156> * Mythical Man Month

* Pragmatic Programmer

* Code Complete

</comment><comment><USER157> 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

</comment><comment><USER158> "Dynamics of Software Development" by Jim McCarthy

</comment><comment><USER159> 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.

</comment><comment><USER160> For our Algorithms class in Applied Mathematics we used:

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

Kleinberg, Tardos: "Algorithm Design" (Pearson)

</comment><comment><USER161> 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.

</comment><comment><USER162> Check reading lists in [https://www.joelonsoftware.com/](https://www.joelonsoftware.com/)

</comment><comment><USER163> \- Computer Systems: A Programmer's Perspective

</comment><comment><USER82> Here are my recommendations. Each is a placeholder for a complete discussion :)

Psychology of Programming

</comment><comment></comment><comment></comment><comment></comment><comment>=

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

</comment><comment></comment><comment></comment><comment>

\- "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

</comment><comment>====

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

</comment><comment></comment><comment>=====

\- "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.

</comment><comment><USER164> Working Effectively With Unit Tests is quite useful. It's focused on Java but the advice given applies well beyond that.

</comment><comment><USER14> I'd also recommend Artificial Intelligence: A Modern Approach written by Stuart J. Russell and Peter Norvig.

</comment><comment><USER165> [http://computationbook.com/](http://computationbook.com/)

</comment><comment><USER166> "Fundamental Algorithms", Knuth.

</comment><comment><USER167> 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/)

</comment><comment><USER168> Thinking FORTH (yes it's language agnostic, even though it's about FORTH)

</comment><comment><USER169> Death March is a good one for understanding how and why projects fail.

</comment><comment><USER170> Introduction to functional programming 1st edition by Richard Bird

</comment><comment><USER171> Why New Systems Fail: Theory and Practice Collide by Phil Simon

</comment><comment><USER172> "A Discipline of Programming" by Edsger Dijkstra.

</comment><comment><USER173> 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.

</comment><comment><USER174> The Pragmatic Programmer by Andrew Hunt and David Thomas

<comment> 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 :)

</comment></comment><comment><USER7> Fred Brook's "The Mythical Man Month".

</comment><comment><USER175> Pragmatic Practices of an Agile Developer!

</comment><comment><USER176> I liked "founders at work"

</comment><comment><USER177> Code, the Hidden... is a great read

</comment><comment><USER178> The Annotated Turing by C. Petzold

</comment><comment><USER179> The Pragmatic Programmer

</comment><comment><USER180> [deleted]

<comment><USER181> What is 'watch this?'

<comment><USER180> Sorry, I accidentally commented on the wrong post somehow. Unfortunately, I can't delete the comment.

</comment></comment></comment><comment><USER129> 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.

</comment><comment><USER182> 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)

</comment><comment><USER183> __moby dick by herman mellvile

 __the bible / unknown author

 __the new testament / various

<comment><USER184> The New Testament is part of the Bible.

<comment><USER183> i see in my native language (hebrew) it's not.

<comment><USER184> Oh. We call that one the Old Testament or the Hebrew Bible.</comment></comment></comment></comment>


Global Survey of Autonomous Vehicle Regulations - <AUTHOR> https://medium.com/@Synced/global-survey-of-autonomous-vehicle-regulations-6b8608f205f9 <comment><AUTHOR> Synced surveyed the international regulations, and here are our picks of major regions and countries that are accommodating the testing and deployment of autonomous driving technologies on their public roads.</comment>


Hong Kong Is Winning the Global Public-Opinion War with Beijing - <AUTHOR> https://www.theatlantic.com/international/archive/2019/09/hong-kong-public-opinion-beijing/599059/ <comment><USER2> Off-topic submission from an account that submits only HK-related political and orientated contents. HN is not for political battling.

<comment><USER3> You created an account just to say this?

<comment><AUTHOR> I guess they did.

For posting this article, I'm sorry if it wasn't appropriate for HN for anything, but I think the story around:

"The city's protest movement has unofficial representatives, crowdfunded advertising, viral videos, and much else that has caught China off guard."

might be interesting to the HN audience.

</comment></comment></comment><comment><USER4> Hasn't this always been the case though?

Globally everyone supported the Umbrella revolution. Generally the world doesn't like China from an ethics point of view. Who would be in favor of "Arrest and extradition without trial for voicing governmental dissidence to China." without being pro-authoritarian?

For me, the real question is whether all this will translate into actual policy in favor of demonstrator's demands.

The strategy, I believe, sits in monetary policy. Hong Kong still represents high quality, safe money. With China's economy slowing and Trump's trade war, there's lots of pressure to keep Hong Kong as a stable financial center.

Just maybe then, some favorable policy can be realized.

<comment><USER5> Definitely worried there's going to be a mass disappearance. CCP might be willing destroy the city rather than admit that people with free choice just aren't that into them.

Braver than I am, that's for sure.</comment></comment>


Slovak Constitutional Court cancels mass surveillance of citizens - <AUTHOR> http://www.eisionline.org/index.php/sk/projekty-m-2/ochrana-sukromia/109-the-slovak-constitutional-court-cancelled-mass-surveillance-of-citizens <comment><USER2> This is related to "Data Retention Directive" [1] which was declared invalid by EU Court of Justice for violating EU Charter of Fundamental Rights.

It means member EU states must update their legislation which will prohibit metadata retention by communication operators (including ISPs) to absolute minimum (generally only what's required for invoicing).

That's why this ruling by Slovak Constitutional Court seems a bit pointless. Slovak parliament would prohibit mass surveillance sooner or later anyway as a result of EU Court of Justice ruling.

[1]: [http://en.wikipedia.org/wiki/Data_Retention_Directive](http://en.wikipedia.org/wiki/Data_Retention_Directive)

<comment><USER3> I wonder why politicians that enact unconstitutional laws don't get punished. They breached the rules. Everybody else except bankers and the police get punished for that.

<comment><USER4> Leaders who do unconstitutional things might be. If you trample on your citizens sufficiently, you might live to see the inside of the Hague.

But it would be completely ridiculous to imprison someone for passing a law. The process here did _exactly_ what it's supposed to do. Politicians make a law. People are unhappy with said law and challenge it. People win in court. Law is no longer in force and the people get their redress.

Also, politicians might enact an unconstitutional law with popular support. And even if that doesn't happen, it is far from obvious what is constitutional and what is not. Should John McCain go to prison because of Citizens United? Should local politicians be incarcerated after the city lost McDonald v Chicago? That would be ridiculous.

Lastly it would mean punishing people for something that doesn't have an enumerated punishment. We don't do that in the modern world.

<comment><USER5> Intentionally violating the constitution is a violation of the privileges of office. If it can be proven, they should be forced out of office.

As for the "punishment", it should clearly correspond to the actual law having been passed, and in what manner it infringed on the constitutional rights of citizens.

Popular support does not make this any better, as minorities are usually the ones who end up hurt.

<comment><USER4> Politicians can be forced out of office for anything. It's called elections. Most countries also have some kind of impeachment process.

Are you saying politicians shouldn't attempt to do what their constituents sent them to do, under the penalty of _imprisonment_? Minorities are protected not by politics, rather by judicial review, which worked great in this case.

<comment><USER5> Are you suggesting that elections should give people a status that puts them beyond the countries constitution?

Remember that these principles are so general, they must apply equally to Western politicians pushing security policies, as to e.g. Muslim politicians in Egypt or other ME countries pushing for Sharia-inspired policies.

What their constituents want is a nice idea until this violates the most basic rights of citizens spelled out clearly for this purpose, i.e. to guide and limit any future laws.

That being said, there is always the possibility of revising the constitution. Even if that is not a good idea. But for good reason, that is a lot more difficult to accomplish.

<comment><USER6> I don't know the specifics here, but as far as I know it is fairly rare for constitutions to have language that specifically make it illegal for their politicians to pass a law. The US is a strange outlier there with its use of phrases like "Congress shall make no law (...)".

The issue is not that elections give people a status that puts them beyond the constitution, but that the constitutions rarely make it a crime to pass unconstitutional laws at all:

In most cases of unconstitutional laws, the laws tend to be unconstitutional not because it is against the law to pass them, but because the rules they add can't be reconciled with portions of the constitution in question, and so are found to be invalid or similar.

Even in the case of the US - or any other countries with similar language - note that even in those cases constitutions specifically does not (at least not in _any_ case I know about) follow the pattern of a criminal code: It does not set criteria for punishment. So even if you were to get a court to assign blame and e.g. "convict" Congress, there would be no consequence.

If you want politicians to be punished for passing such laws, then that in itself would require a massive constitutional change.

Generally you should assume that this is intentional, given that the judiciary is explicitly separate and independent, and so one can rarely assume that individual politicians can know whether or not any given law will at some future date be found to conflict with the constitution. Especially given that interpretations of constitutional law, as any other, tends to evolve over time. Sure - there might be the odd really blatant attempt at passing something silly - but those really blatant attempts are also the least dangerous and least important, as they will be struck down quickly.

The dangerous ones are exactly the ones that are sneakily enough formulated that they stand a chance to escape unscathed. But then, those are also the ones where it is unreasonable to assume that the people voting for it had reason to believe it would be unconstitutional.

<comment><USER5> Contrarily I would expect a clause prohibiting unconstitutional laws in pretty much every single constitution ever written.

As you say however, constitutions rarely define crimes, and so making the passing of unconstitutional laws a crime would be an unexpected outlier. This is not however what I am talking about.

In passing a law that knowingly violates the constitution, the politicians are acting to _enable_ crimes, or rather, actions considered crimes under existing legislation. This action takes place before the new (later to be hopefully struck down) law is passed, and should be considered a criminal act.

As far as knowing what they are doing affecting their conviction or punishment, I fully agree that not understanding that their actions will lead to "necessarily criminal" consequences, should be considered a mitigating factor.

<comment><USER6> > Contrarily I would expect a clause prohibiting unconstitutional laws in > pretty much every single constitution ever written.

That would be _very_ strange. Not even the US constitution has that because it would be legally redundant. Of course a law that is inconsistent with the constitution is invalid. There's no need to state that.

What the US constitution does is in itself unusual when it specifically calls out what types of laws Congress can't pass rather than setting out principles that would render these laws invalid because they'd conflict.

E.g. Norway's constitution used to have a clause that states a "right to work" rather than stating that parliament can not pass laws that have the effect of restricting peoples right to work. The effect is the same, and the former approach is to my knowledge far more common in constitutional law.

> In passing a law that knowingly violates the constitution, the politicians > are acting to _enable_ crimes, or rather, actions considered crimes under > existing legislation.

A major part of a parliaments _function_ is to alter what is considered crimes under existing legislation. If they can not do this without fear of criminal prosecution if one of these laws are found to conflict with the constitution... Well, that constitution would be amended very quickly after it becomes obvious no laws gets passed anymore once politicians fear the whims of a constitutional court which can change with every new appointment.

<comment><USER5> You might be right about this. I found no mention of this at all in the Norwegian constitution, and I found various clauses explicitly giving immunity for votes cast during their tenure in several other constitutions I looked at. This presumably also applies to laws later ruled unconstitutional.

It is not what I would have expected, and strikes me as an oversight. Moreover, it reeks of entitlement.

There should never be any necessity to pass laws that even come close to violating a constitution, so no, I do not believe it would slow down the legislative process.

Instead, it would provide an incentive to avoid passing laws which will hopefully soon be struck down again, some 2-10 years later, but may cause damage to society in the meantime.

If politicians need to be afraid of the constitutional court for passing a specific bill, they should not pass it. There is also usually a way to demand an opinion from the court before a bill is passed, which might absolve them in this regard.

Surely the incentives should be set up to avoid unconstitutional laws from ever being passed in the first place, and not to only be active for "short" periods at a time?

</comment></comment></comment></comment></comment></comment></comment></comment></comment></comment><comment><USER7> I expect some small EU countries, probably East-European, have governments that are agile/smart enough to pull serious datacenter biz into their borders by passing sensible legislation and backing it up with actual (non-)action.

They are in many ways more sovereign then the larger and/or more economically developed EU nations. And they still have politicians that are concerned with (democratic) principles, instead of the two-faced puppets of plutocracy that we find waaaay to often in high public positions.

Go Slovakia!

<comment><USER8> Clearly you don't live in the region. Since I've lived in both Central Europe and the UK and US, I can guarantee you that corruption blossoms (at least as judged by the public) everywhere the same.

P.S.: Slovakia is in Central, not Eastern Europe, and things get generally worse as you go East.

<comment><USER9> Transparency International publishes this thing so we don't need to go by gut feelings re. corruption as judged by the public:

[http://www.transparency.org/cpi2014/results](http://www.transparency.org/cpi2014/results)

Spoiler: Big differences across Europe

<comment><USER10> I love how Greenland's, like, some sort of anti-corruption candle on that map.

Also, I'm surprised that New Zealand, of all places, ranks higher than all but Denmark in cleanliness (and not surprised that North Korea and Somalia are tied in corruption).

</comment></comment></comment></comment><comment><USER11> Rest of the EU: Please follow this example.

<comment><USER12> It's already shut/shot down in multiple EU countries. E.g. in The Netherlands in March and in Germany in 2010.

There seems to be a complete overview here:

[http://wiki.vorratsdatenspeicherung.de/Transposition](http://wiki.vorratsdatenspeicherung.de/Transposition)

<comment><USER13> Yes but some have no intention of annulling it. Sweden, for instance.

</comment></comment></comment><comment><USER14> I want to see more and more countries adopt a similar measure publicly, because as more countries pass such laws, the more it bluntly highlights that the "Land of the Free" can only live up to that maxim if it too passes laws canceling mass surveillance of its citizens.

<comment><USER15> Are you saying if more countries adopt things US will too?

Cause we all know that is just not true.

</comment></comment><comment><USER16> Does the "Data Retention Directive" [1] also apply to UK?

[1] [http://en.wikipedia.org/wiki/Data_Retention_Directive](http://en.wikipedia.org/wiki/Data_Retention_Directive)

<comment><USER17> If it wouldn't have been challenged in the CJEU and thus made invalid everywhere, yes it would.

</comment></comment><comment><USER18> If only enough other countries did this same thing... that there was enormous enough pressure on the usual suspects (US, UK, NZ, CA, AU) to do this too.

I'm afraid we're long past the point of that happening, though, and it makes me sad.

</comment><comment><USER19> Wow I wish we had Slovakian jurists here in USA.

<comment><USER20> No, you don't. (-; As we say in Slovak, one swallow does not make summer. Good decisions like this one are massively outnumbered by "process errors" (or whatever it is called on English) covering the asses of mafia backed by our elected government officials.

<comment><USER21> Not exactly a slovak saying, comes from greece

From wikitionary

An allusion to the return of migrating swallows at the start of the summer season. From a remark by Aristotle (384 BCE - 322 BCE): "One swallow does not a summer make, nor one fine day; similarly one day or brief time of happiness does not make a person entirely happy."

<comment><USER20> I don't recall claiming that this saying originates from Slovakia, only that it's one that is relatively common there. I have also heard it used in Czech, but I don't think I've ever heard it in English, hence the remark.

</comment></comment></comment></comment><comment><USER22> EU countries decided to create the directive, and then implemented this while it was in force. It is slovak government

</comment><comment><USER23> I cannot find any source in Slovakian language (I can understand it). Does anyone have that?

<comment><USER24> See links at the bottom of [http://www.eisionline.org/index.php/sk/projekty-m-2/ochrana-...](http://www.eisionline.org/index.php/sk/projekty-m-2/ochrana- sukromia/108-ustavny-sud-sr-zrusil-plosne-sledovanie-obcanov)

<comment><USER23> Thanks!</comment></comment></comment>


Why funding shouldn't be your first step - <AUTHOR> http://howtosplitanatom.com/news/why-funding-shouldnt-be-your-first-step/

<comment><USER2> There is something to be said about getting reasonable growth under your belt before going out and starting on the funding treadmill. Trying to get money when you're product isn't "worth it" is a huge time waster.

</comment><comment><USER3> It's also a whole let less stressful when you already have enough stress to worry about</comment>