
Technical Papers Every Programmer Should Read (At Least Twice) - llambda
http://blog.fogus.me/2011/09/08/10-technical-papers-every-programmer-should-read-at-least-twice
======
socratic
Is there a list anywhere of which Computer Science (and related) textbooks are
worth reading? (Perhaps based on which universities are actually using them?)

Personally, I find that the research literature is usually (intentionally or
unintentionally) opaque and that most ideas worth learning are at least 5
years old, so textbooks are the best place to actually learn things from a
source intended to teach you the material.

The list I could actually vouch for would be:

    
    
      CLRS
      Russell and Norvig
      Introduction to IR (Manning et al)
      Database Systems: The Complete Book
    

Others that I've heard good things about are:

    
    
      Dragon Book
      Convex Optimization (Boyd)
      Probabilistic Robotics
      Foundations of Statistical NLP
    

I'd really like a good distributed systems or distributed databases book
(rather than reading old Lamport papers or something), as well as a good
statistics/probability book, and I'm not particularly interested in books
about coding/engineering style any more (e.g., Code Complete, Pragmatic
Programmer, Matz's Ruby book, K&R).

~~~
gchpaco
Lamport's papers are exceptionally readable, I should note. His discussion of
e.g. Paxos is still current and interesting and still has implications for
distributed databases even though that algorithm is too expensive for
frequently (like, order of magnitude hundreds or thousands of changes a
second) changing data.

The Dragon is mostly old and hoary by today's standards; we frequently use GLR
instead of LALR(1), it has no discussion of interesting modern developments
like packrat parsers, there is next to no discussion of any part of the
compiler that isn't parsing, etc. A product of its time, but not an edifice
for the ages in the way that SICP is.

If you find a good stats/probability book, let me know; I've been looking for
one for years and come up short. Russell and Norvig is ironically superior to
most texts in the field.

~~~
beagle3
You're wrong about _any_ edition of the the Dragon.

The 0th edition (green dragon, Aho&Ullman) was mostly about parsing, but
talked about everything. The 1st edition (red dragon, Aho,Sethi&Ullman) was
about everything not including JITs, vectorization, GCs and parallelization.
The 2nd edition (purple dragon, Aho,Lam,Sethi&Ullman) is about everything, and
they even dropped operator precedence (Pratt) parsing to make room for more
non-parsing stuff.

------
nandemo
From McCarthy's paper:

> _When a free register is wanted, and there is none left on the free-storage
> list, a reclamation (7) cycle starts.

> (...)

> (7) We already called this process "garbage collection", but I guess I
> chickened out of using it in the paper -- or else the Research Laboratory of
> Electronics grammar ladies wouldn’t let me._

------
agumonkey
Seconding a comment on the linked url, but adding the url, for the lazy
amongst us :

lambda papers (steele, sussman) <http://library.readscheme.org/page1.html>

and btw, an interview of john backus :
[http://archive.computerhistory.org/resources/access/text/Ora...](http://archive.computerhistory.org/resources/access/text/Oral_History/102657970.05.01.acc.pdf)

discussing amongst other things, the pros/cons of fp, and his issues solving
how to fit IO; not mandatory but highly refreshing.

------
duck
This was on HN about 3 months ago:
<http://news.ycombinator.com/item?id=2979458>

~~~
llambda
Michael suggested it for over-break reading, so a retrospective seemed in
order. :)

------
twoodfin
I was going to just suggest adding "End to End Arguments in System Design"
(<http://mit.edu/6.033/www/papers/endtoend.pdf>) but then realized that the
entire MIT 6.033 reading list is exceptionally worthwhile.

<http://mit.edu/6.033/www/papers/>

------
buff-a
Twice? These days it takes reading them at least 5 times before I can claim to
comprehend them.

------
georgieporgie
Am I the only one who thinks it's really weird that we throw around these
lists of, "things programmers must read," but we don't ever throw around lists
of, "things programmers must program at least X times"?

~~~
omaranto
I guess for programmers believing in code reuse X is either 0 or 1...

~~~
mappu
I've written essentially the same application several times in different
languages, for different frameworks, or for substantially different platforms.

I'd also count a serious refactoring or structural improvement as having
programmed something again.

~~~
nandemo
I think this could be a really interesting discussion. My first reaction to
georgieporgie's comment was the same as omaranto's. But in practice, like you
say, we do end up doing a lot of code re-writing.

Suppose we are to explain omaranto's statement to someone who is not a
programmer. My try is: given that (i) programs, whether in source or binary
format, can be indefinitely replicated with virtually zero cost and (ii) we
know how to write modular programs and (iii) there are plenty of useful
modules available for re-use, we never have to substantially re-write anything
from scratch.

But (iii) is arguably false due to a variety of reasons: intellectual property
issues, incompatible platforms, "incompatible" programming languages, etc.

And (ii) is a big lie.

