Page last updated:
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 |
| Date | Author | Title |
|---|
[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.
[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.
[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
[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.
[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.
[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.
[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.
[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.
[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.
[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.
[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.
[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.
[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.
[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.
[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.
[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.
[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.
[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.
[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.
[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.
[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
[Finished 9 April 2008] I freely admit that it was the visual candy of script.aculo.us 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 script.aculo.us libraries, although I would have liked a little more remedial JavaScript as part of the text.
[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.
[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.
[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.
[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.
[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.
[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.
[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.
[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.
[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.
[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.
[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.
[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.
[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.
[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).
[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.
[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
[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 amazon.com.]
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.
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.