Musings of a Software Engineering Student

There’s been a lot of talk about Peter Seibel’s new book, Coders at Work, recently, so I decided to
read it as well. I’m definitely glad I did; It’s a very readable book, with some very good programmers and designers’ views on debugging, programing, and other technical topics. Among those interviewed are jwz, Peter Norvig, and of course Donald Knuth, among others. This book seems inspired by another one I’m reading, Masterminds of Programming, but I enjoyed this one a lot more.

The book consists of 17 interviews with different programmers in a wide variety of domains. There’s a lot to absorb, and it’s pretty instructive to see how many of these coders don’t rely on modern tools such as debuggers or IDEs. While the interviews are pretty organic and aren’t exactly alike, Siebel does ask all of them some of the same questions, and it’s nice to see that different approaches can work equally well. Each programmers approach to API design is another one of the big ones he tends to ask, which is what I’d consider one of the most important parts of being a programmer.

I’d definitely recommend reading this book - there is a lot of useful information to absorb from it. It’s hard to pinpoint specific lessons, but it should at least make you think about your methods and techniques. It’s a very readable book, enjoyable to read and easy to understand. I’m with Joel on this - you should definitely read this book.

The Seasoned Schemer and it’s predecessor The Little Schemer, by Daniel Friedman and Matthias Fellstein, are two of the best books for learning Scheme and functional programming out there. These books are not like any other technical books you have ever read; the format is downright weird. The book is more of a conversation between an instructor and student about a set of problems than anything else, with the instructor on the left half of the page and student on the right. This is the same format that the rest of the books in this series have, such as The Little Schemer, The Reasoned Schemer, and A Little Java, A Few Patterns.

Like The Little Schemer, The Seasoned Schemer starts out easy and quickly advances the difficulty. You are expected to remember the things from The Little Schemer, so you should probably read that book first, even if you have some Scheme experience. The book starts of with introducing new variables with let and letrec, and went on the explain closures, modify state (with set!), and call-cc. The last chapter involves writing a Scheme interpreter without using data structures, just functions. +1

While the answers to all the questions asked in the book are right there, you do want to take your time and solve them yourself. Some of the things covered in this book are quite complicated and hard to understand if you only read the solutions and not find them yourself, like the derivation of the applicative-order imperative Y combinator. The book isn’t too long, so it should only take you a week or so to finish it anyway, and working through the exercises really helps your understanding. This series is actually one of my favourites for learning scheme; I would highly recommend reading it, even if you aren’t going to be doing much Scheme programming, just to expand your horizons.

I just finished reading Beautiful Code, from O’Reilly. It isn’t like most technical books; like the others in the ‘Beautiful’ series, it’s more a collection of essays on a topic than a book. This is probably a better format than a book for these types of issues - there isn’t really one way for code to be beautiful, and so O’Reilly figured that the best way to transmit what beautiful code is was to get a wide range of opinions.

Beautiful Code has 33 essays by different - and very talented - software developers. Some of the more famous ones are Brian Kernighan, Matz, andd Greg Kroah-Hartman. Whether you read the essays in order or sporadically doesn’t matter - There is no dependence on previous chapters in any of the essays. Essays are on average less than 20 pages long, making them easily readable in short sittings. The overarching topic is code, not architecture, although some of that makes it in the book as well, so almost every chapter has code fragments that are being discussed.

Not all of the essays are going to be interesting to every person, although I still read all of them. For example, I didn’t particularly enjoy the essays on code written in bioinformatics packages. I do suspect that every person will like a different subset of the essays, and enough of them are incredibly good to make the book well worth reading.

My favourite essays in the book would have to be Brain Kernighan’s ‘A Regular Expression Matcher’, Andrew Kuchling’s chapter on Python’s dictionary implementation, and Andreas Zeller’s essay on delta debugging. These were very informative and gave very good examples of what beautiful code is, as well as in the last case a very cool idea for automated debugging. There were no more than five essays I was really not interested in, leading to a very interesting read.

All in all, Beautiful Code is well worth reading. It has contributions from the C, Lisp, Emacs, Haskell, Perl, and Python communities, as well as others. It gives a wide range of things to consider when making code beautiful, and many of the chapters explain very interesting concepts, such as implementing scheme’s hygienic macros, instead of small code samples that aren’t used anywhere outside the book. I’m glad I read it.