Don Hosek - Past reading - Computers

My computer reading tends to be somewhat random and mostly work-driven. Occasionally, I read computer books for my own edification, but now that I'm no longer a professional computer guy, I tend to not read computer books at all.

What I've been read in the past - Computers
The Go Programming Language by Alan A. A. Donovan and Brian W. Kernighan
[Finished 24 November 2022] A decent overview of the language, although while I learned C from Kernighan and Ritchie, I don’t know that I’m up for the same approach for language learning now.

Creating and Consuming Rich PDFs by Leonard Rosenthol
[Finished 22 May 2022] A more detailed look at PDFs than Whitington’s book, but still fairly high level. That said, a good prolegomenon to reading the full spec.

PDF Explained by John Whitington
[Finished 19 May 2022] A decent high-level tour of the capabilities of PDF.

LaTeX in 24 Hours: A Practical Guide for Scientific Writing by Dilip Datta
[Finished 7 March 2022] It might be ungenerous to say this, given that I’m writing my own book on LaTeX, but this is not a good book. I picked it up when Springer was giving away eBooks of their catalog and I figured I should see what a recent LaTeX book looked like. On the positive side, it goes beyond core LaTeX, but it seems to miss the fundamental concept of LaTeX—separating content and form as much as possible—and has a number of incorrect recommendations.

The Rust Programming Language by Steve Klabnik and Carol Nichols
[Finished 14 July 2021] The “official” Rust book (and available for free and included with a normal Rust installation), I got the paper copy from the library because I still prefer paper books as much as possible. It provides a good overview of most of the language. My biggest complaint would be that it ignores the wealth of third-party crates that are available for simplifying many common tasks (like error handling or command-line parsing), but other than that, I can strongly recommend this as a good first Rust book, to be supplemented with the O’Reilly book.

Beginning Rust: From Novice to Professional by Carlo Milanesi
[Finished 11 July 2021] An actively bad book. I shouldn’t be surprised. I have never seen a good book from APress. The material is badly organized and often spends inordinate amounts of time on esoteric information that would only serve to baffle the “Novice” reader that this book purports to be aimed towards. It’s not even that good for propping up a monitor because it’s kind of thin.

Programming Rust: Fast, Safe Systems Development by Jim Blandy and Jason Orendorff
[Finished 6 July 2021] Despite being a bit old and in places outdated, this is an excellent comprehensive coverage of Rust development. I found the emphasis on systems development early in the book a bit offputting, perhaps because what Blandy and Orendorff call systems programming I’ve always just thought of as programming (I cut my teeth in the era when “real” programs were written in a compiled language—most often C/C++ or Pascal, occasionally more exotic choices like PL/I, Ada or Modula-2—while interpreted languages were reserved for more mundane tasks like scripting), but the level of detail is fantastic. I’ve since learned that a new edition of the book has been published and it should definitely be on any Rust developer’s bookshelf.

A Tour of C++ by Bjarne Stroustrup
[Finished 15 February 2021] In a lot of ways, this is what I wanted from Effective Modern C++, a look at the language and the best practices therein. There are a few peeks at the upcoming C++20 standard along the way. I got this from the library, but I feel like I really want to own a copy. Perhaps I may wait for a third edition, assuming it comes out in a timely fashion.

Effective Modern C++: 42 Specific Ways to Improve Your Use of C++11 and C++14 by Scott Myers
[Finished 21 November 2020] I was looking for something akin to Joshua Bloch’s Effective Java but for C++. This is kind of it, but C++ being C++, a lot of the material was pretty low-level. Things that I never think about in Java, like returning an object turn out to be really big deals and fairly complicated in C++ although the standard template library allows some of this, at least, to be abstracted away.

The Good Neighbor: The Life and Work of Fred Rogers by Maxwell King
[Finished 31 December 2019] Declaring a behind on my book log amnesty on writing reviews.

The Difference Engine: Charles Babbage And The Quest To Build The First Computer by Doron Swade
[Finished 24 October 2019] See my review at

The Road to learn React by Robin Wieruch
[Finished 3 October 2019] Declaring an “I’m way behind” amnesty.

Scala Cookbook by Alvin Alexander
[Finished 16 March 2019] Not really what it claims to be: this is not, in fact, a collection of recipes in the traditional sense of other O’Reilly “Cookbooks.” Instead it’s more of a Scala by example book. It does that reasonably well, but it’s not quite what I expected to see.

Becoming Functional: Steps for Transforming Into a Functional Programmer by Joshua F. Backfield
[Finished 23 October 2018] A step-by-step guide, using an example project, to how one can make an object-oriented code base into something more functional in its structure. Not too bad.

Testing in Scala by Daniel Hinojosa
[Finished 27 August 2018] A decent enough book, I think, paradoxically, it would have benefitted from less complete examples of the tests.

Living Clojure by Carin Meier
[Finished 10 June 2018] The first roughly two-thirds of this book provides a gentle introduction to Clojure, providing more hand-holding than does Clojure Programming but sacrificing little depth (mostly in the realm of more esoteric features of the language). Again, advancements in the Clojure community make the contents in many ways different, with newer, often simpler solutions available courtesy of newer libraries.

I did find Meier’s decision to clump all the exercises together as a timed learning plan to be a bit odd—I would rather have had there be exercises interspersed with the primary text, but that could just be me and certainly it wouldn’t fit with her modeling the text on the Couch to 5K model.

Clojure Cookbook: Recipes for Functional Programming by Luke VanderHart and Ryan Neufeld
[Finished 31 May 2018] A bizarre mix of ridiculously basic with complex recipes, it’s hard to see who the authors saw as their target audience. It’s interesting to see how the Clojure community had advanced from the time of the publication of Chas Emerick’s Clojure Programming. At this point, Leiningen has become the de facto standard build tool for Clojure projects to the point where it would be difficult to employ many of the recipes in this book without also using Leiningen.

Clojure Programming by Chas Emerick, Brian Carper and Christophe Grand
[Finished 9 May 2018] Perhaps a bit out of date now (unless O’Reilly has put out a newer edition), but an overall good introduction to this particular dialect of Lisp. I’ve been intrigued by lisps since I first encountered them in high school, but have never written any significant lisp or done much more than try to decipher emacs-lisp code to little success. Emerick et al do a good job of introducing the reader to the principles of Lisp and manage to be insistent on FP principles without seeming as doctrinaire as some other FP programming book authors I’ve encountered have. I feel secure enough from having read this book that I feel like I could tackle my next new project in Clojure should I feel that it would benefit from being written in that language.

Scaling Data Services with Pivotal Gemfire by Mike Stolz
[Finished 25 April 2018] This read more like a bit of technical marketing than a genuine book on the topic, but at 62 pages, it would be difficult to expect more. There’s some valuable information here, but overall it was less than I desired.

Scala by Example by Martin Odersky
[Finished 4 February 2018] It starts out pretty good, but some of the later chapters end up falling into the weeds of computer scientific jargon that ended up feeling like it’s more abstract than practical.

Reactive Web Applications: Covers Play, Akka, and Reactive Streams by Manuel Bernhardt
[Finished 12 January 2018] A decent enough book, although it could have done with being less broad and getting into greater depth in its topics

Applied Akka Patterns: A Hands-on Guide to Designing Distributed Applications by Michael Nash
[Finished 29 December 2017] I’m left not sure who this book is for. There’s a mix of basic information about the actor pattern and some more advanced material that assumes a great deal of familiarity with the Akka framework.

Functional Programming in Java: How to Improve Your Java Programs Using Functional Techniques by Pierre-Yves Saumont
[Finished 6 December 2017] Saumont comes at things with a very opinionated perspective, to the detriment of the book. Like the Scala book in this series, the text is geared largely to (re)implementing a functional library, which makes it feel in many ways like a mathematics textbook which focuses on presenting proofs of the theorems in the text while generally ignoring the question of how those theorems are applied. Overall, I was hoping for something that was more geared towards developing a functional idiom within the framework of the Java standard library rather than trying to turn Java into something it’s not.

Functional Programming in JavaScript by Luis Atencio
[Finished 26 May 2017] Employing functional idioms in JavaScript has been a growing trend and here Atencio does a good job of showing how best to exploit the benefits of FP in JS while also providing a good introduction to the benefits of FP in general.

Functional Programming in Scala by Paul Chiusano and Rúnar Bjarnason
[Finished 26 May 2017] Another good introduction to FP, here Chiusano and Bjarnason dedicate most of the book to re-implementing basic library functionality as a means of explaining the benefits of functional programming and showing how these things can be implemented in Scala. There’s an assumption of some familiarity with Scala programming in the book which makes some of the examples a bit inscrutable at times, but this is otherwise an excellent book.

Geek Sublime: The Beauty of Code, the Code of Beauty by Vikram Chandra
[Finished 27 July 2016] I heard about Chandra on his birthday from The Writer’s Almanac and as a writer and programmer, I thought I’d take a look at this book. There was a great deal of potential here, but it felt, in the end, like Chandra fell short of his goals and ultimately wrote a failed book.

The Swift Programming Language
[Finished 18 June 2016] A sufficiently comprehensive and clear introduction to the language. It appears to be a viable successor to Objective C for Apple programming.

Appeal Of One Half Of The Human Race, Women, Against The Pretensions Of The Other Half, Men, To Retain Them In Political by William Thompson
[Finished 11 December 2014] A landmark text, but alas, it’s written in a rather archaic and poorly-aged prose style.

What's Wrong with You? by Omar Yamini
[Finished 21 November 2014] If this were a work of fiction, I think every reader would immediately leap to point at the narrator as being unreliable. That’s not to say that Yamini is a bad person or that he outright lies, but there does seem to be a vein of self-justification running through the work that makes it unintentionally interesting from the reader’s perspective. Useful for getting a sense of the quotidian details of prison life, I don’t think it works in the “scared straight” manner that Yamini apparently intended given the book’s subtitle.

Literary Hoaxes by Melissa Katsoulis
[Finished 20 November 2014] See my review at

On Immunity: An Innoculation by Eula Bliss
[Finished 17 November 2014] This was an odd book. At one point Bliss really nails the oddity of the book when she talks about how she was surprised to consider herself “press” when denied an interview with a doctor. The subject matter is the sort of thing that might call for a journalistic investigation but instead we get something that lives firmly in creative non-fiction land. There’s a wonderful examination of the cultural and scientific aura that surrounds vaccination (Bliss, thankfully, is not an anti-vaxer or I would never have made it to the end of the book) showing how the two have been intertwined for as long as the subject of immunity has been understood (or just half-understood). Plus, I learned that etymologically, vaccine comes from the Latin vaca, cow.

Requiem for a Paper Bag edited by Davy Rothbart
[Finished 12 November 2014] See my review at

The Secret Museum by Molly Oldfield
[Finished 5 November 2014] See my review at

French Kids Eat Everything by Karen Le Billon
[Finished 2 November 2014] Part memoir, part manifesto for feeding kids. As a memoir, it was often frustrating (as in “woman, how could you possibly not get it already?”), but as a manifesto it’s both encouraging and depressing (the latter when we discover the challenges that Le Billon faced upon returning to Canada, which apparently has acquired the bad eating habits of its fat neighbor to the south). Some of her challenges in Canada are resolved when she realizes that she should serve food that’s more indigenous to Canada, shopping at the local farmer’s market rather than trying to replicate the foods she made in France, but it still represents a challenge when the peer pressure her kids face moves from eat this fish to eat this McFish.

The Concise Guide to Sounding Smart at Parties by David Matalon and Chris Woolsey
[Finished 8 October 2014] See review at

Friday was the Bomb by Nathan Deuel
[Finished 25 September 2014] Disclaimer: I’m friends with Nathan from our MFA program. Having said that, I can still recommend this collection. It’s a bit uneven at times reflecting its origins as a collection of shorter personal essays. The chronological arrangement means that some of the strongest essays (the title essay and “Flood-tide Below Me”) end up near the end of the book. Still, Deuel manages to convey the anxieties of being the stay-at-home dad in a marriage where his wife’s job represents a continual threat to their life while they live in a city where the violence of the region grows ever closer until finally they decide to leave the Middle East for the Midwest (they’ve since settled in Los Angeles, ruining the delightful symmetry of that move).

Wrong: Why Experts Keep Failing Us and How to Know When Not to Trust Them by David H. Freedman
[Finished 9 September 2014] See review at

Gödel, Escher, Bach: An Eternal Golden Braid by Douglas Hofstadter
[Finished 7 August 2012] This is one of those books that it seemed that everyone but me had read (or at least had on their desk) when I entered nerd school. Coming to it now a quarter century later, I can see the appeal of it, and I think it would be fun to teach a course using this book as the central text. I was most interested in the Gödel part of the book, which was a central concern of the first two-thirds and was really well-done, providing a good in-depth look at the meaning and consequences of the incompleteness theorem. As Hofstadter moved into the domain of artificial intelligence, the book began to really show its age. Aside from the obvious case of Hofstadter believing that a computer would never beat the best human chess player (which, in fact, happened in 1997, 18 years after the book was published), the field of artificial intelligence has moved in directions rather different from what Hofstadter imagined at the time of this writing. Still, despite its age and its flaws, it’s a book well worth reading.

The Information: A History, A Theory, A Flood by James Gleick
[Finished 27 May 2012] A really nice cross-disciplinary look at information theory. Being a few chapters into a more academic computer science oriented text on the subject (working through lots of proofs and calculations relating to entropy, encodings, etcetera), I found some of the concepts familiar and had a bit of deeper background in understanding where things were going in the discussion, but I don’t think that this was strictly necessary. There’s a great deal of wonderful background and example-building that enables a great deal of breadth as well as making connections between computability and Gödel’s incompleteness theorem.

C++ Coding Standards: 101 Rules, Guidelines, and Best Practices by Herb Sutter and Andrei Alexandrescu
[Finished 29 January 2012] A reasonably comprehensive overview of the best practices of contemporary C++. I found myself realizing as I read this how poor and out of date my C++ has gotten. There were big chunks of the language which I had forgotten existed in any form.

Hadoop in Action by Chuck Lam
[Finished 24 October 2011] I went into this book thinking that much of the learning curve of Hadoop was going to be centered around programming issues and was irritated that the early programming examples employed a version of the API that was already deprecated when Lam wrote the book. But as I dug deeper, I realized that the programming side of things is ultimately the least important aspect of Hadoop; writing a Map-Reduce program is not that complicated (and Pig/Hive which are brought into discussion in later chapters really deserved more coverage simplify that even further). Most of the book focuses on management issues with Hadoop which seem to be the core of working well with Map-Reduce development

Spring Integration in Action by Mark Fisher, Jonas Partner, Marius Bogoevici,
[Finished 21 July 2011] Pretty good coverage of Spring Integration by the project lead and several committers. It does assume some familiarity with enterprise integration patterns, but not so much that it’s a handicap to read it without that background.

Spring in Action, 3rd Edition by Craig Wallis
[Finished 15 July 2011] A great update to the previous edition of Spring in Action. As usual, the framework is presented through the context of building a web application, but the greater simplicity that comes with the annotation-based configuration in Spring 3 means that Wallis is able to cover more topics and get into greater depth in some areas without sacrificing comprehensiveness.

EJB3 in Action by Debu Panda, Reza Rahman and Derek Lane
[Finished 11 July 2011] A good overview of EJB3 technologies, although there seems to be a bit of a defensive stance taken with respect to the growth of Spring and its lightweight framework.

Cocoa Programming for Mac OS X by Aaron Hillegass
[Finished 22 January 2011] This is definitely the book to get to learn Cocoa programming. I started this with a study group, but fell behind the group and finished it up on my own. There’s a pretty good overview of the libraries, but I would have liked more depth. I’m assuming that I need more books to cover details (or just get deeper into the Apple-supplied documentation).

Collaborative Intelligence In Action by Satnam Alag
[Finished 7 October 2010] A bit of a mishmash, although there’s a fair amount of useful information on algorithms and open-source solutions to collaborative intelligence problems.

Data Structures & Algorithms in Java by Robert LaFore
[Finished 11 May 2010] A decent introduction to data structures. There wasn’t a whole lot in here that I didn’t already know, but I felt that it would be a good idea to plug in some of the gaps in my knowledge.

Much of the information is presented informally and readers are directed to a set of Java webapps to be able to see how the structures and algorithms work in slow-motion. For some of the more complicated structures, these are especially handy for understanding

This is the first entire book that I’ve read on the Kindle and I found the Kindle experience to be a bit underwhelming, complicated further by the fact that program listings and tables are presented as graphics because of the limitations of the Kindle format. ePub theoretically would work better, although when I looked at a programming book on a Nook while visiting Barnes & Noble, I was similarly underwhelmed by that device’s display of technical content as well.

Stripes ...and Java web development is fun again by Frederic Daoud
[Finished 10 November 2009] A nice clear and lucid introduction to the Stripes Java web framework. I found that the framework did everything that I needed it to do and did it in a generally clear way. Daoud does a good job of covering the cases where Stripes is a bit out of sorts in the way it handles things (most notably some odd corners of Spring integration). Sidebars and commentary go a long way towards adding clarity and pointing out some of the more complicated aspects of the framework.

Programming in Scala by Martin Odersky, Lex Spoon and Bill Venners
[Finished 6 October 2009] Not only an excellent book on Scala, but an excellent book on functional programming and on programming in general. By far, this is the book which does the most to really explain what FP is all about and how programmers can take advantage of it. Scala is a language that I think that I would really like to pursue and this is a book which will remain at convenient arms’ length

Java Persistence with Hibernate by Christian Bauer and Gavin King
[Finished 11 August 2009] A great overview of Hibernate. There are problems of course: Some unnecessary chapters (e.g., the gratuitous chapter on SEAM); too much coverage of XML vs Annotation-driven configuration; not good enough reference organization; too little coverage of JPA. But even with these flaws, I learned a lot about how to configure entity beans with Java and manage their persistence. Definitely a book to keep within arm’s reach of my desk.

A Programmer's Guide to Java SCJP Certification: A Comprehensive Primer by Khalid A. Mughal and Rolf W. Rasmussen
[Finished 7 August 2009] I read the guide for Java 1.4 in the Bates and Sierra version, so I decided to try someone else’s guide in prepping for the Java 6 test. The overall material is pretty good, but I found myself frustrated by frequent errors in the review questions/answers. Numerous answers are missing from the back of the book and there were four questions in the review test where the answers in the back of the book didn’t match the questions. Those problems aside, it’s a good enough book for learning the material and diagnosing weaknesses.

Programming Erlang: Software for a Concurrent World by Joe Armstrong
[Finished 11 July 2009] I’m not always confident about reading a book written by the creator of a language. Sometimes it works well (see Knuth’s TeXBook, sometimes not so much (the original ANTLR book by Terrence Parr). This book, thankfully falls into the first category. I would have liked to have had some more guided application development in the book. It’s a surprisingly thin volume, but then Erlang is at its heart a rather simple language. Armstrong does a good job of establishing the FP mindset and I find myself tempted to write some of my newest code in Erlang.

Programming Groovy: Dynamic Productivity for the Java Developer by Venkat Subramaniam
[Finished 27 March 2009] A reasonably well organized book for a sometimes disorganized language. I felt like there was a lot more to the language than I got from the book, although some of the key aspects of the language which have a great deal of promise, particularly the builders. On the other hand, playing with the language I’ve found that it has a tendency to change types unexpectedly.

Maven: The Definitive Guide by Sonatype
[Finished 5 January 2009] A pretty good guide to Maven, although I have some quibbles about the order in which things are presented (I’d rather have it start from the perspective of someone working in Eclipse, for example), but it covers everything that one needs to know about this build/dependency management tool.

Java Tools for Extreme Programming by Richard Hightower and Nicholas Lesiecki
[Finished 18 December 2008] I found this in my wife’s library and decided to read it, but found myself frustrated by the obsolescence of large swaths of the text along with the high proportion of filler.

Jakarta Commons Cookbook by Timothy M. O'Brien
[Finished 17 December 2008] Another essential reference desk. Here the problem is that a fair amount of the Jakarta Commons is made less meaningful with Java 5. Perhaps, though, this would be a good area to contribute to the open source community: Putting together Generics-aware versions of the libraries.

Java Cookbook by Ian F. Darwin
[Finished 13 December 2008] An essential reference for any Java programmer. My one complaint is that there’s a concerted effort to ignore anything outside the Java libraries.

Core JavaServer Faces by David Geary and Cay S. Horstmann
[Finished 29 August 2008] We decided to avoid JSF on our project before I began this book, although after reading it, I’m wondering whether that was a mistake. It seems a great technology, although this book contains a little too much padding and off-topic material to boost its page count for my tastes.

Head First Object Oriented Analysis and Design by Brett D. McLaughlin, Gary Pollice and Dave West
[Finished 22 August 2008] A bit more basic than I had originally expected. A good primer for a programmer who is not quite ready for design patterns yet, to get them thinking about how to solve programming problems.

Core J2EE Patterns by Deepak Alur, John Crupi and Dan Malks
[Finished 1 August 2008] It seems more a book for someone writing a framework than for someone using a framework. I can see this as useful as my Java work becomes increasingly sophisticated, but at the moment, it seemed mostly a dry and uninteresting work.

Inside Java 2 Platform Security: Architecture, API Design, and Implementation by Li Gong
[Finished 21 July 2008] A great deal of information at higher detail and lower level than I’m interested in. Perhaps someday in the future I’ll come back to this and be happy about it.

Hibernate in Action by Christian Bauer and Gavin King
[Finished 12 July 2008] Argghh! For some reason Bauer and King decided to change the title of the book between editions so I inadvertently bought the old edition.

Google Web Toolkit Applications by Ryan Dewsbury
[Finished 10 July 2008] A bit of a disappointment. I had hoped for something that was a bit more about integrating GWT with Java applications, but Dewsbury’s focus is almost entirely on doing fancy stuff in the front end.

Spring in Action by Craig Walls and Ryan Breidenbach
[Finished 9 June 2008] Given how much material there is to cover, this volume does an admirable job of covering it, although it really could have benefitted from frequent references to other sources on the material where there was insufficient room to cover the whole of the material. As for the framework itself, it seems an outstanding framework and I’m looking forward to working with it on our current project.

Java Generics and Collections by Maurice Naftalin and Philip Wadler
[Finished 2 June 2008] One of the interesting features in Java 5 is the addition of the generics and collections features. To a large extent, this reminds me of the introduction of the STL in C++, and just like that opened new possibilities in C++, the generics material makes Java a more compelling language to work with.

Implementation Patterns by Kent Beck
[Finished 28 May 2008] It’s not often that a computer book is beautifully written. But this is one case where the rule is violated and the prose is exquisitely crafted.

The patterns described here are rather simple things, not quite on the level of Gang of Four patterns. They consist of such concepts as how to name methods or fields, or how to assign responsibilities to classes. A delightful book and one which seems like it would repay re-reading handsomely.

Unit Testing in Java: How Tests Drive the Code by Johannes Link
[Finished 23 May 2008] A clear, well-written book on the subject of unit testing in Java. Not a whole lot which is unfamiliar to me, courtesy of doing a lot of test-driven development in other languages, but it was nice to see my practices and beliefs validated by another developer’s suggestions. It is interesting to note that dependency injection is viewed as the solution to the mocking problem for Java, which makes sense since some of the Perl-esque solutions I’ve been using are not really possible in Java.

Catalyst: Accelerating Perl Web Application Development by Jonathan Rockway
[Finished 1 May 2008] An amazingly bad book. What’s really necessary for Catalyst is a single tutorial than a comprehensive overview of the features well-organized. What we get instead is a set of tutorials which don’t necessarily cover all the features of Catalyst, and no reference features to speak of at all. Wondering what the function of the method attributes in a controller are? You won’t find that information here. The index is frustratingly incomplete, the book is thin and vague and the whole thing is a bit of a waste. Would-be Catalyst developers are better off just reading the POD documentation than trying to make any use of this book

Prototype and You Never Knew JavaScript Could Do This! by Christophe Porteneuve
[Finished 9 April 2008] I freely admit that it was the visual candy of which brought me into learning this package, but the syntactical candy of prototype really impacted how I looked at writing JS code.

The book itself is a somewhat odd bird as at times it assumes familiarity with JS techniques and at other times, it assumes ignorance thereof. Overall, though it does provide pretty decent coverage of the Prototype and libraries, although I would have liked a little more remedial JavaScript as part of the text.

Perl Medic: Transforming Legacy Code by Peter J. Scott
[Finished 28 February 2008] Bleah. This is a wannabe Perl Best Practices, but without the quality or depth of Conway’s work. In fact, a fair number of the suggestions are the opposite of best practices. Don’t bother with this one, get Conway and consider yourself done.

Pro Perl Debugging by Richard Foley with Andy Lester
[Finished 23 February 2008] I opened the box from amazon and found a hardcover computer book. Imagine my surprise.

Cover aside, there’s a fair amount of good information in here, although it seems at the same time to be about half filler (I think this has been my experience with Apress books in general). There are, however, some good recipes for debugging web applications (short version, run Apache in single-user mode), and for those of us who like paper references, it’s a useful tome to have on the shelf.

Practical Perforce by Debra Wingerd
[Finished 15 February 2008] For whatever reason, my current employer is using perforce for version control. Not being familiar with it (but having used RCS, CVS, SVN and even SourceSafe in the past), I figured that it would be a good idea to read the book so that I could tell what practices were dictated by the software and what were cultural (and perhaps subject to improvement).

All told, I have to say that I prefer svn’s overall methodology. It just seems a lot more agile than the perforce approach, although the final chapter on dealing with web-based projects is a bit more sensible. I’m thinking that there might be some applicable ideas in the agile version control with svn book, despite the use of the word “svn” in the title.

As a manual, the book falls a bit short. I’m thinking that there’s room for a good book that’s repository-neutral to talk about the best way to manage version control in a programming environment.

MySQL Database Design and Tuning by Robert D. Schneider
[Finished 5 February 2008] A decent enough book, although too much of it seemed like it was straight out of the MySQL manual, without enough supplemental information. Why would I choose InnoDB over MyISAM? How exactly do I interpret the results from EXPLAIN? There was nowhere near enough of this sort of information, which I would really have liked to have seen.

Programming Ruby by Dave Thomas with Chad Fowler and Andy Hunt
[Finished 11 January 2008] A pretty good book which manages to thread the line between needing to be a tutorial and needing to be a reference. The big problem I see is a complete lack of coverage of any of the practical library components necessary to do any real development work. I suspect that this is part of why Rails is viewed as an almost inseparable part of Ruby.

Perl Testing: A Developer's Notebook by Ian Langworth and chromatic
[Finished 31 December 2007] I wanted to get a stronger sense of the testing capabilities of Perl, so, this being the sole book on the topic that I was aware of, I placed an order.

The book is fairly dense and designed more as a reference than a tutorial. It helps to have a computer handy to try the code that’s provided and do experiments, but even more so, it’s a means to be able to learn the material well.

It’s a very different approach than the Head First series which I’ve taken to much more closely, but it does seem to have a valuable place in the nerdbook ecosystem.

Sun Certified Programmer & Developer for Java 2 Study Guide by Kathy Sierra and Bert Bates
[Finished 6 December 2007] While digging up the ISBN for this at Amazon, it appears that the exam has changed since I (well, my wife, actually) got the book. Looks like another purchase may be necessary, although this exam is apparently still given as well...

The text is well-presented and gives good advice on how to approach the material. I found the Bates/Sierra jokey style a bit cloying at times as I read through the book, but it didn’t detract too much from the information being presented. The practice CD is, alas, Windows-only (come on folks, right the software in Java!), which leaves the paper-only reader with fewer practice questions than I would like.

Head First Design Patterns by Eric Freeman and Elisabeth Freeman with Kathy Sierra and Bert Bates
[Finished 15 November 2007] Quite simply, this is the best book for learning design patterns. Yes, it’s a bit overstuffed with some fluff and filler (and perhaps a bit too much whitespace in places, which is an uncommon complaint for contemporary computing paper brick books). By beginning with a problem to be solved then showing how a pattern fits it, the authors manage to do an outstanding job of presenting what could be a difficult and abstract problem.

The examples are presented in Java, but it should be a simple matter for any competent programmer to use this to apply patterns to her preferred language if it’s not Java.

If the rest of the Head First series is this good, then O’Reilly has a big winner on its hands here.

Agile Web Development with Rails by Dave Thomas and David Heinemeier Hansson
[Finished 23 March 2007] I’ve come to appreciate the value of a good framework in application development. Yes, it sometimes forces me to set things up in a way that seems a bit unnatural, but the benefits of scaffolding and MVC-architecture by far outweight that difficulty.

Ruby feels much like the programming language that I’ve been looking for, with a clean dynamically-typed object model and mostly well-conceived language structures. The big difficulty I’ve found is that there isn’t any good single resource for Ruby/Rails programming. This book provides a decent overview, but the current practice in programming books to build the bulk of the text around the construction of a sample application doesn’t really fit the way that I like to learn a language: I want to get into my own project and the needs of the sample project and my own code generally split apart pretty quickly. I’ll doubtless come to appreciate the value of this book over time, much as I grew to love the llama book, but for now, I find myself wishing that it was more of a reference than a tutorial.

And I would add that I do feel that I can trust the Pragmatic Programmers series of books for future purchases, regardless of my reservations about this volume.

Perl Best Practices by Damian Conway
[Finished 13 November 2006] After reading Damian Conway’s excellent Object-Oriented Perl and hearing about this book, I of course let amazon take some of my money so that I could read this one. It’s a solid book with absolutely no filler in its 500+ pages. There are some sections which could do with a bit less explication of the low level section (I’m thinking in particular the advice to use Inside Out objects, which would have been better to start with explaining how to work with Class::Std or Object::InsideOut rather than going into details about how to do by hand things which are better handled by the appropriate CPAN module). And there are some bits of advice that I disagree with entirely (for example, Conway’s deprecation of protected access to data which he might think is an idea which is best forgotten, but I find is, at least at times, a very useful way for parent and child classes to communicate). But even if you disagree with some of the practices, it provokes the programmer into contemplating that aspect of coding. No perl programmer can read this without coming out at the back a better programmer. And many of the ideas are rather language agnostic and could be applied to coding practice for other languages as well.

Foundations of Ajax by Ryan Asleson and Nathaniel T. Schutta
[Finished 24 October 2006] Part of what attracted me to this book when I picked it up was the fact that it had screenshots of Safari and Firefox from a Mac. Great, someone writing about web development who knows that there are browsers other than Internet Explorer under Windows.

The exposition is pretty decent, although as with too many computer books (I think I’m ready to give up on Apress books already), there’s a lot more padding than content here. What’s worse, what seems to me the best approach to dealing with Ajax having finished my first project where I used it, is to have some sort of Framework, a possibility which isn’t even mentioned until the end of the book, and that in passing. The appendix on browser issues, is helpful and not something I was able to find in the web (I wish I’d finished reading the book before I started the Ajax project since I really needed that info many times). The index is woefully incomplete especially when you’re looking up information on particular Javascript properties.

In all, a decent, but not spectacular book. I think what I really want is something which is geared around the use of some Ajax framework (or perhaps more than one) and which deals with the ugly details of how to do the job in an appendix. And much shorter code snippets between explication. Four-page listings of HTML/JavaScript make my eyes glaze over. Having typographically indistinct Java code as well makes things just that much more complicated.

Applying UML and Patterns: An Introduction to Object-Oriented Analysis and Design by Craig Larman
[Finished 20 October 2006] A fairly quick read, I tackled this while re-entering the programming world. Parts of it are a bit frustrating, like some vagueness about some aspects of UML and what the components are, but the structure of the book, which looks at the life-cycle of a software development project does give a pretty decent introduction to both UML and design patterns, although it’s not especially useful as a reference to either.

Apache Cookbook by Ken Coar and Rich Bowen
[Finished 13 September 2006] I had high hopes for this book, which were quickly dashed once I started actually reading it. Much of the information is sparsely and incompletely presented (the latter especially perplexing given how thin this book is). A great deal of time is expended on explaining also how to get Apache running under Windows, a foolish prospect if there ever was one: The only reason to use Windows as a server is if you want some Windows-specific functionality which in turn implies IIS. A well-informed web administrator would run a proper server OS on their webserver.

PHP 5 Objects, Patterns, and Practice by Matt Zandstra
[Finished 3 August 2006] Maybe it’s because I was reading this at the same time as Damian Conway’s excellent book on object-oriented Perl, but this came across as quite a bit less well-written. There’s much less information on object-orientation here, but a big part of that is the more mature object mechanism in PHP compared to the kludgy Perl5 object system.

There are a few chapters which seem to be padding as a consequence, although even as padding they do address some useful topics for good programming practice (PEAR, CVS and Phing).

Object Oriented Perl by Damian Conway
[Finished 31 July 2006] This is easily one of the best programming books that I’ve read. The tone is light but informative, and one of my favorite features of the book is that Conway ends each discussion with a reference for where to find out more: Sometimes it’s a book or article, sometimes a website, sometimes the perl documentation. The book covers, reasonably comprehensively, the ins and outs of object-oriented programming in perl. There are sections which are a bit out of date already (always a problem with a rapidly evolving language like Perl which was at 5.005 when Conway wrote the book, is 5.8.6 on my Mac, and Perl 6 is under way (one hopes with a bit more alacrity than the LaTeX 3 project).

Do I have any complaints about the book? None that I can think of. This is an essential for any perl programmer’s book shelf.

Programming Applications with the Wireless Application Protocol by Steve Mann
[Finished 13 January 2001] A fair introduction to a technology which became obsolete almost immediately upon release. By the time I finished reading this, WAP was one of those technologies that had fallen into the technological dust bin

Understanding ActiveX and OLE by David Chappell
[Finished August 2000] This got good reviews at amazon. I, personally, didn’t care too much for it, as it gave me a conceptual understanding, but didn’t allow me to do any actual development. Not in any way what I needed from the book

Special Edition Using FoxPro 5 by Michael Antonovich
[Finished 4 August 1999] Occasionally good, occasionally bad. It gets higher marks just because so many FoxPro books I’ve encountered have been so uniformly bad.

Instant SQL Programming by Joe Celko
[Finished 11 February 1999] A consensus recommendation from the internet, I found this book to be a bit of a disappointment. The useful content could have been condensed into a much shorter work and information on more sophisticated SQL programming added in its place.

Motif Programming: The Essentials... and More by Marshall Brain
[Finished 3 September 1998] Excuse me for a moment, I just have a mental image of the author in junior high: “Mr Brain will you keep your hands to yourself!”

OK, the book itself is a bit thin on details. You won’t really be able to call yourself a Motif programmer just by reading this book (and doing the exercises), but it is a good way of getting one’s feet wet before diving into the O’Reilly books.

Thinking in PostScript by Glenn C. Reid
[Finished 23 February 1998] Reid was kind enough, after Addison-Wesley let his book fall out of print, to put it up on the web in PDF format. Unfortunately, having read it I’m left thinking that A-W had good reasons not to order a second printing. If you want to learn PostScript, read the Adobe “color books” (Reid wrote one of them). They’re worth the money. [Note: The link is to the PDF version of the book, not]

Teach Yourself Perl 5 for Windows NT In 21 Days by Tony Zhang and David Till
[Finished 30 January 1998] Personally I prefer Randall Schwartz’ style of Perl teaching more, but this is a surprisingly good book for the paper brick genre.

Language Translation Using PCCTS and C++: A Reference Guide by Terence John Parr
[Finished 25 January 1998] Donald Knuth felt that the creator of a software system should write the manual. This book is the reason why he was wrong.

Visual C++ Unleashed by Viktor Toth
[Finished 29 December 1997] I got suckered in by the promise of great software on the CD. But it’s all crippleware demos and not the real stuff. The book itself is passable, although the author is still largely stuck in C-mode. Sigh.

Visual FoxPro 5.0 for Windows: Developing an Application Framework by Nelson King
[Finished 29 November 1997] Somebody please find me a book that will allow me to learn FoxPro programming already. I’m beginning whether the people writing the books know how to program FoxPro. Surely someone somewhere does, but they don’t seem to be writing the books.

Visual J++ Bible by Richard C. Leinecker and Tom Archer
[Finished 14 November 1997] A decent coverage of the language although the authors appear to be severely challenged in the aesthetics department. Many of their later examples also leave much to be desired.

Windows NT in a Nutshell: A Desktop Quick Reference for System Administrators by Eric Pearce
[Finished 16 October 1997] Perhaps my expectations were too high, but I expected something a little bit more in depth than this book. Pearce, for example, fails to discuss the environment variables that affect the operation of some shell commands (although some of these are apparently undocumented outside of Microsoft).

Object Orientation in Visual Foxpro by Savannah Brentnall
[Finished 14 October 1997] Theoretical books have been pushed out of the marketplace by big bricks of paper. I’m uncertain as to whether this is a good thing. In some cases, a theoretical approach can be useful, but Brentnall’s discussion of Foxpro’s object orientation in this book left precious little standing room to really have a concrete grounding. The only clearly good thing that I got from the book was a realization that what Fox calls a container class is not what I would think of as a container class.

Building Visual FoxPro 5 Applications by Barrie Sosinsky
[Finished 18 September 1997] DO NOT BUY THIS BOOK. Despite claims that this is a step-by-step account of how to put together a FoxPro application, it’s a rambling acccount of contracting, software development processes and only a modicum of usable FoxPro knowledge. I hope I can get my money back.

Computer Graphics: Principles and Practice by James D. Foley, Andries van Dam, Steven K. Feiner and John F. Hughes
[Finished 13 August 1997] A somewhat disorganized conglomeration of just about every imaginable topic on computer graphics. It’s really more useful as a reference than a tutorial and even then, I find myself wondering.

Compilers: Principles, Techniques and Tools by Alfred V. Aho, Ravi Sethi and Jeffery D. Ullman
[Finished 15 May 1997] The famed dragon book. I really only understood about half of it, but it was still very fascinating and leaves me wanting to write a compiler of my very own.

C++ Database Programming by Al Stevens
[Finished 24 October 1996] An interesting book, although at the end, I was left wondering where the query library is. The separation of commentary from source code in the example programs is also unfortunate.

Advanced C++ Programming Styles and Idioms by James O. Coplien
[Finished 13 October 1996] Just as the title indicates. Some of it was a bit too esoteric for me, I must admit.

A C++ Programmer's Guide to STL by Mark Nelson
[Finished 23 August 1996] This book has taught me more about general C++ programming than any other that I’ve picked up. And its coverage of STL is fantastic.

The Hacker Crackdown: Law and Disorder on the Electronic Frontier by Bruce Sterling
[Finished September 1995] Most prose on the internet is, quite frankly, crap. Anything book-length tends to fall into one of two categories: Poorly HTMLized texts in the public domain and works too bad to find a “real” publisher.

The discovery of this book on the internet (and it’s available on paper as well), then was quite delightful and sucked several hours of my precious time while I read it. Since most of my non-fiction reading tends to not be of the mainstream variety, I often forget how captivating it can be (and ought to remind myself to bring some of this energy into my own writing). Definitely a gripping yarn, and while it will appeal to the computer geek, is not mired in technobabble. A definitely recommended read.

Learning Perl by Randall Schwartz
[Finished May 1995] OK, so I can be a computer geek at times. I figured it was about time to learn this language so I could do my own CGI scripts, or at least understand the ones I get from other people. As for the book? Well, the humor was really more distracting than it should have been and I found the organization really quite awful. There’s also a dearth of good examples of things and the discussion of vital things like eq appears somewhere nonintuitive. Perhaps if I had done the exercises as I went along it might have helped. Still, there’s plenty of room for a better mousetrap here.