My apologies for the long gap of time that has elapsed since I’ve written a “real” post; it is true that school and work have been keeping me busy, but the whole story is that I’ve had less to write, and more to think about lately. This includes slowly working through two books that I’ll briefly mention here.

Coders At Work by Peter Seibel is a series of real and raw interviews with some of the most high-profile programmers of our day (though I’m rather ashamed to admit that the only name that was familiar to me before I started reading the book was that of Donald Knuth). After reading the favorable review of this on Coding Horror, I picked it up, and I’m glad I did.

Within its 601 pages, each interviewee is asked some predictable (though interesting) questions resembling:

• How did you get started programming?
• What was it that drew you to it?
• What do you think about C/C++?
• What tools do you use?

And then some more useful ones:

• In retrospect, how much of a role did academia play in jump-starting your career? Was it necessary?
• How about graduate study?
• What is the process that you use to design software?
• How important are formal proofs to testing?
• How do you read code?
• What are the skills you are looking for when hiring new programmers?

Obviously, as a rather new programmer in undergraduate study, these questions and more I find especially fascinating to hear addressed this early into my career. Though these folks have strong opinions which vary widely in some aspects, there are nuggets here such as the huge importance of reading code that others have written which I am glad to discover. The book has been reported to read like a novel, which it truly does.  Caution: because of the informal interview settings, the book contains occasional (though concentrated) strong language.

When I wandered over to Barnes & Nobles to pick up the first book, a second grabbed my attention entitled Pragmatic Thinking and Learning by Andy Hunt. This is, not surprisingly,  another addition to the Pragmatic Bookshelf (TM) series, but it turns away from the technical skills to concentrate on the art of thinking — but not in the analytical, procedural, mechanical, left-brain approach that we employ at work. Instead, Hunt emphasizes capturing and taking advantage of the creativity and intuition that sets apart an expert from an advanced beginner on the Dreyfus model of skill acquisition, and how to stimulate and encourage such thought patterns that he contends are not overly common to the field of Computer Science. With a well-established background, plenty of humor, well-placed quotes, hand-drawn illustrations and practical ideas geared toward those in the software industry, I am finding this to be a fresh and unique perspective on skills useful to a programmer.

Another seasoned (read: old-ish) but fantastically practical book for programming students, enthusiasts, or pros looking to improve their ability is The Pragmatic Programmer by Andrew Hunt and David Thomas. I stumbled onto this one while browsing randomly through the local bookstore, and I’m glad I discovered it. If you are serious about software development as a career, I’m convinced that you will benefit from owning this book.

Although Pragmatic Programmer has plenty of expected how-to best coding practices, such as orthogonality, code generation, object orientation, and other tips designed to save you time in the long run, the overarching theme of the book rises above; this theme is something the authors refer to as the DRY Principle – that is, “Don’t Repeat Yourself.” The book bullet-points a total of 22 bluntly succinct tips (these tips are also collected into a quick-reference tear out sheet in the back of the book), and most of these involve concepts to help you fulfill the DRY principle. Though the book is highly conceptual, Hunt and Thomas include a few brief code snippets to make those tips tangible (my only wish is that they could be fleshed out a bit more).

One of the coolest things about the book, in my opinion, is that the authors have made an effort to cover nearly all the aspects of the software development process — from gathering requirements, writing prototypes and tracer code, to coding,  testing, debugging, deploying, and writing documentation — brushing each against the DRY goal of non-duplication. This thorough book also includes some out-of-the ordinary sections, such as how to understand algorithm speed and performance. Hacking code, I am realizing,  is only a part of the big picture in a successful project!

Some of the suggestions are harder to put into practice than others (such as learning scripting languages to automate routine tasks, and taking the time to learn powerful text editors like Emacs or Vim which have keyboard shortcuts for everything up to organizing a world takeover), but I have no doubt that once the initial time investment is made in learning a scripting language or two, it will pay itself back many times over. I find myself preferring, and ultimately relying perhaps a bit too much on comfy IDE’s and UI’s and costing myself time and wasted mouse manuevering in the long run for the convenience and viewing pleasure. (For the record, though, I’m hooked on the Eclipse editor and I’m not budging!)

In short, it’s hard to read a section without being slightly convicted in one way or the other about things we all should already know (yes, you have to comment your code; yes, you have to document it; and no, your team shouldn’t allow anonymous code). But the topics quickly progress beyond these points and into many other, less obvious, tips and warnings. Hunt and Thomas have drawn from their experience and have done a great job in combining so many great principles into a book that is easy to read, humorous, and fluff-free (say that 5 times fast). Now if only I can gather up the courage to crush those lazy habits, and then tackle Perl and Latex…

Next up for review: Advanced Windows Debugging by Mario Hewardt and Daniel Pravat.

I know this is an old book (1994!), but it’s one that I have just added to my bookshelf and it’s worth a review for undergraduate (read: relatively inexperienced) programmers such as myself. Written by the now famous “Gang of Four” (Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides), Design Patterns is the classic and authoritative reference on the subject.

So far I am a self-taught programmer with intermediate experience, but I am looking forward to taking classes in my major and improving the quality of the code I write as early as possible. Design patterns are a significant part of it, and this book is a great place to start. Separated into two parts — a case study and a reference section — this is a book that will be useful both now and in the future. While the patterns presented are not new by any means (in fact, they weren’t new at the time when the book was written), with today’s shift towards object-oriented programming languages (Java, C#, etc.), the basic 18 patterns that it presents are more crucial than ever to have a working knowledge of.

If you are interested in creating properly abstracted and decoupled classes; wish to learn about patterns useful for allowing undo/redo operations and state saving, patterns that help you manage object creation or access, and much more, then you will find this book to be useful. As I read through the scenarios I find myself thinking back to code that I have written, wishing I had read the book earlier! In all, the patterns the book describes are Abstract Factory, Builder, Factory Method, Prototype, Singleton, Adapter, Bridge, Composite, Decorator, Facade, Flyweight, Proxy, Chain of Responsibility, Command, Interpreter , Iterator, Mediator, Memento, Observer, State, Strategy, Template Method, and Visitor. For each pattern there is a brief and long description, a list of implementation tips to consider when using the pattern, and a concrete example in C++ (mostly) or Smalltalk.

The only con that I have found so far is that the code samples are fairly specific and leave me wanting more as a tangible explanation of the conceptual description for each pattern. For that reason, a great book to go along side this one — or perhaps to start with –  is Design Patterns in Java by Steven Metsker and William Wake, as it has more examples and included problems and solutions for each pattern. Overall, though, Design Patterns is a must-have for serious programmers.

Design Patterns: Elements of Reusable Software on Amazon.com