Posted by Brian
Last week I decided to do something I had been toying around with for a while and launched a new website, www.curmudgeonlysoftware.com. This will be the new home for all of my software related postings and this blog will be where I post everything else. Essentially it’s a professional vs. personal divide. My most commonly read articles are by far software related, so splitting this way should do most people a favor.
Existing technical posts that have value to others will be redirected to Curmudgeonly Software. I will probably get around to sorting that out this weekend. For now, you can see the next post in my From C# to Perl series on the new website, this time on performance. Also, I have been working on an implementation of tetravex in Perl with SDL that I will be posting on soon. For now you can find the code at github.
This site may also be changing over to WordPress sometime in the near future. When I started this site I chose Typo because I was doing some work with Rails, and because WordPress was becoming the target of more frequent attacks. However, I tried WordPress for Curmudgeonly Software and it is so far and away superior that I’ll probably switch this site as well.
Posted by Brian
Edited By Andy Oram & Greg Wilson
Beautiful Code is a collection of essays from programmers working in a number of different areas, from language design, to operating systems, to enterprise application development. If you are a programmer, chances are good that at least a couple of essays in here will appeal to you.
First, the good. Some essays are great. Yukihiro Matsumoto, the creator of Ruby, has arguably the best (and shortest) essay in the collection, concentrating on what makes code beautiful and how those factors influenced his design of Ruby. Elliote Rusty Harold’s contribution on lessons learned creating XML verifiers is also a standout. He goes through several implementations, learning from each to improve the performance of the next, all while maintaining correctness across all cases. Charles Petzold’s description of on-the-fly code generation for image processing is dense, but interesting. As a sometimes Python programmer, Andrew Kuchling’s discussion of the design trade-offs in the design of Python’s dictionary implementation was much appreciated and gives insights into performance optimizations you can make with your application if needed.
Unfortunately there is also a fair amount of bad. One issue is that the book is simply too long. The editors mention they got a more enthusiastic response from contributors then they expected. They may have felt compelled to include all or most of the responses. But beyond the length, some of the essays are just bad. For example, Douglas Crockford’s “Top Down Operator Precedence” essay dives right in without actually explaining the algorithm. It is explained piecemeal throughout the code, but you never get a good feel for exactly what is going on. Other contributors have the view that whatever skills they need to do their work is essential to being a true software engineer. For example, Bryan Cantrill writes that postmortem debugging with core dumps “is an essential part of our craft - a skill that every serious software engineer should develop.” Quite honestly, only a very narrow niche of software engineers are serious then. Other authors take similar narrow views at times, whether it is the author of math libraries feeling that everybody needs to care about high performance computing or C programmers feeling that every real programmer should implement their own dynamic dispatch code in C at some point in their careers.
Beautiful Code is worth the read, but don’t hesitate to skim over the essays that don’t interest you. I probably would have enjoyed it more if I didn’t force myself through most of the them. (Also see Jeff Atwood’s review for a good explanation of why the title of the book is misleading.)