Ask HN: What's the best computer science book you've read recently?

Working through the class on Coursera now, and it's a lot of fun. https://www.coursera.org/learn/build-a-computer

10 years in my to-read pile and going strong.

I'd definitely recommend TECS for folks looking to learn more about the many layers of abstraction sitting under their interpreter/VM. Also worth taking a look at the Little OS Book or the OSDev wiki for some more insight into a less idealized/more crufty architecture.

I wound up spending the most time playing around with chapter 9 (the Tetris part of Nand to Teris) and made a very basic ray-casting game a la Wolfenstein 3D: https://youtu.be/c-J7lwKWDN8

This book influenced me tremendously. It explains how can random process (e.g. genetic mutation) builds highly non-random structures (e.g. the human eye). Recently I was using American Fuzzy Lop (http://lcamtuf.coredump.cx/afl/) to find bugs in my software, and was able to appreciate the surprising effectiveness of the "random" strategy it employs to discover structures in the program. For example, AFL could construct a valid JPEG using randomized input: https://lcamtuf.blogspot.com/2014/11/pulling-jpegs-out-of-th....

"The Plausibility of Life ends with a brief critique of intelligent design, suggesting that the concept of facilitated variation will provide a solid argument to rebut creationists. I applaud the authors' intention, as it seems to me that more scientists ought to face the realities of public misunderstanding of science. But their presentation is too brief, and a bit too simplistic. The "controversy" about evolution has nothing to do with the soundness of scientific explanations of the history of life: It's not a scientific controversy, but a social, cultural and political one. Creationism is the result of centuries of anti-intellectualism in the United States, coupled with sometimes cynical exploitation of the issue for political gain. In addition, many scientists have no interest in getting out of the ivory tower to talk to the very same public that pays their salaries and funds their precious research grants. The recent defeat of intelligent design at the trial in Dover, Pennsylvania—at the hand of a conservative judge appointed by George W. Bush—will do much more to promote sanity in public education than any theory about facilitated variation, as scientifically sound as the latter may be." http://www.americanscientist.org/bookshelf/pub/have-we-solve...

This is a great book. I love the approach, it really helps with one of the main problems with using algorithms or design patterns even and that is problem identification. There are a bunch of problems that are way easier to solve if you recognize the solution exists in dynamic programming for example, but if you don't they become very hard.

The book definitely reaches a good balance that other algorithms books don't have. It makes you want to keep reading.

Such a nice book. My personal preference is to use CLRS for reference and Skiena for people want a quick introduction to algorithms.

prepping for google interview?

I love this book for how approachable, readable, and even enjoyable it is. Skiena does a great job of motivating each of the algorithmic techniques. I recommend this one widely.

This book is highly overrated. Algorithms by Sedgewick (http://algs4.cs.princeton.edu/home/) is a much better book for learning and understanding algorithms. Skienas book is a simple collection of (sometimes very exotic) algorithms. It won't teach you anything, it will only tell you what exists.

It is a fantastic book. It doesn't take u into typical algorithms (at least that I recall), but rather it explains as intuitively as possible how a computer is built up from flip flops and binary logic to assembly, intermediate language and on to full-on compilation of a useable language.

Basically beginner programmers can acquire a broad understanding of the foundation the programs you're building are built on by reading this book. It reads more like a non-fiction expose than a programming language tutorial book, which is to say, given its subject, it's an easy read you can do on the couch. Depending on your skill and knowledge level, there may be a few sections you have to re-read several times until you understand it, but you won't feel as though you need to go over to your computer chair and try something to fully grasp it.

If you can do basic arithmetic, you can get through this book. That seems to be the hidden premise. That computers are easy and should be easy to understand. This book is a testament of that. Though I'm sure some will find this doesn't go deep enough. But the point is: learning so generally will create many entry points for you to follow up on in your journey into programming and computer science. It will clear up many things and essentially make the path seem less scary and out of reach. This book achieves that really well. High level programmers will come away feeling far less insecure about their lack of knowledge of the underpinnings of whatever it is they are developing. I know I did. I can't say enough about this book. It's the real deal. I'm sure those with a computer science degree might have more to say (that is they likely think it's a cursory overview), but I think for everyone else it's a computer science degree in a book you can read in one or two weeks. At least half the degree. For the second half, I recommend Algorithms In A Nutshell. And done! Go back to programming your high level JavaScript react app and get on with your life.

On a side note: it's my opinion that theory first is the wrong way. Application first, theory as needed is the right approach. Otherwise it's like learning music theory before u know u even like to play music. U might not even like being a programmer or be natural at it. And if u spend 4 years studying theory first, u will have spent a lot of time to discover what u could have in like a month. In addition, it can suck the joy and fun out of the exploration of programming and computer science. It's natural and fun to learn as u dive into real problems. Everything u can learn is on the internet. It's very rewarding and often faster to learn things when you are learning it to attain a specific goal. The theory u do learn seems to make much more sense in the face of some goal you are trying to apply it to. In short over ur computing career u can learn the same stuff far faster and far more enjoyably if you do so paired with actual problems.

But that said sometimes u do gotta step back and allocate time for fundamentals, even if u have no specific problem they are related to. However you will know when it's time to brush up on algorithms, or finally learn how the computer works below your day to day level of abstraction. Just know that a larger and larger percentage of us programmers went the applied route, rather than the computer science theory first + formal education route. It's probably the majority of programmers at this point in time. In short u r not alone learning this as u go. Learn to enjoy that early on and save yourself from the pain of insecurity of not knowing everything. This is an exploration and investigation, and perhaps you will make some discoveries nobody else has been able to make, and far before u have mastered and understood everything there is to know about he computer. Perhaps that's it's biggest selling point--you don't have to know everything before you can contribute to the computer world! So enjoy your pursuits in programming, knowing in your unique exploration at any time u may come up with something highly novel and valuable.

This would be my recommendation as well. It is closer to a textbook, than say a popular science book, but is still a very fun, engaging, and at times pretty funny read.

Similarly to books like GEB, it really exposed me to a whole range of fascinating ideas and topics that I am now interested in.

I second this, although I am not finished with it, I can say it is a very interesting read. Thanks for the link to the author's site which has lecture notes, I didn't know this existed. The lecture notes are easy going an have a good sense of humor, such as the following:

"It's a shame that, after proving his Completeness Theorem, Gödel never really did anything else of note. [Pause for comic effect] "

Cheers.

One of the most important books ever written on software engineering practice. Author Frederick Brooks won the Turing Award for this book and for his work on IBM's System/360 (the main example project used in the book).

http://amturing.acm.org/award_winners/brooks_1002187.cfm

This is one of the books I hear about every year and people always find useful and not outdated. Time for a read I guess

If you read that and like it, try The Design of Design by Fred Brooks, in which he talks about on a high level how the design process works; good teachings about the flaws of the waterfall model.

Another classic is https://en.wikipedia.org/wiki/Peopleware:_Productive_Project...

"It is the one thing every software manager needs to read... not just once, but once a year." (Joel Spolsky)

Everything I needed to know about taking on software projects. "Prepare to throw one away".

The insights from reading this book years ago certainly helped me navigate project management as a rescue guy. By the time I was hired, the failing project was already part way through the experience that Brooks' book is based on, and he was writing the OS!!!

He writes about the origin of the svc (supervisor call) in OS360. They needed a way to keep track of them as they were popping up from all over, so they made a list, and you added yours to it, then other groups could check the list before they wrote another version of the same function.

John Bender!!! :-P

Leonard Susskind's "Quantum Mechanics: The Theoretical Minimum" as well as Nielsen & Chuang's "Quantum Computation and Quantum Information" are also fantastic resources. I've got both sitting here on my desk :)

Fun fact: these two are married and the cutest couple. They walk to Rice's Coffeehouse almost daily together talking about whatever it is compiler professors talk about.

This book was my greatest buy ever! I once went to Fry's electronics to their book section - my expectation was to find only popular books there, when lo and behold, I see this book on compilers. I turn it over to look at the price tag, thinking I'll have to shell out something like $80 for the book and to my shock and surprise the tag says,... wait for it... $0.01 That's right one cent! At first I think this is some kind of prank and somebody peeled off a price sticker from some discounted stale candy or something and stuck it on this book. I'm of half a mind to see if I can buy slip this book by the store checker and have them just scan the one cent price tag and not to a double take. But my concsience gets the better of me and I walk up to a store clerk point out the one cent price tag and ask them to do a real price check so I can find out the fair price. The clerk looks up the book in his computer and says, nope that is the correct price in their system! So I bought "Engineering a Compiler 2nd Ed. By Cooper & Torczon" for $0.01! My greatest book buy ever!

Along these lines, "A Life out of Sequence: A Data Driven History of Bioinformatics" (http://press.uchicago.edu/ucp/books/book/chicago/L/bo1674439...)

If you you work in bioinformatics it is weird how little history the average bioinformatician knows (the field only really dates back to the late 1960s). People may know things like PAM matrices, but not Margaret Dayhoff who created them (not to mention the standard amino acid codes used today).

Also available at http://www.deeplearningbook.org/ .

I finished it up a few months ago and I cannot recommend it enough.

The real soul of SICP is in it's exercises however. It asks you to build on your own prior work in inventive ways, challenging you to solve the exercises correctly, but also to do so in a maintainable way.

I wrote up some supplementary material to make the experience smoother for a practicing programmer: High-level requirements of the chapter subprojects, Pitfalls and paradigms embedded in some of the footnotes, Answers to (nearly) all exercises, a testing framework for Chapter 4 interpreter (including the JIT compiler), a GUI for running Chapter 5 virtual machine here: https://github.com/zv/SICP-guile

This is one of the more fascinating books that I've read recently. The commentary makes the paper itself very accessible. I rather enjoyed the direct reproduction of the paper itself (with typos!) in the book, and the near line by line commentary at points. It's not the way that I would want to be taught about Turing machines, but it's amazing to see them articulated for the first time.

On my "to read" list, but haven't read it yet. However, I started watching these screencasts on Turing Machines and Lambda Calculus (examples in Python), and they are fantastic: https://www.destroyallsoftware.com/screencasts/catalog/intro...

Also, I found this blog post good: "Tech Book Face Off: Gödel, Escher, Bach Vs. The Annotated Turing" http://sam-koblenski.blogspot.se/2016/01/tech-book-face-off-...

I was very happily surprised by how much I enjoyed this book.

I found this to be helpful for learning basics of web development, https://github.com/thewhitetulip/web-dev-golang-anti-textboo...

I've been planning to get into GO this spring, would this be a good start? Or is there a possibility that it goes out of date?

This book blew my head off when it first came out (I used to work in the space). Highly recommend.

Indeed! This book is likely to be 100x more interesting than your local college's undergrad networks course.

The dozen or so principles Varghese lays out for writing fast networking code is reason enough to pick it up. The writing is very approachable, too. Reminds me more of the early network operator books than a CS text.

Wow this is a unique book! Just skimming I see Bloom filters, tries, routing protocols, sequential logic and DDOS all in same book. This looks great. Thanks for sharing.

I've been looking at this but I don't really know Haskell (just f#). In your opinion is it worth trying before knowing a Haskell? I'm mostly interested because I wish to learn f-star as well, which also has dependent types.

This is an excellent book! It was my prescribed textbook for an undergrad concurrent systems course. It's very "proofy" but explains a large amount of important concepts quite well.

The book is divided into two sections: Principles and Practice. The former introduces basic terminology, concepts and common mistakes. The latter is where it gets interesting and introduces real-world problems like cache coherence traffic.

The language used in the book is Java but the concepts can be applied to practically any language that supports concurrency. Highly recommended!

Just a head's up: for someone well versed in computer science the first two thirds of this book can be pretty dull. The majority of the time is spent explaining first year CS topics in layman's terms. After that it picked up a bit with, for example, showing how randomized algorithms can apply to types of decision making in real life.

I still think it is better suited for those with little to no CS knowledge.

I'll take the counter-point on this one. I picked it up after it was mentioned in the YC's Summer Reading List; however, I found it to be a tire to finish.

The reasons and explanations given seem to touch around a technical, but not too technical approach to algorithms. Getting stuck in a place that probably just leaves both audiences a bit unhappy. For instance, there is a chapter that mentions that the optimal stopping point is ~37%. There is never any mention about how the 37% number is found. Of course, I could look it up but I could just as well look up the optimal stopping problem.

Aside from that, the examples come across as contrived and inapplicable. Sure merge sorting your socks sounds great, but I still will never do it!

I just finished that not long ago. It's an interesting read because it places an emphasis on the value on simple and statistically effect algorithms that can be executed by humans with relatively low cognitive overload.

Many of the algorithms and ideas are familiar, but the novelty here is how one can map these CS lessons to improve performance on the human OS and human network.

And it's free online http://www-bcf.usc.edu/~gareth/ISL/ISLR%20First%20Printing.p...

I nominate it with a link http://www.deeplearningbook.org/

I didn't love this book, it was OK. It's heavily based off The Goal, and I thought that book was a bit better. I think if you have a certain dysfunction in your team AND the mandate to fix it, then The Phoenix Project is a must read. For everyone else it's kind of a waste.

Seconded. After being a FreeBSD developer for a dozen years some people might expect me to know everything this book covers, but in fact I pulled it out just last month to help me understand how some details of how the VFS layer and the NFS client worked.

Second this. Much newer than some of the other books listed here, but a great read nevertheless

I only had a chance to read part of the book (around the first 25% at most), but I found a lot of the ideas to be applicable to all forms of work. The ideas were well-explained and didn't require a software background. I intend to pick up a copy when I have the cashflow for it.

>The Cathedral and the Bazaar by Eric S. Raymond

Had reddit :)

That reminds me about the book:

Open Sources: Voices from the Open Source Revolution:

http://www.oreilly.com/openbook/opensources/book/

It is free to read at the above link. I had read many of the chapters some years ago. Pretty interesting stuff.

It consists of multiple chapters, each written by different well-known people associated with prominent projects from the open source movement, at a time when it was relatively new (1999).

The paragraphs that I remember the most from it are from this chapter:

Future of Cygnus Solutions

An Entrepreneur's Account

Michael Tiemann

(Cygnus Solutions was a company which initially ported and improved GCC and its toolchain to multiple Unix platforms, and made a business out of it, before open source was a gleam in many people's eyes. They did well and were acquired by Red Hat some years later.)

Here are the paragraphs:

[ Again, a quote from the GNU Manifesto:

There is nothing wrong with wanting pay for work, or seeking to maximize one's income, as long as one does not use means that are destructive. But the means customary in the field of software today are based on destruction.

Extracting money from users of a program by restricting their use of it is destructive because the restrictions reduce the amount and the ways that the program can be used. This reduces the amount of wealth that humanity derives from the program. When there is a deliberate choice to restrict, the harmful consequences are deliberate destruction.

The reason a good citizen does not use such destructive means to become wealthier is that, if everyone did so, we would all become poorer from the mutual destructiveness.

Heavy stuff, but the GNU Manifesto is ultimately a rational document. It dissects the nature of software, the nature of programming, the great tradition of academic learning, and concludes that regardless of the monetary consequences, there are ethical and moral imperatives to freely share information that was freely shared with you. I reached a different conclusion, one which Stallman and I have often argued, which was that the freedom to use, distribute, and modify software will prevail against any model that attempts to limit that freedom. It will prevail not for ethical reasons, but for competitive, market-driven reasons.

At first I tried to make my argument the way that Stallman made his: on the merits. I would explain how freedom to share would lead to greater innovation at lower cost, greater economies of scale through more open standards, etc., and people would universally respond "It's a great idea, but it will never work, because nobody is going to pay money for free software." After two years of polishing my rhetoric, refining my arguments, and delivering my messages to people who paid for me to fly all over the world, I never got farther than "It's a great idea, but . . .," when I had my second insight: if everybody thinks it's a great idea, it probably is, and if nobody thinks it will work, I'll have no competition!

-F = -ma Isaac Newton

You'll never see a physics textbook introduce Newton's law in this way, but mathematically speaking, it is just as valid as "F = ma". The point of this observation is that if you are careful about what assumptions you turn upside down, you can maintain the validity of your equations, though your result may look surprising. I believed that the model of providing commercial support for open-source software was something that looked impossible because people were so excited about the minus signs that they forgot to count and cancel them.

An invasion of armies can be resisted, but not an idea whose time has come. Victor Hugo

There was one final (and deeply hypothetical) question I had to answer before I was ready to drop out of the Ph.D. program at Stanford and start a company. Suppose that instead of being nearly broke, I had enough money to buy out any proprietary technology for the purposes of creating a business around that technology. I thought about Sun's technology. I thought about Digital's technology. I thought about other technology that I knew about. How long did I think I could make that business successful before somebody else who built their business around GNU would wipe me out? Would I even be able to recover my initial investment? When I realized how unattractive the position to compete with open-source software was, I knew it was an idea whose time had come.

The difference between theory and practice tends to be very small in theory, but in practice it is very large indeed. Anonymous

In this section, I will detail the theory behind the Open Source business model, and ways in which we attempted to make this theory practical.

We begin with a few famous observations: ]

And here is the full chapter by Tiemann:

http://www.oreilly.com/openbook/opensources/book/tiemans.htm...

This is a great book for introducing infosec!

Hah yes, I have it in a box somewhere. Great detailed book, highly recommend.

I think it's well intentioned and the author seems like someone who has put a lot of work into something they think is important, but it contains some terrible technical misunderstandings, and that's a real shame as I cringe thinking about a developer without a CS degree who's read this book to make themselves more confident in interviews repeating some of the stuff in it.

https://github.com/imposters-handbook/feedback/issues/50

A HN discussion on the book: https://news.ycombinator.com/item?id=12351660

I'm assuming that's:?

https://mitpress.mit.edu/books/concepts-techniques-and-model...

Concepts, Techniques, and Models of Computer Programming

https://mitpress.mit.edu/books/concepts-techniques-and-model...

Amazon links with your affiliate tag, seriously?

Practical Foundations for Programming Languages by Bob Harper is really good, plus there's a free draft of the second version on the author's site http://www.cs.cmu.edu/~rwh/pfpl.html

I always go to the book author's page first not only to get the errata but also discover things such as free lectures as in the case with Skeina's Algorithm Design Book

actually, i found the "Paradigms Of AI Programming" by peter-norvig to be waay better.

It's a fun read. 30+ years since I last read it, I'll have to bump it up on The Pile :-)

The book is basically a scam and panned. He talks about automata like it was new and he invented it. I strongly suggest you read the Amazon reviews.

It is also available online for free: http://www.wolframscience.com/nksonline/toc.html

This one is a waste of time. Nothing new expanded to (what feels like) thousands of pages.

Despite its age, I think it is still very worthwhile, just like Programming Pearls.

It seems an earlier related draft (s/Programs/Code) is available at http://repository.cmu.edu/cgi/viewcontent.cgi?article=3435&c...

When I started coding for a living in the early 1990s (in an environment where efficiency was paramount), Writing Efficient Programs was gold. I still have it, and I'm glad that to see that it's still valued.

You can save the story either by upvoting it or by clicking on the favorite button.