This question is something that I really like to know... did any one have /can tell me about
Programming book related that he/she just couldn’t stop reading from start to end.
My self I was reading a lot of programming books but never as “book” from start to end
Always like reference always half of the book I never opened.
_The Little Schemer_, _The Seasoned Schemer_, _The Little MLer_. Those are made to be burned through, though. Probably not one sitting (many ideas need time to sink in), but only a couple sessions each.
More recently, _Land of Lisp_. I already knew much of the material, but a very fun read. (Nice stickers, too!) I'd suggest this as a starting point for people new to Lisp, maybe even before _The Little Schemer_ (!).
I read most of chapters 3, 4, and 5 of SICP in one night and the following morning. (I'm on the second pass, doing most of the exercises, and nearly done with chapter 2. I'm taking a break, though.)
_Thinking Forth_, by Leo Brodie et al.
_The Awk Programming Language_ by Aho, Weinberger, and Kernighan.
_Programming Pearls_ and _More Programming Pearls_ by Jon Bentley.
I couldn't put _CTM_ (http://www.info.ucl.ac.be/~pvr/book.html) down, either. It took a while to get through, though - It's quite large. I tend to read two or three books in tandem and switch between them, but I was on that sucker 100% cover to cover. What a wonderful book!
I'm currently reading _Erlang and OTP in Action_ by Logan, Merritt, and Carlsson. I just got it in the mail yesterday, but quite good so far.
Also: When you're reading hard programming books, do the exercises! You don't have to do them all, though at least half is a good idea. It reinforces what you've read, and shows you what you actually know vs. what you just think you do. I tend to read the book first, then do exercises on the second pass.
I definitely agree with the Schemer series. I wouldn't leave off the The Reasoned Schemer, I've been working on that book for over a month now. Better than coffee. Might actually finally understand monads.
SICP is astounding. Thoroughly worked through the first three chapters years ago. I'm constantly revisiting the later chapters.
I haven't worked through CTMCP, but that book is written in a lovely, compelling style with eye-opening statements on nearly every page. I'm also also finding that it's the ultimate Clojure book.
We've already talked about _The Reasoned Schemer_ in another thread. :) I may give it a try again eventually. Clocksin's _Clause and Effect_ is a similar book, in Prolog.
Monads aren't that hard, they're just one step too general - at first, it's not clear what their examples have in common. It helped when I realized I'd already written "monadic" code in OCaml and Scheme, and with pipelines in shell scripts. (Getting away from the avalanche of category theory terminology mixed with nonsense about burritos and space suits also helped. The epiphany itself matters, not the stepping stone!) Also, starting with a simpler monad (e.g. Maybe) makes the plumbing clearer.
For interpreters / compilers, I prefer the treatment in EoPL to SICP's. There's an awesome "converting an interpreter to a continuation-passing-style interpreter to a CPS-based compiler" section in (only) the first edition of EoPL.
What really impresses me about CTM is how much deep material it ties together, from all over the place, yet the book is still extremely easy to follow. Somebody just starting in CS could benefit tremendously from reading its take on concepts when their other textbooks stump them. It's one of the most readable textbooks I've seen. (PAIP is another.)
To understand monads in a context where they are both useful and necessary (Haskell) I highly recommend the later chapters of Learn You a Haskell for Great Good (http://learnyouahaskell.com/). I'd read through all the different analogies (burritos, space suits, etc) and it didn't click until LYAHFGG showed how they are a logical way of attaching some extra context to a bit of data (or more generally a computation).
The Little/Seasoned Schemer books where the first programming/technical books that when I finished them I had that same feeling you get when you finish a good novel. Land of Lisp is the first book I've picked up since then that's given me the same feeling so far.
Since the first 2 schemer books can each be read in about a week (they shouldn't be read faster) it's a shame for anyone not to read them.
Programming books are rarely page turners. I cannot think of one book to add to the (currently empty) list here. I find most programming books to be boring and discursive. Far too many fall into a pattern not too far removed from romance novels where, inevitably, the alpha male hero beds the heroine by chapter three. And if software engineering is considered programming, many of those books seem to be anchored in the occult where certain spells produce magical results for arcane reasons.
Personally I dislike tutorials and the pedagogy that comes along with that style. Even when well done they seem wordy presentation of the trivial and obvious.
Serious computer science books (e.g., Knuth's Art of Computer Programming, Hank Warren's Hackers Delight) take careful reading and study; I read them for pleasure, but it is a different pleasure that I get from, say, a Lee Child's Jack Reacher novel.
I think there are good reasons for this situation. The interesting aspects of programming are complex, involve a deep understanding of multiple levels of abstraction, and require considerable background knowledge. This is incompatible with a mindless read.
The average programming book is pretty awful - many seem to be sold by weight. If you skew towards those recently published, there's a very high concentration of instantly obsolete books that cover surface details of the current incarnation of rapidly changing technology. There are real incentives for the programming book publishing industry to churn out tedious garbage: People buy 'em, instant obsolescence means the same people replace 'em.
Older books aren't necessarily better, but those remaining have been through a generation or two of garbage collection already, making it easier to find the good ones. Excellent books have been published recently, of course (http://www1.idc.ac.il/tecs/, http://landoflisp.com/), it's just easier to find them in hindsight.
Books about parsing techniques* rather than ANTLR (or whatever) specifically, language semantics and implementation techniques rather than an awful 200 lb. Wrox book with a mug shot on the cover, etc. tend to stay relevant for much longer. Rather than reading yet another API guide, check out _The Art of the Interpreter_ (http://repository.readscheme.org/ftp/papers/ai-lab-pubs/AIM-...). Also, CiteSeer (http://citeseerx.ist.psu.edu/) is a gold mine.
I haven't gotten _Hackers Delight_ yet, but it's on my list.
* Recommended: Dick Grune's _Parsing Techniques, a Practical Guide_. Lots of deep content, but would still be worth it for the bibliography alone.
> I find most programming books to be boring and discursive.
I was of the same opinion until I read "Programming Pearls" by Jon bentley. The way it opens up a problem statement, thereby making you think is truly fascinating. If you haven't read it, please do.
Jon Bentley's books are outstanding but don't fall into the quick read category in my opinion. They are complex and need careful study (and working the exercises) to get all you can from them.
His 1982 book, Writing Efficient Programs, and the 1981 precursor, Writing Efficient Code, ought to be read by every C programmer. Sadly, they are now out of print and hard to find. Writing Efficient Programs is a breezy tour of the tricks of the trade, but it is a serious list of hints (some subtle, some not) for making efficient programs.
I left _WEP_ out of my list just because it lacks the requested I-want-to-read-it-osity -- it's a very fine book. (IWTRIosity is sort of orthogonal to whether a book rewards careful study. Knuth and SICP have both.)
The sequel (_More Programming Pearls_) is good, too. Judging by the discrepancy between the used prices of PP (~$20) and MPP (<$5), I'd guess most people don't even know it has a sequel.
The interviews are thought-provoking, particularly the ones with Peter Norvig and Joe Armstrong. Seibel expands on some recurring themes on his blog (http://gigamonkeys.wordpress.com/category/books/coders-at-wo...). My wife also liked _Coders at Work_, though she has a lot of experience doing interviews for documentaries, and there were a couple times she was frustrated about comments Seibel should have pursued further.
_Masterminds of Programming_ wasn't very good, though I enjoyed the Chuck Moore interview.
I wish Arthur Whitney had been in _Coders at Work_.
I wish Arthur Whitney had been in _Coders at Work_.
I nominated him but he fell through the cracks. I think the book is weaker for it.
There's a wonderful story (which you probably know but it's worth repeating) that Roger Hui, the J guy, was asked who the best programmer was. He responded by saying that Peggy Lee was once asked who the best jazz singer was and she responded, "You mean besides Ella?" (By analogy, Roger's answer was "You mean besides Arthur?")
I finished reading this today, really enjoyable book, very insightful and often thought provoking - it's nice to hear topics from people who have differing perspectives.
Not sure what you mean by hardcore hacker though, unless you mean....most of the programmers in the book come from an era where assembly code and primitive machines were the only tools they had?
As books about programming go, it's pretty accessible to non-programmers. There's plenty of content about motivation, rewards, the relation between technology and culture, etc. It isn't just an avalanche of technical minutiae.
I found the part about L. Peter Deutsch (mostly) giving up programming for music particularly interesting.
K&R's _C Programming Language_, because my father saw me start to write Schrodinger's equation in BASIC and said I should take a look.
Stroustrup's _The C++ Programming Language_, twice in a row, because I didn't want to be left out for not having taken Computer Science.
Butelhof's _Programming with Posix Threads_, because another book referenced its explanation of why Win32 threading had a bug because it could not, at the time, signal and wait on a mutex in an atomic way. There was something deep to find in those rowboats and bucket stories.
GoF's _Design Patterns: Elements of Reusable Object-Oriented Software_, because when I complained to a mentor that I was struggling to organize a dozen scientist programmers, he handed it to me, laughing.
John Robbins, _Debugging Applications_, first edition, because it was the first time for me that code didn't have the disclaimer, "of course you should insert error-handling code here." Basic x86 assembly in one chapter!
Earlier in my development as a programmer, skimming books and hacking was standard. But, as programming became ingrained, reading on the topic became more and more enjoyable. Appreciating the intellectual approach, holding the ideas in my brain without needing a computer to figure out the concepts upped my appreciation of good writing rather than tutorials.
I have never read a programming book from start to end, since most of them are either dry or not though-provoking. Three PL books that I liked very much are:
- Prolog and Natural-Language Analysis. An enjoyable introduction to Prolog and Natural Language analysis:
You may already have heard of it, as it's a classic in the Ruby community. It feels more like a work of art than a mere programming book, but you'll learn an awful lot while reading it. :)
As somebody who knows several other languages but not Ruby, I didn't learn that much about Ruby from that book. It's a fun read, but I felt like I mainly came away with in-jokes and minor details about syntax. I wonder if it has a bigger impact on people new to programming.
_Land of Lisp_, for example, teaches quite a bit about the language while still being fun.
It was entertaining and I found some of the clever ways he described syntax useful for remembering, i.e. the pipes form a chute which slides the variable into the block.
There was a time that I read every programming book front to cover (no Internet, few programming books in public libraries, not enough money to buy zillions of books, and loving reading all contributed to that) but some are more addicting than others. Looking at my bookshelves, I find many that stand out not only because I read them front to cover, but also because of their quality. Examples:
Inside Macintosh (especially the phonebook edition), (terse, but well-written, and describing a revolutionary system), but also some of the later books. For example,mtgs series on QuickDraw GX is tedious in it's repetition, but if you skip that, it nicely describes a very much complete 2D Graphics system.
How to solve it.
The art of computer programming (volumes 1, 2, and 3). What helped here is that my public library had them, but they are nice to read, if you have the mathematical background (it definitely helps to read this in parallel with a study in number theory, combinatorics, etc)
Anatomy of Lisp.
The art of the meta-object protocol.
Out of the inner circle.
The Soul of a new Machine.
Unix Internals, the new frontiers.
Effective C++.
SICP.
More recently, I found the C# specification a page turner. Easy to read, and almost every section made me think about why they chose to do things different from Java the way they did (examples: complicate the grammar by including structs, having signed and unsigned ints).
I second The Soul of A New Machine, what an incredible book.
It follows a team of engineers at Data General around 1980 as they race to build a new computer under incredible pressure.
It's an incredible story and anyone who has worked on a tightly knit team under high pressure will relate.
Effective C++ and More Effective C++ are both extremely well-written and technically informative. Importantly, they are also pretty approachable to non-whizes, but they teach important lessons (patterns and antipatterns, but very practical.)
Reposting a dead post which should not have been dead, from abecedarius:
These had high I-want-to-read-itosity, I thought:
Abelson and diSessa, Turtle Geometry
Abelson and Sussman, Structure and Interpretation of Computer Programs
Aho and Weinberger and Kernighan, The AWK Programming Language
Andrew Appel, Compiling With Continuations
Jon Bentley, More Programming Pearls
Jon Bentley, Programming Pearls
Leo Brodie, Thinking FORTH
W. H. Burge, Recursive Programming Techniques
Carriero and Gelernter, How to Write Parallel Programs
A. K. Dewdney, The New Turing Omnibus
Edsger Dijkstra, A Discipline of Programming
Richard Feynman, The Feynman Lectures on Computation
Friedman and Felleisen, The Little Schemer
Friedman and Wand and Haynes, Essentials of Programming Languages [1st edition]
James F. Gimpel, Algorithms in Snobol4
Paul Graham, On Lisp
Philip Greenspun, Philip and Alex's Guide to Web Publishing
Grune and Jacobs, Parsing Techniques: A Practical Guide
Daniel Hillis, The Connection Machine
Kernighan and Pike, The Practice of Programming
Kernighan and Pike, The Unix Programming Environment
Kernighan and Plauger, Software Tools in Pascal
Donald Knuth, Literate Programming
Glenn Krasner (editor), Smalltalk-80: Bits of History, Words of Advice
Susan Lammers, Programmers at Work
Wm Leler, Constraint Programming Languages
Liskov and Guttag, Abstraction and Specification in Program Development
Peter Norvig, Paradigms of Artificial Intelligence Programming
Chris Okasaki, Purely Functional Data Structures
Richard O'Keefe, The Craft of Prolog
P. J. Plauger, Programming on Purpose I. (and II and III)
P. J. Plauger, The Standard C Library
Jef Raskin, The Humane Interface
Stuart Russell and Peter Norvig, Artificial Intelligence: A Modern Approach
Toby Segaran, Programming Collective Intelligence
Toffoli and Margolus, Cellular Automata Machines
Niklaus Wirth, Project Oberon: The Design of an Operating System and Compiler
Witten, Moffat, & Bell, Managing Gigabytes
(mostly from my old list at http://wry.me/~darius/personal/books.html)
Why is Darius Bacon's account dead? I just flipped showdead back on to check, and it's his first dead comment. Seriously, WTF?
Skipping stuff commented on elsewhere:
While _The New Turing Omnibus_ is probably nothing too surprising to people here (at least not the subset that also hangs out on LtU, etc.), it's got a lot of approachable 2-5 page summaries of many major topics in CS.
_The Craft of Prolog_ is quite good, though perhaps of less interest to non-Prologers. _The Art of Prolog_ is essential, however. It's an SICP-caliber book, focused entirely on declarative programming, constraint programming, DSLs, etc.
_Compiling with Continuations_ rocks. It's an ML treatment of CPS-as-an-IR, like Steele's _RABBIT_ and Krantz et al.'s _Orbit_.
I know it's not a programming book but I do feel that it is a definitive, landmark computer science book:
Godel, Escher, Bach by Douglas R. Hofstadter
Just a wonderful narrative of so many related topics across computer science, mathematics, cognitive science, biology, physics, etc. etc. And the author does get into some programming techniques and data structures (recursion, stacks, functional programming).
qualify as a programming book for this thread (maybe not)? It has no information on how to write "Hello, World" in any language, and little how-to information about coding, but a lot of information about effective programming, and it is a very interesting, readable book.
At first I didn't think I had any, so I did a quick scan of my bookshelves:
_Anatomy of LISP_.
I also did SiCP cover to cover in a few months when it first came out.
_SmallTalk 80: Bits of History, Words of Advice_. Fantastic stuff; reading about making those early 80s processors run ST efficiently is like watching early rocketry.
_The Unix Programming Environment_. This should date me.
_Threaded Interpretive Languages_ (during the FORTH craze of the early 80s). Cured me of FORTH.
Tannenbaum's book on MINIX (bought it the day it came out, had it signed by Tannenbaum at Computer Literacy in San Jose. What a crowd. I miss that store).
That's about it. Of course there are many other computer-related books that I couldn't put down, such as _A Few Good Men from Univac_ and _The Soul of a New Machine_. But these are not about programming.
AoL is better written -- I found both his prose and his code style more inviting -- but much more dated than LiSP. That I liked it better has more to do with not already knowing most of it, the way I did with LiSP. If you can pick it up cheaply, do, at least for history and entertainment.
A (possibly mutual) acquaintance just sent a copy my way. :D I'm off to bed, but will dig into it tomorrow. I really enjoyed LiSP, and really look forward to it!
When I first decided to learn my first programming language, I bought a Wrox PHP for Beginners books and literally read every word (and practiced every example) over a weekend.
I learned two things from doing this: 1) PHP is a great language for beginners and 2) The details you read in a book like that won't stick with you forever, and you'll have to use the book as a reference anyways...
We must be REALLY different. AIMA is just one of those books that put me to sleep. Maybe I find vintage AI boring, or the book is just too fat, but I really hated it.
From the preface:
"This book presents the results of Project Oberon, namely an entire software environment for a modern workstation. The project was undertaken by the authors in the years 1986-89, and its primary goal was to design and implement an entire system from scratch, and to structure it in such a way that it can be described, explained, and understood as a whole. In order to become confronted with all aspects, problems, design decisions and details, the authors not only conceived but also programmed the entire system described in this book, and more."
Early in college I read the first edition of Jeffrey Friedl's "Mastering Regular Expressions" over the course of a long car trip. Still one of the most literate, humane tech books I've ever come across. Pity that the world hasn't yet heeded his call to bury the word "regexp".
Effective Java was, for me, one of the programming books that was simply unputdownable! I've always been a fan of Joshua Bloch's work and this book is a real gem for any practicing Java pro!
I think a lot of this depends on context. Programming books tend to require a certain amount of concentration, especially if covering topics novel to the reader, and if they have a decent information density. That's ok, I'd rather read something that takes some thought over a few days, than wade through a pile of verbose crap with little true information but finish it in an evening.
However, looking back over some books I've read for ones that I read cover to cover without much of a break, one was programming in scala - I thought it was well written, but it was also an easy read as I was familiar with much of the material, and it was very relevant to what I was doing at the time. There are books that I've really enjoyed where at least some of the content was truly new to me, like "essentials of programming languages", and "concepts, techniques and models of computer programming" - I can't honestly say I read the latter without taking a break every now and again though. But both of these books are very enjoyable and present the material in really nice ways. I wish I'd had these as an undergraduate.
I did read the pragmatic programmer a long time ago, pretty much cover to cover. Trying to reread it now, it (and the other books I've attempted to read of theirs) seem like the pop psychology of programming books. I enjoyed it at the time, and felt it was worthwhile. Probably a better book for programmers starting out. When I attempted to read it again I found it patronising and self indulgent.
I agree with many of the mentions (Little Schemer is almost omnipresent), but would like to add a newer book: Growing Object Oriented Software Guided by Tests. The title may mislead one to think the book is a dry repetition of the same-old "OO principles", but it isn' so. The meat of the book is a step-by-step description of the development (through TDD) of a largish application; and somehow they managed to make the whole thing interesting. I wish more books would take on a large development endeavor in a narrative way.
The best books I have read are ones that walk through a project from start to finish. I usually read through the entire book first without any programming. I take notes on the side and highlight key concepts. Then I walk through again and program the entire project. I haven't needed to learn a new programming language or framework in a while, but this method has proved to be fairly effective.
Simply Rails 2 was the last book I read like this 2 years ago. We are now one of Engine Yard's case studies.
> The best books I have read are ones that walk through a project from start to finish.
When I want to learn a new programming language or a new framwork, I always look for that kind of books. The last one I did was "Agile Web Development with Rails" a few years ago.
I have seen a couple "cookbooks" that pulled me through pretty quickly. I like to see things that are neat, or tough to do layed out and in the process, find new toys to play with. It feels like reading a good magazine.
This was the first programming book that actually made me laugh at times. The writer's style is wry and very accessible. His strong opinions and commentary kept me glued. Admittedly I didn't read every word but IMHO this is one of the classics.
I have chill running down my spine from thinking that someone read Numerical Recipes from cover to cover without putting it down. No offense - but it's an incredibly dense book. In particular the code samples take a lot of effort to really chew through, at least for me.
I'm really enjoying O'Reilly's Beautiful * series. Instead being one of of your run of the mill how-to books they contain stories about some really cool projects.
One of my favorites in Beautiful Data was about the architecture of the Mars lander. Enthralling stuff.
Two programming books that I actually did read cover to cover was:
- Skiena's Algorithm Design Manual. Lively presentation of standard algorithms, with some very fun war stories thrown in. I found it a lighter read than CLRS and TAOCP (those are books you study).
- Segaran's Programming collective intelligence. Quick paced introduction to data mining in Python. The code in the book is very informal but easy to understand.
I read The Little Schemer in three or four sit-downs. (I think the author advises not to read it in one sitting.)
I tend to get too distracted to give many books the cover-to-cover treatment. Some great ones that made the cut were:
1) Metaprogramming Ruby.
2) The Art of Rails.
3) Ruby Design Patterns
4) Services-Oriented Architecture in Ruby
These stick out for me. Even if the last one in the list felt a little "rushed to production", it still covered important topics you won't find anywhere else. Plus I find when a book has typos (either in the text or in the code), that just makes me engage with it a little bit more.
> Plus I find when a book has typos (either in the text or in the code), that just makes me engage with it a little bit more.
Really? I wasted almost an hour double-checking my code due to a typo in an algorithm in _Programming Collective Intelligence_ (pg. 35, should end in "return num/den", not "return 1.0-num/den".) That's just sloppy. I added it to the errata page (http://oreilly.com/catalog/errataunconfirmed.csp?isbn=978059...).
It makes me feel that while the author's explanations are pretty good, the code samples are rather dodgy. I've switched to looking up the relevant mathematical formulas and converting them to code myself.
that book is full of errors =/ I'm not a regular python user, but I've also heard that the code contained within the book is not very "pythonic" and is really meant as a pseudocode. still no excuse for it to be incorrect.
when a book has typos, it makes me want to throw it in the fire.
I'm a bit rusty on subtleties of standard Python style these days (I mostly switched to Lua around Python 2.5 or so), but I got the same impression. Still, the conceptual explanations in the book are pretty good.
While mistaking e.g. "there" / "their" / "they're" annoys me, I acknowledge that I'm stubborn about that stuff. Messing up details in a big formula or algorithm that people are going to use as a reference is just sloppy, though. I really appreciate authors who write in a (possibly personal and ad hoc) literate programming system that automatically extracts and tests all code samples.
I don't understand your "makes me engage with it a little bit more" reaction, though. I really don't. Could you explain?
The best page-turner C# book I have ever read is "C# 4.0 in a Nutshell." This book comes from the guys who developed the awesome LINQPad. The book is filled with awesome nuggets and examples that were totally new to me. A lot of .NET books just read like msdn documentation. This is not one of them.
Not exactly.a programming book, but I just read "Design with the mind in mind" and could not put it down. More about usability, but it has contributed to my programmimg in that it helps me think more about the overall feel and flow of a process, and how the brain comprehends things such as large dara sets and procedures.
Why's guide has enough non-text/geeky humor to keep me reading. And, it's mostly pictures! You're learning, but it doesn't 'feel' like you're learning.
The Tao of Programming flows differently than other books, which blast you with information. Instead of telling you stuff directly, it is anecdotal. Rather than didactic, it's like a parable.
Not necessarily a programming book but Code: The Hidden Language of Computers Hardware and Software. It's really easy to digest and moves at a good pace. It may not change your world but it will make thinking about computer internals feel less mysterious and more fun.
Sigh ... these kind of threads are expanding my TBR-list into financial oblivion.
On topic: Paradigms of Artificial Intelligence Programming by Norvig was a cover-to-cover session for me. It does not try to teach programming but to think about the structure of a solution.
"Understanding Unix/Linux Programming: A Guide to Theory and Practice" by Bruce Molay does a wonderful job of diving into the workings of the Linux kernel without any prerequisite knowledge beyond an understanding of C. This book focuses on deconstructing common commands such as "tail" and "who" and explaining almost line-by-line how they work and interact with the rest of the system.
It appears to be a bit expensive at the moment, but it's commonly used as a textbook, so there's a plentiful used market for it.
Microprocessors: A Programmers View (Computing That Works) : This is an older book and had fascinating explanations about how CISC (i386) processors worked and a comparison against RISC type processors and the implications for programmers. This book has fascinating historical info and if I recall correctly had a great amount of humor regarding the development of the various types of processors. Out of date now though and hard to get I think. An Amazon link if someone's interested: http://www.amazon.com/Microprocessors-Programmers-View-Compu...
This had more to do with me just having gotten hooked to programming than the book. Still, the book VB 6 Step by Step totally rocked and contributed to me pulling all nighters programming random stuff in middle school.
I have yet to see any author of a programming book that possesses a writing style that will keep me reading. However, often it's not important, as there are other reasons to keep turning the page. ;-)
Code Complete by Steve McConnell, and VBA Excel for Dummies. I think the latter was a very well written book, and VBA programming is underrated because for many people it's a good place to start in terms of practical application and it also has the benefit of being an interpreted/scripting language, so you can get instant feedback like in Python. Beats typing main string(args[]) or whatever the hell it is before you even know anything
Restful Web Services - great book and really opened up my thinking about how things behind web services can "resources" with different representations - rather than remote function calls.
The original "Java In a Nutshell" - it was dry reading, but at the time is was sooo useful.
C++ Primer Plus by Stephen Prata - this was the book that got me into programing "as a career" so to speak. I picked it randomly off the shelf and it turned out to be foundational :)
One of my favorites, a long time ago, were the "Bible" series, like the Quick C Bible. They were the perfect balance between reference/encyclopedia of methods and a straight read-through for how I/O works, etc. I wish more programming books were written this way.
_The Guru's Guide to Transact-SQL_ by Ken Henderson is unusually readable for a programming book. Perhaps it's a bit dated now, but still a good source of information.
in addition to others already reported: Object Oriented Software Construction by Meyer.Mostly because, like other great books, it proposes a problem and then presents a solution which exposes another issue and so on and so forth. Even if in the end one disagrees with all the proposed choices, the reading is great and the reasoning sensible.
This may not be a programming book but I could not put "The Elements of Computing Systems" down for the first 5 chapters. They are just brilliant, it wasn't a tutorial type of book. The authors don't give you anything actually. Just a bunch of specs and some background knowledge. But when I got down to it, that was all that mattered when presented in a structured way (and of course some reading and questions on the forum).
More recently, _Land of Lisp_. I already knew much of the material, but a very fun read. (Nice stickers, too!) I'd suggest this as a starting point for people new to Lisp, maybe even before _The Little Schemer_ (!).
I read most of chapters 3, 4, and 5 of SICP in one night and the following morning. (I'm on the second pass, doing most of the exercises, and nearly done with chapter 2. I'm taking a break, though.)
_Thinking Forth_, by Leo Brodie et al.
_The Awk Programming Language_ by Aho, Weinberger, and Kernighan.
_Programming Pearls_ and _More Programming Pearls_ by Jon Bentley.
I couldn't put _CTM_ (http://www.info.ucl.ac.be/~pvr/book.html) down, either. It took a while to get through, though - It's quite large. I tend to read two or three books in tandem and switch between them, but I was on that sucker 100% cover to cover. What a wonderful book!
I'm currently reading _Erlang and OTP in Action_ by Logan, Merritt, and Carlsson. I just got it in the mail yesterday, but quite good so far.
Also: When you're reading hard programming books, do the exercises! You don't have to do them all, though at least half is a good idea. It reinforces what you've read, and shows you what you actually know vs. what you just think you do. I tend to read the book first, then do exercises on the second pass.