Ask HN: What's the best computer science book you've read recently? - bobnarizes
======
DubiousPusher
The Elements of Computing Systems: Building a Modern Computer from First
Principles by Noam Nisan and Shimon Schocken

Basically it has you hands on work through the basics of every concept active
in a modern computer save for networks and web.

You use software tools provided with the book to design memory, ALUs,
intepreters, VMs, compilers Operating Systems and applications.

Available as a free online class at
[http://www.nand2tetris.org](http://www.nand2tetris.org)

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

~~~
pestaa
I empty my inbox periodically -- no reason to keep unread stuff around.

------
webmaven
The Plausibility of Life by Kirschner & Gerhart

OK, this is an oddball one, in that a book on Evo Devo is pretty far from CS,
but reading it completely changed how I look at software architecture,
protocols, formats, programming languages, and a whole range of other CS-
related topics.

Superficially, it is what it says on the tin: an examination of the mechanisms
by which life manages to evolve at all, that keep most mutations from being
immediately lethal, and instead have a decent chance of producing
(potentially) useful variations.

But under the hood, I've found it extremely interesting how and why so many
aspects of the living world are resilient and even antifragile, and there is
are _lot_ of useful ideas and concepts to mine beyond relatively superficial
biomimicry like genetic algorithms, neural networks, or even "design for
failure" approaches for software and services.

Read it, and you won't think about "Worse is Better", "Bus Numbers", or Chaos-
Monkeys the same way ever again.

[http://yalebooks.com/book/9780300108651/plausibility-
life](http://yalebooks.com/book/9780300108651/plausibility-life)

~~~
div0
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/](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...](https://lcamtuf.blogspot.com/2014/11/pulling-jpegs-out-of-thin-
air.html).

~~~
webmaven
Hey thanks for the link, that jpeg example is really quite cool.

One of the things that I gained from the book was a bit better "feel" for
getting the right granularity/modularity in order to facilitate _evolvability_
(as in the chunks I might want to swap out for another implementation, while
leaving others in place), as a separate concern from _maintainability_.

BTW, I've noticed is that the "order blindly emerging from chaos" theme keeps
popping up in fiction by writers like Bruce Sterling, Cory Doctorow, and
Charles Stross (all favorites of mine).

------
aduffy
The Algorithm Design Manual by Skiena.

Each section contains a story of some situation he was in where he faced a
problem which he solved by applying one of various algo techniques (DP, divide
and conquer, etc.). After reading CLRS for a class, it was nice to see how
some of the most common textbook algorithms have been applied by a notable
computer scientist.

~~~
amai
This book is highly overrated. Algorithms by Sedgewick
([http://algs4.cs.princeton.edu/home/](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.

~~~
denzil_correa
> Skienas book is a simple collection of (sometimes very exotic) algorithms

It has the same material as Sedgewick, doesn't it?

~~~
amai
No, I believe there are more algorithms listed in Skienas book. But from
Skienas book you will barely understand them and it won't teach you how to
really implement them. Sedgewicks book is much better in that respect. One can
compile and run the given Java examples and actually play around with them.
Skienas book is a good reference for postdocs in algorithmic design.
Sedgewicks book on the other hand is for people who actually want to implement
these algorithms.

------
relics443
I still haven't read anything better than Code by Charles Petzold [1] and it's
not even close.

[1] [https://www.amazon.com/Code-Language-Computer-Hardware-
Softw...](https://www.amazon.com/Code-Language-Computer-Hardware-
Software/dp/0735611319)

~~~
faceyspacey
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.

~~~
bluesilver07
Is this book relevant only to beginners? Do you think a programmer with about
7 years of experience (in C, C++, C#, Java) will find it useful?

~~~
rickhanlonii
It's a really short and interesting read. It's difficult to think anyone could
read it and find it to be a waste of time.

------
simon_acca
Quantum Computing Since Democritus by Scott Aaronson.

A brilliant MIT professor's reflections on the intersection between computer
science, physics and philosophy.

Here are the lecture notes and book:
[http://www.scottaaronson.com/democritus/](http://www.scottaaronson.com/democritus/)

I also very much recommend the author's blog:
[http://www.scottaaronson.com/blog/](http://www.scottaaronson.com/blog/)

~~~
bogomipz
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.

------
johntran
The Mythical Man-Month.

[https://en.wikipedia.org/wiki/The_Mythical_Man-
Month](https://en.wikipedia.org/wiki/The_Mythical_Man-Month)

It was written 40 years ago, but it is still relevant to today. Its so
important to think about how to build effective engineering teams.

~~~
amai
Another classic is
[https://en.wikipedia.org/wiki/Peopleware:_Productive_Project...](https://en.wikipedia.org/wiki/Peopleware:_Productive_Projects_and_Teams)

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

------
johnbender
Quantum Computing for Computer Scientists

Note, you have to be willing to put the time in, especially if your linear
algebra is rusty or (like me) you have only a passing familiarity with complex
numbers.

With that in mind, it's almost entirely self-contained and you can immediately
start to make connections with classical computing if you're familiar with
automata.

I've been interested in learning about quantum computing for a few years now
and this book finally got me going.

[https://www.amazon.com/Quantum-Computing-Computer-
Scientists...](https://www.amazon.com/Quantum-Computing-Computer-Scientists-
Yanofsky/dp/0521879965)

[update]

As an aside it's a really great excuse to try out one of the many computer
algebra systems out there. I gave Mathematica a trial for fun since I'd
already used SageMath in the past.

~~~
fvargas
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 :)

------
DearVolt
Engineering a Compiler 2nd Ed by Cooper & Torczon

I used it to supplement my prescribed compiler construction textbook and it's
incredibly useful! Also surprisingly easy to read compared to some texts with
a very math-heavy approach.

~~~
marai2
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!

~~~
DearVolt
Wow, that's awesome! I picked up mine second hand at a textbook distributor
for the equivalent of about $30.

For anyone interested in other books on compiler construction, I would
recommend these:

\- "The Basics of Compiler Design" by Torben Mogensen

\- "Modern Compiler Implementation in C" by Andrew Appel (ML and Java versions
available too)

\- "Modern Compiler Design" by Grune, Bal et al.

The Dragon Book is obviously infamous for this topic, but I would recommend
covering at least two slightly more basic texts before taking it on.

~~~
nextos
Try Principles of Program Analysis by Nielson & Nielson. Uber hardcore and
beautiful approaches to static analysis and optimization, on a very general
mathematical framework.

------
tpetricek
A Science of Operations by Mark Priestley
([http://www.springer.com/gb/book/9781848825543](http://www.springer.com/gb/book/9781848825543))

This is cheating a bit, because the book is history of computer science rather
than computer science, but I think anyone interested in programming should
read it. We often think about history of computing (and what it teaches us) in
a retrospective way (we see all the amazing totally revolutionary things that
happened), but it turns out that if you look deeper, there is often a lot more
continuity behind key ideas (and we just think it was a revolution, because we
only know a little about the actual history). This book goes into detail for a
number of major developments in (early) programming and it makes you think
about possible alternatives. It was one of the books that inspired me to write
this essay: [http://tomasp.net/blog/2016/thinking-
unthinkable/](http://tomasp.net/blog/2016/thinking-unthinkable/)

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

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

------
jrbedard
Deep Learning (Adaptive Computation and Machine Learning series) by Ian
Goodfellow, Yoshua Bengio, Aaron Courville

Came out in November 2016. Split in 3 parts:

Part I: Applied Math and Machine Learning Basics (Linear Algebra, Probability
and Information Theory, Numerical computation)

Part II: Deep Networks: Modern Practices (Deep Feedforward Networks,
Regularization, CNNs, RNNs, Practical Methodology & Applications)

Part III: Deep Learning Research (Linear Factor Models, Autoencoders,
Representation Learning, Structured Probabilistic Models, Monte Carlo Methods,
Inference, Partition Function, Deep Generative Models)

[https://www.amazon.com/Deep-Learning-Adaptive-Computation-
Ma...](https://www.amazon.com/Deep-Learning-Adaptive-Computation-
Machine/dp/0262035618)

~~~
m-i-l
Also available at
[http://www.deeplearningbook.org/](http://www.deeplearningbook.org/) .

------
cygned
"Structure and interpretation of computer programs"

Definitely recommended.

~~~
ZephyrP
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](https://github.com/zv/SICP-guile)

~~~
apenney
The one thing I really wish I had was a comprehensive test suite for all the
exercises. They are (obviously) hard to solve and there's no other way to see
if you were right but to check the solution. It's a huge flaw in most CS
books, feedback without hand feeding you the answers.

~~~
inimino
I disagree with this pretty strongly, actually. The best skill you can get
from SICP-level exercises is looking at the code and being completely
confident that you understand it and that it is correct. The best way to use
them is to write the code without running it, and once you are sure, review it
with someone else to find out if you were right.

This breaks down a bit around chapters four and five where you are plugging in
parts of a larger code base, and the accidental complexity starts to dominate.

~~~
DennisP
Reviewing with someone else can be a challenge for self-study; that's the step
a test suite would replace.

Of course someone could use the test suite to just make changes semi-randomly
until it works, but there's no reason it has to be used that way.

~~~
inimino
Self-study students can find someone online to study together.

I like the amount of projects SICP inspires. That's one of the best things
about it. I wouldn't want to discourage writing a test suite, but I wouldn't
suggest studying it by using one.

SICP questions are designed to have elegant solutions, which may be missed,
this is one reason why a study group is better than a test suite.

------
Eridrus
I tend to get most of my CS content from papers & web pages, but Sutton &
Barto's Reinforcement Learning book is pretty good:
[https://webdocs.cs.ualberta.ca/~sutton/book/the-
book-2nd.htm...](https://webdocs.cs.ualberta.ca/~sutton/book/the-
book-2nd.html)

------
kol
"The Annotated Turing" by Charles Petzold: [https://www.amazon.com/Annotated-
Turing-Through-Historic-Com...](https://www.amazon.com/Annotated-Turing-
Through-Historic-Computability/dp/0470229055)

~~~
henrik_w
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...](https://www.destroyallsoftware.com/screencasts/catalog/introduction-
to-computation)

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-...](http://sam-koblenski.blogspot.se/2016/01/tech-book-face-off-
godel-escher-bach-vs.html)

------
jagger27
Like others in this thread, this is more (only, in fact) about programming but
I found The Go Programming Language to be an absolutely perfect introduction
to Go with fantastic examples and succinct prose. It's beautifully typeset as
well, which doesn't hurt.

[http://www.gopl.io](http://www.gopl.io) ISBN: 978-0134190440

~~~
sherlockgopher
I found this to be helpful for learning basics of web development,
[https://github.com/thewhitetulip/web-dev-golang-anti-
textboo...](https://github.com/thewhitetulip/web-dev-golang-anti-textbook)

~~~
spraak
Thank you! I live the idea of an anti textbook :)

------
vram22
More about programming than computer science, but it does talk a lot about and
show some custom algorithms (it's more about programming-in-the-small, though
it does talk about some big picture too), also it is old and out of print
(last I checked), but I thought it was really good when I bought and read it,
so mentioning it:

Writing Efficient Programs

Also has a great bunch of "war stories" about performance tuning in real-life,
including one in which people, IIRC, improve the performance of quicksort on a
supercomputer by 1 million times or some such, by working on tuning as well as
architecture and algorithms at several levels of the stack, from the hardware
on upwards.

by:

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

Edited to change Wikipedia URL to more specific one.

~~~
dfan
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.

~~~
vram22
> (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.

Interesting to know, and agreed.

The book even has a list of thumb rules for the various kinds of optimizations
it describes, with guidelines on when each one is appropriate to use or not
(as you would know, having read it). Great writing throughout, too. Loop
unrolling (for both fixed- and variable-length loops) was one among the many
cool ones.

------
jsgoller1
I've been reading _The Practice of Programming_ (Pike, Kernighan) lately; it's
mainly geared towards Java and C/C++ programmers, but even as a DevOps
engineer I'm finding a lot of it useful.

[https://www.amazon.com/Practice-Programming-Addison-
Wesley-P...](https://www.amazon.com/Practice-Programming-Addison-Wesley-
Professional-Computing/dp/020161586X)

------
cottonseed
Lately I've been reading Network Algorithmics. Awesome book.

[https://www.amazon.com/Network-Algorithmics-
Interdisciplinar...](https://www.amazon.com/Network-Algorithmics-
Interdisciplinary-Designing-Networking/dp/0120884771)

~~~
sgrossman
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.

------
edko
Type-driven development with Idris ([https://www.manning.com/books/type-
driven-development-with-i...](https://www.manning.com/books/type-driven-
development-with-idris)).

It was a real eye-opener of what types can do.

~~~
nickpeterson
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.

~~~
edko
I don't know Haskell either, but the book starts from scratch. It can be
followed with no problem.

------
pbhowmic
The Art of Multiprocessor Programming by Shavit & Herlihy. Recommend topping
it off with the lecture delivered at Microsoft Research
([https://youtu.be/nrUszqrlvi8](https://youtu.be/nrUszqrlvi8))

~~~
DearVolt
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!

------
jonmb
Algorithms to Live By: The Computer Science of Human Decisions

An interesting mix of computer science and psychology. Just started on this
one recently. Highly recommended by a colleague. Seems great so far.

~~~
dvcc
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!

------
letientai299
Programming in Scala by Martin Odersky, Lex Spoon, and Bill Venners.

Beside a good introduction into Scala, that book also teach me the principles
in computer programing. It's worth read again several times.

------
ardivekar
I really like Introduction To Statistical Learning with Applications in R, by
Daniela Witten, Gareth James, Robert Tibshirani, and Trevor Hastie.

It's the easiest book I've found to get into machine learning without any
formal statistics training.

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

------
petithug
A List of Successes That Can Change the World: Essays Dedicated to Philip
Wadler on the Occasion of His 60th Birthday

[https://www.amazon.com/gp/product/3319309358](https://www.amazon.com/gp/product/3319309358)

------
deepnotderp
Does ai count as CS? If so, I'd like to nominate the Deep Learning Book

~~~
sitkack
I nominate it with a link
[http://www.deeplearningbook.org/](http://www.deeplearningbook.org/)

------
ktRolster
Zero Bugs and Program Faster, I'd say. Here's a brief reflection:
[https://www.opinionatedgeek.com/Blog/2016/11/23/zero-bugs-
an...](https://www.opinionatedgeek.com/Blog/2016/11/23/zero-bugs-and-program-
faster-by-kate-thompson)

------
medgetable
I'd highly recommend The Phoenix Project:

[https://www.amazon.com/dp/0988262509/ref=cm_sw_r_cp_awdb_pxm...](https://www.amazon.com/dp/0988262509/ref=cm_sw_r_cp_awdb_pxmFybEE46277)

The story they've wrapped around the shift to Agile for this company was
extremely entertaining and kept me coming back to read more! Plus it has some
very good thought exercises to take with you to your own job :)

~~~
krschultz
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.

------
kartD
Grokking algorithms. Great book, especially for someone like me who doesn't
deal too much with this stuff (as an embedded systems engineer).

Grokking functional programming and deep learning seem awesome as well, but I
haven't finished either so take my recommendation with a pinch of salt.

------
weavie
If you are into operating systems:

The Design and Implementation of the FreeBSD Operating System

[https://www.amazon.co.uk/Design-Implementation-FreeBSD-
Opera...](https://www.amazon.co.uk/Design-Implementation-FreeBSD-Operating-
System/dp/0321968972)

~~~
cperciva
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.

~~~
weavie
I would be very impressed if anyone (human) could keep that whole book in
their head!

------
rough
Has anyone read Probability and Computing: Randomized Algorithms and
Probabilistic Analysis by Michael Mitzenmacher, Eli Upfal[0]? If so, how
difficult are the exercises? Aside from doing problems I like to read
solutions and analyze them to learn better style, new techniques/ideas. Are
there any books like this one, but with solutions? Thanks.

[0]
[https://www.amazon.com/gp/product/0521835402/ref=s9_simh_gw_...](https://www.amazon.com/gp/product/0521835402/ref=s9_simh_gw_g14_i5_r?ie=UTF8&fpl=fresh&pf_rd_m=ATVPDKIKX0DER&pf_rd_s=&pf_rd_r=KTK543K9T7G6W2Q4YHA5&pf_rd_t=36701&pf_rd_p=a6aaf593-1ba4-4f4e-bdcc-0febe090b8ed&pf_rd_i=desktop)

------
jpfr
The source code and commentary of xv6, a simple Unix-like teaching operating
system. By far the best book on operating systems I have encountered so far.

[https://pdos.csail.mit.edu/6.828/2012/xv6.html](https://pdos.csail.mit.edu/6.828/2012/xv6.html)

(The alternative is learning PDP-11 assembler and reading the original Unix v6
sources with Lion's commentary.)

------
henrik_w
The Effective Engineer by Edmond Lau. Not CS, more SW dev, but it is fairly
new and I thought it was very good: [https://henrikwarne.com/2017/01/15/book-
review-the-effective...](https://henrikwarne.com/2017/01/15/book-review-the-
effective-engineer/)

~~~
TheCowboy
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.

------
lamchob
Structured Parallel Programming: Patterns for Efficient Computation by von
Michael McCool, James Reinders, Arch D. Robison

It introduces some important parallel patters, explains what makes them tick
and how to make them efficient. The book makes a strong case for using
parallel frameworks, namely TBB and Cilk+ to create general and portable
solutions.

There's also a set of slide available, \-
[http://ipcc.cs.uoregon.edu/curriculum.html](http://ipcc.cs.uoregon.edu/curriculum.html)

------
grillisalaatti
Not new, but "Hacking - The Art of Exploitation".

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

------
spraak
Has anyone read "The Impostor Handbook"[0]? What do you think of it?

[0] [https://bigmachine.io/products/the-imposters-
handbook/](https://bigmachine.io/products/the-imposters-handbook/)

Edit: I'm not connected to the book.

~~~
chrisseaton
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](https://github.com/imposters-
handbook/feedback/issues/50)

------
coverclock
It's very rare for me to read a technical book cover to cover. I recently read
IPv6 FUNDAMENTALS by Graziani (Cisco), but that was more an act of
desperation. The best CS-related book I've _ever_ read was probably MEASURING
AND MANAGING PERFORMANCE IN ORGANIZATIONS by Robert Austin. It completely
changed the way I see the world, both professional and personally. Austin uses
agency theory, an application of game theory, to show how incentives in an
information economy drive dysfunction into organizations because not all
metrics of behavior can be adequately or economically measured. This is
_extremely_ applicable to, for example, incentive programs in high tech
organizations. At the time he wrote it, Austin was working on his Ph.D. in (I
dimly recall) operations research at Carnegie Mellon while working as an
executive in IT for Ford Motor Company Europe. Now he's on the tenured faculty
at Harvard Business School.

------
elorant
C# in depth by John Skeet. This could easily be one of the best computer
related books i've ever read. The amazing thing is that is shows with code
examples how the language progressed from one version to the next. I've never
read anything similar in computer literature. It gave me a deep understanding
of the language and all its caveats.

------
housel
John Day's _Patterns in Network Architecture_ is a highly opinionated book (by
someone who was around for the development of the Internet and OSI standards),
and one that provided a radically new perspective on networking and network
protocols that I have found useful over the past year.

------
oever
"Semantic web for the working ontologist" by Dean Allemang and Jim Hendler.

A very clear book that learns you to think about integrating data
semantically. Make sure to by the second (or later) edition.

[http://workingontologist.org/](http://workingontologist.org/)

------
Dangeranger
Practical Object-Oriented Design in Ruby (POODR) by Sandi Metz
[http://www.poodr.com/](http://www.poodr.com/)

------
progrocks9
The Cathedral and the Bazaar by Eric S. Raymond. It's inspiring for embrace
Open Source collaboration and also very useful for manage projects. In Guy
Kawasaki's quote "The most important book about technology today, with
implications that go far beyond programming"

~~~
vram22
>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/](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...](http://www.oreilly.com/openbook/opensources/book/tiemans.html)

------
swalta
I recommend the MOOC and book for Nature in Code - evolutionary dynamics in
Javascript

[https://www.edx.org/course/nature-code-biology-javascript-
ep...](https://www.edx.org/course/nature-code-biology-javascript-epflx-
nic1-0x)

------
nextos
CTM. Could be labelled as SICP's sequel.

~~~
e12e
I'm assuming that's:?

[https://mitpress.mit.edu/books/concepts-techniques-and-
model...](https://mitpress.mit.edu/books/concepts-techniques-and-models-
computer-programming)

~~~
nextos
Yes, apologies for the acronym without definition.

------
henrythewasp
Understanding Computation: From Simple Machines to Impossible Programs by Tom
Stuart

[https://www.amazon.co.uk/Understanding-Computation-
Machines-...](https://www.amazon.co.uk/Understanding-Computation-Machines-
Impossible-Programs/dp/1449329276/)

Not finished it yet, but it's a joy to read and explains fundamental concepts
of things like parsers, interpreters and Lambda Calculus using minimal Ruby
syntax.

------
daw___
Internetworking with TCP/IP by Dr. Douglas Comer.

------
blain_the_train
> This book will help you navigate the diverse and fast-changing landscape of
> technologies for storing and processing data. We compare a broad variety of
> tools and approaches, so that you can see the strengths and weaknesses of
> each, and decide what’s best for your application.

[http://dataintensive.net/](http://dataintensive.net/)

------
amai
I'm not sure if that counts as computer science book, but this book was a
pleasant surprise:

Butcher: Seven Concurrency Models in Seven Weeks

------
nsm
Designing Data-Intensive Applications by Martin Kleppman. He does a great job
of distilling storage systems to concepts and discussing conceptual trade offs
instead of focusing on particular storage products. Plenty of footnotes to
relevant research papers too.

------
mindcrime
Recently? And actually finished as opposed to skimming or working through
parts of?

 _Code_ by Charles Petzold.

Of the ones that I haven't finished, but have at least looked at, I think I'd
say:

 _Machine Learning for Hackers_ by Drew Conway and John Myles White

and

 _The Master Algorithm_ by Pedro Domingos

------
adamnemecek
I'll give you a couple. Note that some of these are rehashes of my earlier
comments.

# Elements of Programming

[https://www.amazon.com/Elements-Programming-Alexander-
Stepan...](https://www.amazon.com/Elements-Programming-Alexander-
Stepanov/dp/032163537X/ref=as_li_ss_tl?ie=UTF8&linkCode=ll1&tag=akhn-20&linkId=c9a5aee4d1e5663b112138e6a6831e39)

This book proposes how to write C++-ish code in a mathematical way that makes
all your code terse. In this talk, Sean Parent, at that time working on Adobe
Photoshop, estimated that the PS codebase could be reduced from 3,000,000 LOC
to 30,000 LOC (=100x!!) if they followed ideas from the book
[https://www.youtube.com/watch?v=4moyKUHApq4&t=39m30s](https://www.youtube.com/watch?v=4moyKUHApq4&t=39m30s)

Another point of his is that the explosion of written code we are seeing isn't
sustainable and that so much of this code is algorithms or data structures
with overlapping functionalities. As the codebases grow, and these
functionalities diverge even further, pulling the reigns in on the chaos
becomes gradually impossible.

Bjarne Stroustrup (aka the C++ OG) gave this book five stars on Amazon (in
what is his one and only Amazon product review lol).

This style might become dominant because it's only really possible in modern
successors of C++ such as Swift or Rust, not so much in C++ itself.

[https://smile.amazon.com/review/R1MG7U1LR7FK6/](https://smile.amazon.com/review/R1MG7U1LR7FK6/)

# Grammar of graphics

[https://www.amazon.com/Grammar-Graphics-Statistics-
Computing...](https://www.amazon.com/Grammar-Graphics-Statistics-
Computing/dp/0387245448/ref=as_li_ss_tl?ie=UTF8&qid=1483833551&sr=8-1&keywords=grammar+of+graphics&sa-
no-
redirect=1&linkCode=ll1&tag=akhn-20&linkId=a24987cf311b4d463e558953a02aabeb)

This book changed my perception of creativity, aesthetics and mathematics and
their relationships. Fundamentally, the book provides all the diverse tools to
give you confidence that your graphics are mathematically sound and visually
pleasing. After reading this, Tufte just doesn't cut it anymore. It's such a
weird book because it talks about topics as disparate Bayesian rule, OOP,
color theory, SQL, chaotic models of time (lolwut), style-sheet language
design and a bjillion other topics but always somehow all of these are very
relevant. It's like if Bret Victor was a book, a tour de force of polymathical
insanity.

The book is in full color and it has some of the nicest looking and most
instructive graphics I've ever seen even for things that I understand, such as
Central Limit Theorem. It makes sense the the best graphics would be in the
book written by the guy who wrote a book on how to do visualizations
mathematically. The book is also interesting if you are doing any sort of UI
interfaces, because UI interfaces are definitely just a subset of graphical
visualizations.

# Scala for Machine Learning

[https://www.amazon.com/Scala-Machine-Learning-Patrick-
Nicola...](https://www.amazon.com/Scala-Machine-Learning-Patrick-
Nicolas/dp/1783558741/ref=as_li_ss_tl?sa-no-
redirect=1&linkCode=ll1&tag=akhn-20&linkId=f79b946c3b993086bf6e1c6d5baba530)

This book almost never gets mentioned but it's a superb intro to machine
learning if you dig types, scalable back-ends or JVM.

It’s the only ML book that I’ve seen that contains the word monad so if you
sometimes get a hankering for some monading (esp. in the context of ML
pipelines), look no further.

Discusses setup of actual large scale ML pipelines using modern concurrency
primitives such as actors using the Akka framework.

# Hands-On Machine Learning with Scikit-Learn and TensorFlow: Concepts, Tools,
and Techniques for Building Intelligent Systems

[https://www.amazon.com/Hands-Machine-Learning-Scikit-
Learn-T...](https://www.amazon.com/Hands-Machine-Learning-Scikit-Learn-
TensorFlow/dp/1491962291/ref=as_li_ss_tl?s=books&ie=UTF8&qid=1484524457&sr=1-4&keywords=tensorflow&linkCode=ll1&tag=akhn-20&linkId=3defd0415456891a643c1f469d3d25fc)

Not released yet but I've been reading the drafts and it's a nice intro to
machine learning using modern ML frameworks, TensorFlow and Scikit-Learn.

# Basic Category Theory for Computer Scientists

[https://www.amazon.com/gp/product/0262660717/ref=as_li_ss_tl...](https://www.amazon.com/gp/product/0262660717/ref=as_li_ss_tl?ie=UTF8&psc=1&linkCode=ll1&tag=akhn-20&linkId=8c3134b0b0f77535181ab284c307e862)

Not done with the book but despite it's age, hands down best intro to category
theory if you care about it only for CS purposes as it tries to show how to
apply the concepts. Very concise (~70 pages).

# Markov Logic: An Interface Layer for Artificial Intelligence

[https://www.amazon.com/Markov-Logic-Interface-Artificial-
Int...](https://www.amazon.com/Markov-Logic-Interface-Artificial-
Intelligence/dp/1598296922/ref=as_li_ss_tl?ie=UTF8&qid=1484525312&sr=8-1&keywords=markov+logic&linkCode=ll1&tag=akhn-20&linkId=fac3a76632e543c1fc43138177ca15b1)

Have you ever wondered what's the relationship between machine learning and
logic? If so look no further.

# Machine Learning: A Probabilistic Perspective (Adaptive Computation and
Machine Learning series)

[https://www.amazon.com/gp/product/0262018020/ref=as_li_ss_tl...](https://www.amazon.com/gp/product/0262018020/ref=as_li_ss_tl?ie=UTF8&psc=1&linkCode=ll1&tag=akhn-20&linkId=a4d27cbb764ec79ea34ddaf4e51dcf41)

Exhaustive overview of the entire field of machine learning. It's engaging and
full of graphics.

# Deep Learning

[https://www.amazon.com/gp/product/0262035618/ref=as_li_ss_tl...](https://www.amazon.com/gp/product/0262035618/ref=as_li_ss_tl?ie=UTF8&psc=1&linkCode=ll1&tag=akhn-20&linkId=0767299f472486a6688d7d5df831d691)

[http://www.deeplearningbook.org/](http://www.deeplearningbook.org/)

You probably have heard about this whole "deep learning" meme. This book is a
pretty self-contained intro into the state of the art of deep learning.

# Designing for Scalability with Erlang/OTP: Implement Robust, Fault-Tolerant
Systems

[https://www.amazon.com/Designing-Scalability-Erlang-OTP-
Faul...](https://www.amazon.com/Designing-Scalability-Erlang-OTP-Fault-
Tolerant/dp/1449320732/ref=as_li_ss_tl?_encoding=UTF8&psc=1&refRID=8KVM0G4T0EQR2C9XH2F9&sa-
no-
redirect=1&linkCode=ll1&tag=akhn-20&linkId=253570acccdf384b260c433265747d3e)

Even though this is an Erlang book (I don't really know Erlang), 1/3 of the
book is devoted to designing scalable and robust distributed systems in a
general setting which I found the book worth it on it's own.

# Practical Foundations for Programming Languages

[https://www.amazon.com/gp/product/1107150302/ref=as_li_ss_tl...](https://www.amazon.com/gp/product/1107150302/ref=as_li_ss_tl?ie=UTF8&psc=1&linkCode=ll1&tag=akhn-20&linkId=47e57e2ea9b3e926b5ffdc940c4f3ae7)

Not much to say, probably THE book on programming language theory.

# A First Course in Network Theory

[https://www.amazon.com/First-Course-Network-
Theory/dp/019872...](https://www.amazon.com/First-Course-Network-
Theory/dp/0198726465/ref=as_li_ss_tl?ie=UTF8&qid=1484523709&sr=8-1&keywords=network+theory&linkCode=ll1&tag=akhn-20&linkId=22c763111aba8c33d26e931eb49964c8)

Up until recently I didn't know the difference between graphs and networks.
But look at me now, I still don't but at least I have a book on it.

~~~
bad_user
Amazon links with your affiliate tag, seriously?

~~~
kranner
I see nothing wrong with GP providing their affiliate tag.

They are referring customers to Amazon, and customers don't pay extra.

~~~
bad_user
As an ex-Amazon Affiliate myself, I disagree because the incentive to post
those links is not aligned with the reader's expectations.

Do you enjoy viewing commercials and product placements without the proper
disclaimer? Because this is exactly what this is. I surely don't appreciate
hidden advertising, not because of the quality of the advertised products, but
because I cannot trust such recommendations, as a salesman can say anything in
order to sell his shit.

Notice how this is the biggest list of recommendations in this thread. Do you
think that's because the author is very knowledgeable or is it because he has
an incentive to post links?

~~~
adamnemecek
> As an ex-Amazon Affiliate myself, I disagree because the incentive to post
> those links is not aligned with the reader's expectations.

Please don't project your behavior onto others. I take book recommendations
seriously. I actually really enjoy it, people have told me IRL that my
recommendations helped them a lot.

> Notice how this is the biggest list of recommendations in this thread.

They are all books that I've read in the last ~4 monthish (not all in
entirety). Just FYI I'm not sure how much money you think I'm making off this
but for me it's mostly about the stats, I'm curious what people are interested
in.

> Do you think that's because the author is very knowledgeable

I'm more than willing to discuss my knowledgeability.

> or is it because he has an incentive to post links?

It's the biggest list because due to circumstances I have the luxury of being
able to read a ton. I own all the books on the list, I've read all of them and
I stand by all of them and some of these are really hidden gems that more
people need to know about. I've written some of the reviews before. Just FYI
I've posted extensive non-affiliate amazon links before and I started doing
affiliate only very recently.

Furthermore, HN repeatedly upvotes blog posts that contain affiliate links.
Why is that any different?

------
rodrigocoelho
I read Applied Microsoft .NET Framework Programming by Jeffrey Richter a few
years ago and felt that that's how technical books shold be written. I felt
happy every time I got to read it.

[https://www.amazon.com/Microsoft%C2%AE-Framework-
Programming...](https://www.amazon.com/Microsoft%C2%AE-Framework-Programming-
Developer-Reference/dp/0735614229)

------
nojvek
What if - by Randall Monroe. It's not a computer science book but has lots of
great questions and answers to what if questions. He answers with pretty
pictures and funny explanations.

I learnt a lot about what I don't know Being able to do rough math off the
head, thinking critically and out of the box.

Also the book smells good. Most of the time I read certain books because they
smell good.

------
awesp
Write You A Scheme, Version 2.
[https://www.wespiser.com/writings/wyas/home.html](https://www.wespiser.com/writings/wyas/home.html).
A tutorial on how to write a production ready implementation of scheme using
Haskell. Contributors welcome

------
tu7001
[http://interactivepython.org/runestone/static/pythonds/index...](http://interactivepython.org/runestone/static/pythonds/index.html),
truly great read, especially if one learning python.

------
jakub_g
High Performance Browser Networking by Ilya Grigorik

Available also online for free at [https://hpbn.co/](https://hpbn.co/)

Lots of great insights about how TCP/IP, 3G etc work and how it affects the
performance of websites

------
derstander
I haven't re-read it in its entirety, but I always enjoy picking up Sipser's
"Introduction to the Theory of Computation" and reading through one or another
of the chapters and playing with things in my head or on paper.

------
samirm
Network Security Through Data Analysis
[http://shop.oreilly.com/product/0636920028444.do](http://shop.oreilly.com/product/0636920028444.do)

------
JotForm
Artificial Intelligence: A Modern Approach is a great read!

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

------
evbacher
D is for Digital: What a well-informed person should know about computers and
communications, by Brian Kernighan.

------
jonbaer
The Master Algorithm by Pedro Domingos

------
pcvarmint
Not new, but _How To Solve It: Modern Heuristics_ by Michalewicz & Fogel, is a
classic.

------
nialv7
Introduction to the Theory of Computation by Michael Sipser.

Constructing Turing Machines is real fun.

------
chris_wot
I'm reading _Type Inheritance & Relational Theory_ by C.J. Date.

------
spdegabrielle
GEB

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

~~~
ardivekar
Reading GEB always makes me feel like such a philistine.

~~~
lllllll
haha, I'm reading it now - finally after many years - and I can absolutely
relate to the feeling you describe. I decided that I won't be hard on myself
for not understanding it all at the first read. Still quite enjoying it so far
(1/3rd read). Additionally I also decided that I don't _have_ to finish it
unless I feel like ( specially considering it's 800pages).

~~~
pouta
You just read and re-read it over and over and still find something
interesting

------
jackyinger
A New Science - Wolfram

Maybe stretching outside the typical, but I have a weakness for cellular
automata.

Also, I've vowed never to buy another Oriely book or similar book ever. Online
docs are free and stay up to date.

~~~
throwaway7645
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.

~~~
sitkack
On the plus side it is full of pretty pictures, has a massive number of pages
which can be used to press leaves or flowers, heat in the winter and a door
stop in the summer to encourage airflow. There really isn't a bad quality
about this book. Oh, and super cheap on the used market.

~~~
JoachimS
Got mine for about 10 USD. page/price ratio is quite impressive.

------
ripitrust
SICP

I read it twice and it is still a gem

------
abhinav7786
cpp by yashwant kanetkar

------
codesushi42
Good Math: A Geek's Guide to the Beauty of Numbers, Logic, and Computation

[https://www.amazon.com/Good-Math-Computation-Pragmatic-
Progr...](https://www.amazon.com/Good-Math-Computation-Pragmatic-
Programmers/dp/1937785335/ref=sr_1_1?ie=UTF8&qid=1484554405&sr=8-1&keywords=good+math)

A great review of college math and CS. The book goes over FOPL, Set theory,
Turing machines and lambda calculus among other things. A fun read!

------
SomeStupidPoint
Not a book, but it's a 70 page paper that changed (substantially) the way I
thought about computing systems: Non-Abelian Anyons and Topological Quantum
Computation.

The gist is a model of computation based on knotting the worldlines of a
certain kind of particle (well, particle/anti-parricle pairs) and measuring
properties of the knots/links. It's also the theory behind Microsoft's effort
to build a quantum computer.

 _Highly_ recommend at least reading the non-technical sections (ie,
everything but section 3 and appendix A).

Copy of paper:
[https://arxiv.org/abs/0707.1889](https://arxiv.org/abs/0707.1889)

------
amirbehzad
Book: Star Schema, The Complete Reference, by Christopher Adamson. One of the
best technical books ever written.

[https://www.amazon.com/Schema-Complete-Reference-
Christopher...](https://www.amazon.com/Schema-Complete-Reference-Christopher-
Adamson/dp/0071744320)

Article: Thinking Clearly about Performance, Cary Millsap (Method R
Corporation)

[http://method-r.com/papers?download=44:thinking-
clearly-(pap...](http://method-r.com/papers?download=44:thinking-
clearly-\(paper\))

------
elcct
Modern C++ Programming with Test-Driven Development

[https://pragprog.com/book/lotdd/modern-c-programming-with-
te...](https://pragprog.com/book/lotdd/modern-c-programming-with-test-driven-
development)

Awesome even if you don't want to do any C++

------
mmaunder
Best for what?

------
malios
Leaving this comment here so I can return later.

~~~
curiousgal
You can save the story either by upvoting it or by clicking on the _favorite_
button.

~~~
malios
Oh didn't know this. Thanks.

