Published in June 2010, Practical Clojure by Luke VanderHart and Stuart Sierra is the latest Clojure book to hit stores. Despite the Clojure 1.0 jar shown at the beginning of the book, this title tries to cover the current version of the language, including references to concepts that will be introduced by the upcoming 1.2 version.

The target audience of this book is programmers who are absolutely new to Clojure. It didn’t strike me as being particularly aimed at developers who are coming from the Java camp, or the Lisp camp; in this regard, the book is rather “background agnostic”, even though Lisp programmers will feel much more at home than Java programmers will, due to the nature of the language itself.

The authors of the book are clearly well versed in this new language (Sierra is part of Clojure/core, the equivalent of the A-Team in Clojureland) and their confidence with the concepts presented is demonstrated throughout the book. Their explanations tend to be clear and to the point. Longer discussions are occasionally included when required to introduce concepts that are novel to most programmers, like the Software Transactional Memory (STM), refs, atoms and agents.

The book starts out by presenting a short but well-argued case for why Clojure is a worthwhile language, and then focuses almost exclusively on the core of the language. I’m afraid they do so to the detriment of the ecosystem surrounding Clojure. The authors don’t talk about how to install Clojure, recommend editors and IDEs (albeit a few are casually mentioned), or how to use build tools like Ant, Maven or Leiningen.

clojure.contrib, a fundamental extension library, is barely mentioned and there is no coverage of other important libraries or emerging frameworks. For instance, perhaps expectedly, Compojure (a web framework) and Incanter (a statistical and graphical environment) are only mentioned as examples of DSLs, however examples of their usage are not provided. (I believe the authors mistakenly refer to Compojure as Enclojure, which is a different project).

Despite the narrow focus, Practical Clojure doesn’t shy away from complex subjects and manages to include a chapter on Java interoperability, parallel programming, metaprogramming, and performance considerations. It does so briefly however, favoring a cursory presentation of the fundamental concepts rather than in-depth coverage, which would provide the reader with the degree of confidence required to approach real world problems.

The core language is covered in a manner that acts as both a tutorial and a reference. Major concepts, data structures, and common functions are presented to the reader with an endless supply of tiny examples. It’s easy to fly through them, but typing along in the REPL will be a far more valuable exercise for readers who hope to retain the information presented.

This leads us to another shortcoming of this book, which is the lack of more structured and complex examples. When I define their examples as “tiny”, with very few exceptions, I really mean it. For the first few chapters of the book the examples don’t get much larger than calculating the square root of a number through Newton’s method or adding contacts to an address book. Most of the other examples do a good job of illustrating the point they are trying to make with one, two, or just a handful of lines of code.

This is an actual sample of the kind of examples you’ll find throughout the book to illustrate many core API functions:

user=> (reduce + [1 2 3 4 5])
15

Note that this approach is didactically valid, because it isolates the function to show exactly how it works. After dozens of these functions though, you may expect larger examples to show how to integrate the use of some of these functions and data structures you’ve learned about. Such examples are seldom included. Furthermore, the book lacks any exercise for the reader. Foundational books that fail to offer many articulated examples and that lack exercises, tend to make it hard for the reader to retain the information and get some hands-on practice.

I have lots of respect for short books that get to the point and avoid wasting the reader’s time. K&R is notoriously acclaimed thanks to its clear and concise nature. However, Clojure is not C, and I feel that the 198 pages fall a little short when it comes to introducing this wonderful language to new readers. There is more to Clojure than simply surveying the language itself, even though I suspect that certain readers may appreciate this extremely narrow focus.

Overall the book is well-edited, despite the presence of minor issues. Aside from a few typos (e.g., “becauseall” on page 79), readers may find the formatting to be slightly inconsistent at times. For example in chapter 5 when presenting sequences, after the map function has been introduced, the font for the subsequent functions is substantially decreased for no apparent reason. Readers may be misled into thinking that the functions presented afterwards are somehow different from the previous ones, when in fact they’re all defined in clojure.core. In Listing 6-3, at page 103, the authors present their first “complex” example (the address book) and they do so by using, among others, doseq. This macro was not introduced before that page nor is it really explained within the example.

From a physical standpoint, this book is a rather thin and wide paperback. A small font, coupled with small margins and a wide layout, imply that the readability of the book suffers a little. The paper itself is off-white, fairly thick and slightly textured, not as pleasant to the touch as other books by Apress or most other technical publishers, even though I recognize that this is a matter of taste (some people may actually love it because of these characteristics).

With two introductory Clojure books on the market, drawing comparisons is unavoidable. Stuart Halloway’s Programming Clojure is a slightly older book (published in May 2009), which grants Practical Clojure a distinct advantage. This is not to say that Programming Clojure is obsolete, on the contrary it’s still a valid choice, but it doesn’t illustrate some of the new features that are available today. For example, in chapter 13 Practical Clojure introduces protocols and datatypes that will be available in Clojure 1.2 for the first time. Given that Halloway’s book was published more than a year ago, there was no possible way he could have included such powerful abstractions at the time.

Despite being older and less methodical than Practical Clojure, Programming Clojure tends to offer more complex examples. In the introduction of Programming Clojure you’ll see examples which Practical Clojure fails to include until much later in the book. Practical Clojure, the subject of this review, may leave you wanting for more practical examples of how all the language features fit together. Whereas Programming Clojure may leave you longing for more consistent explanations of how each part of the language works on its own.

Practical Clojure and Programming Clojure are competitors in the marketplace, but it wouldn’t be a bad idea to get ahold of both, because they complement each other quite well, in my opinion. Having to pick just one, I would probably recommend Practical Clojure, given its more consistent and up to date presentation. The sizzle offered by Programming Clojure, can be found to a much greater degree in upcoming and less introductory books, such as The Joy of Clojure. In this sense, reading Practical Clojure first followed by The Joy of Clojure, would be a solid learning path (Clojure in Action is another worthy addition, but it doesn’t replace The Joy of Clojure, which is a real gem).

In conclusion, Practical Clojure is not the Clojure equivalent of the highly praised Practical Common Lisp, from the same publisher. Reading it cover to cover and typing all the snippets included within, will not give you enough knowledge to start writing complex, idiomatic Clojure programs out of the gate.

However, if you are learning Clojure today, I do recommend this book. It’s a clear, well thought-out, concise introduction to the language that will give you a solid foundation as you go on to learn more about Clojure and Lisp in general.

In this post I’ll share a (necessarily incomplete) list of relatively new books that I believe will make most developers better programmers. By “new”, I mean books that have been released recently (within the past three years), that haven’t become classics yet or appeared in everyone else’s list of recommended programming books. Hence, you won’t find SICP, TAoCP, PFDS, etc.

Please note that each of them deserves (and probably will receive at some time) a lengthy review. Here I simply state in a brief manner why I think they are important.

In this post, I’d like to point out a couple of resources that I think compliment each other well, and focus on how to upgrade applications, as opposed to simply providing you with a shopping list of features.

The first one is Upgrading applications to Rails 3, a screencast that was just released by ThinkCode.TV. This screencast is almost an hour-long and shows you how to port a real world web application from Rails 2 to Rails 3. As such, it can be very useful if you have existing code that you’d like to port over to Rails 3. The author ported a few large applications to Rails 3, as he has solid experience with it. I’m biased of course, but I feel it’s well worth $8.99. (Today only, use the coupon RAILS3 to purchase this Rails screencast for just $5.99.)

The second resource is the Rails 3 Upgrade Handbook by Jeremy McAnally. It’s a beautiful PDF that succinctly explains what’s new in Rails 3, as well as how to upgrade your applications to the new edition of the framework. At 10c per page ($12 for 120 pages), it too is worth the money in my opinion.

Regardless of whether you end up buying these resources or not, I sure hope you have extensive test coverage for your existing Rails 2 applications. In my experience this is a must, because porting complex applications to Rails 3 without solid test support is a definite challenge. Nevertheless, I feel that this major upgrade is truly worth it. Rails 3 really brings Rails to a whole new level and we, as a community, should be proud and excited about what lies ahead of us.

Without further ado:

• Recommended Ruby Books
• Recommended Rails Books

A few people may disagree with the choices, but I think most experienced Ruby and Rails programmers, who’ve read those books, will concur with my recommendations. I’m quite confident that these are, all things considered, some of the best books available on the subject.

A word to the publishers

As tempting as it is to collect Ruby and Rails books, these days I don’t feel I can economically justify the act of purchasing every Ruby or Rails book put out there. So if you are a publisher or an author, and you’d like for me to consider your book, you are certainly welcome to send me a review copy. I will definitely read it, but only include it on these lists if it’s either outstanding or as good as the existing ones. If it’s a programming book that’s not related to Ruby/Rails, yet is really good, I would consider reviewing it on my blog.

Aside from a few good suggestions for other must-read books for programmers, there were several comments about how buying hard copies of books in this day and age is stupid. A few advocated piracy as an alternative to buying books, printed or not. Aren’t we supposed to be a group of professionals? Do we really believe that pirating books is the right answer to our profession’s need for knowledge?

The most sensible recommendations concerned the use of legally free, available material online, as well as suggestions that the $250 could be spent on services like Safari Books Online.

I love Safari Books Online. I used to have an extended trial account for a few months, and utilized it constantly. I have access to Books24×7, an alternative, less extensive service as well.

Safari Books is ideal when used as a reference. You have access to thousands of books from major publishers, so virtually any search will lead you to a few relevant volumes dealing with the subject you’re looking for. It’s also great for keeping up to date with technology, thanks to “Rough Cuts” which are books that haven’t been completed yet.

It’s an extremely valuable service and I would recommend it to anyone in a heart beat. However, there a few reasons why I still buy hard copies.

I spend long hours working and staring at the computer screen. A printed book is a chance to take a break at night, and let my eyes rest a little. I find it refreshing. And let’s face it, for extensive reading, paper is much easier to read from than the screen.

Likewise, when I’m holding a book or have it open on my desk, I’m in “book reading mode”, which makes it far easier to immerse myself in it. This means that I’m focused on the task and can proceed quickly. The only context switch that happens is between the book and the editor/shell, if it’s the kind of book that warrants typing along. If you are reading a book in a browser tab, it’s very easy to think, “I’ll just check my email for a second”, or introduce similar distractions. I’m sure I’m not alone in this respect.

When I buy a physical copy of a book, I feel psychologically more obliged to at least try to get through it. Online I experience a paradox of choice of sort. With hundreds of interesting books available there in front of me, I’m more inclined to excessively multitask, and end up checking out different books while I should still be reading the current one.

And let’s not forget that not all books are legally available online. I’ve found that many advanced computer science books are not yet available on Safari Books or Books24×7. For example, The Art of Computer Programming, Purely Functional Data Structures, Types and Programming Languages, Programming Pearls, and other worthy suggestions that were made in response to my first post, are all not available on Safari Books. As well, mathematical books that can be of use to the serious/discerning programmer are also not included (understandably).

Lastly, and I realize that this is a “vanity point” and perhaps the most irrational one on this list, I like to have a beautiful collection of books on my bookshelves. If I’m going to spend $xxx a year on books, I’d prefer to have something to show for, beside my newly acquired knowledge.

However, the sheer volume of free available content has slowed down the number of books I’ve purchased in the past few years. And I’m thinking about re-joining Safari Books Online nevertheless, as I see it as being complementary to printed books. The Safari Library option is somewhat expensive ($42.99 per month), but for the price of an extra printed book per month, I gain full access to a huge catalog of programming books and a growing list of “Rough Cuts”.

With the amount of free knowledge available, useful paid services, research papers, and relatively good deals on printed copies from Amazon, the real constraint remains time not money. But claiming that purchasing hard copies is obsolete or worse, stupid, is… well, asinine, in my opinion.

What’s your take? Do you think Safari Books Online is worth it? Do you still buy printed copies of your professional books? Do you even read programming books at all these days?

The hardest part was shortlisting only a few titles, out of a substantial number of books that interest me. This ruthless streamlining was not solely motivated by cost either. Time is by far the most non-negotiable constraint, and as pretty as certain books may look on my shelves, I’d rather get titles that I know I will reference often or read cover to cover.

Last night I finally placed my order on Amazon. Narrowing down my choices wasn’t easy, but I think I was able to get a lot of bang for my buck, so to speak. I’m sharing the list of books I ordered, and my rationale behind selecting them, in the hope that some readers will find this information useful. You’ll probably find one book at least that tickles your fancy.

1) Code: The Hidden Language of Computer Hardware and Software by Charles Petzold

Very high-level languages have major advantages, but they tend to conceal many details. As a result these low-level details are often forgotten, overlooked or no longer taught. I’m talking about gates, bit manipulation, etcetera. Ten years have passed since I last sat in a computer architecture class or programmed in the MIPS assembly language, so I see this book as a refresher about this sort of interesting details that lay between hardware and software.

2) Programming: Principles and Practice Using C++ by Bjarne Stroustrup

I’ve been meaning to get more serious about learning C++ for a while now. The fact that I chose this book may seem odd. After all, it’s a C++ book for CS 101. I’m fully aware that I won’t find many new concepts in it and that the pace will probably be very slow to me at time, as it’s aimed towards newcomers. I opted for this book, among other reasons, because it’s very recent and was written by Bjarne Stroustrup (C++’s creator) himself. It’s a modern overview of C++ today and should cover all the essentials of writing portable code with a slant towards real world work, including parts of the STL. I’m interested in revisiting well known concepts from the perspective of C++, and this title should work as a good introduction before I switch to The C++ Programming Language, Effective C++, More Effective C++, Exceptional C++, and other advanced books. Lastly, I chose it because a good friend suggested it to me.

3) Processing: A Programming Handbook for Visual Designers and Artists by Casey Reas

Processing is another language I’m interested in. The idea of creating fancy visualizations of data is very appealing to my statistical side. This is probably another “basic” book, but I wanted to have a detailed tutorial on the subject. It’s also a very beautiful book. (Remember that deep down we are all hedonists.)

4) Clean Code: A Handbook of Agile Software Craftsmanship by Robert C. Martin

I love “Uncle Bob”‘s writing style and this book is, according to many, a wonderful addition to any software engineer’s collection. Apparently it’s Code Complete meets Refactoring meets Test Driven Development: By Example, all wrapped up in a single book. As much as that’s possible, naturally.

5) The Little Schemer (4th Edition) by Daniel P. Friedman

This is the first little volume in the “The * Schemer” trilogy. I’ve heard great things about this unusual Q&A book that straddles the border of functional and logic programming. I’m not new to functional programming, but I’m certain that this book will be an eye-opener nevertheless. There should be plenty of fun exercises inside. If I enjoy it as much as I hope, I’ll also get The Seasoned Schemer and The Reasoned Schemer, down the line to bring my understanding to the next level.

6) Introduction to Algorithms, Third Edition by Thomas H. Cormen

I own the second edition of this book, but guess what? They just released a revised edition with updated content, new algorithms and it’s been expanded to take the world of multiple processors into account. If you are not familiar with this classic, don’t let the title mislead you, this is no “introduction”. It’s an excellent, rigorous tutorial and reference that every programmer should own.

7) Elements of Programming by by Alexander Stepanov

The toughest book of the lot. This newly released theory of computation book has incredible reviews. It should be a rigorous handbook of the mathematical foundations of programming. And at this price it’s a bargain, in my opinion. The examples are in C++, so I’ll quote part of the review by Bjarne Stroustrup.

“Elements” is a great book in that it can change the way you think about programming in fundamental ways: If you “get it” programming will never be the same again for you.

Reading “Elements” requires maturity both with mathematics and with software development. Even then it is so different from most books on programming that it can be hard going. The frequent comparisons of “Elements” to Knuth’s “The Art of Programming” is well earned.
— Bjarne Stroustrup

What are your thoughts on this list? I think I could have done a lot worse with my modest $250 budget. And as you can imagine, I’m pretty excited about their arrival and am looking forward to diving into them.

On a side note, this reminds me that I should start writing detailed reviews for the most interesting books I’ve read over the past few years, not just for Ruby books (recently updated) and Rails ones (to be updated soon).

Disclaimer: The links to Amazon have my referral. It’s a small contribution to this blog that won’t cost you a dime. If you are opposed to me making a few cents from my posts, feel free to select, copy and then paste the title that interests you into Google.

While at it, I also updated my About page and added a thumbnail of the cover of my book to the sidebar. I finished writing Ruby on Rails for Microsoft Developers a couple of months ago and am now waiting for Wrox to do their magic and get it into stores. The book should leave Wrox’s warehouse towards the end of this month and reach customers in early April. But I’ll talk about my book and the subject of writing a technical book more in future posts.

Programmers are not all that different. Cross-training in other languages and frameworks can only improve one’s overall mastery of the craft. When it comes to Ruby frameworks, the two most popular choices are Ruby on Rails and Merb. They’re often seen as being contenders, but this truly isn’t a zero-sum game; learning both is a very sensible move. They both enable you to write web applications in Ruby, and are somewhat similar, so learning one after you know the other shouldn’t be very challenging. In the many cases people learn Merb after they’ve had some experience with Rails, but either way, acquiring a solid grasp of both frameworks provides developers with extra flexibility. Often people who learn both, will end up mostly just using one or another, depending on their individual preferences. But it’s worth knowing them so as to be able to write both CRUD-style applications that fall within Rails’ solution space, and more complex, edge cases where Rails’ opinions will end up contending with yours.

Among the reasons to give Merb a chance, is its focus on performance, a smaller memory footprint and an extreme level of modularity, which enables you to pick and choose which components you’d like to use.

Merb is not as mature as Rails, of course, but it has reached version 1.0.x and with it developers can have greater confidence in a more stabilized API. Now is perhaps the best moment to get involved and learn more about this rising framework. Not surprisingly though, Merb finds itself in a similar spot to the one that Rails was in a couple of years ago (in terms of weakness of documentation when it comes to getting started). Thankfully, this point is being taken seriously and there’s been some major progress in terms of improving the documentation for Merb. Below are some useful links to get you started with Merb.

Merb has an official API documentation, a wiki, a google group, and a community site called Merbunity for news, projects and tutorials. The irc.freenode.net #merb channel is also a useful and welcoming spot. Furthermore, there is a Peepcode PDF draft called Meet Merb. If you want something even more substantial, on the book front there are several titles coming out in the near future. These include Merb in Action, The Merb Way, Beginning Merb and Merb: What You Need To Know. There is also an open source Merb book, whose development is led by Matt Aimonetti. It’s a work in progress, but probably a very good starting point, which just happens to have the added bonus of being free. And if your interested in Merb, don’t miss InfoQ’s interview with Yehuda Katz, who’s Merb’s lead developer and one of the sharpest guys we have in the Ruby community.

Finally, if you are a professional developer who wants to quickly progress with Merb and bring their skills to the next level, do not miss your chance to attend a three day intensive course on Merb, which is being offered by Yehuda and Matt in Phoenix, AZ between January 19 and 21 (2009). Registration has been open for two days already and 20 out of the 30 available spots have already been snapped up. The remaining seats won’t last more than a day or two, so if you are interested, don’t delay (sign up now and you’ll also benefit from an early registration price).

2009 is almost here, so why not take the opportunity to learn Merb this year?

The Contests

What I say below applies to US and Canada, as the contest is being held worldwide in 30 countries separately, and each of these may have different individual contests and prizes as well. In fact, the first thing you’ll see when you visit the xmlchallenge.com site should be a popup that prompts you to select your country.

For US/Canada there are 5 contests: Video, Gadget, Query, Porting and XML. The Video Contest consists of creating a funny/creative/cool video about XML, XQuery and/or DB2. The Gadget Contest is about developing a downloadable gadget/widget that leverages DB2. The Query Contest requires you to use XQuery to query a database and come up with the answer to five questions. The Ported Application Contest is all about porting an existing application to DB2 or creating a new one that uses DB2. And finally, the XML Contest asks you to build a useful, user-friendly XML application from scratch. The last two contests can be approached as a team or as an individual. The Query, Ported App and XML contests start today!

You don’t have to participate in all of them, of course. But by participating in any of these you gain points, and there are six badges that you can obtain: XML Challenger, XML Rookie, XML Whiz, XML Star, XML Master and XML Grand Master. I feel so nerdy reporting this. The XML Grand Masters will be enrolled in a draw for an additional prize.

The Prizes

Speaking of prizes, let’s see what goodies are up for grab. There will be a few give-aways just for participating. For example, the first 500 participants will receive an XML Challenge T-Shirt as well as a Rubick’s Cube. The first 1000 to complete the Quick Quiz during registration will also receive a free T-Shirt. But let’s move on to the more substantial prizes.

For the sake of awarding prizes, the contestants will be split in two groups, students and professional developers.

The Video Contest: The deadline is December 17, 2008 and a few selected winners will receive an 8GB iPod Video Nano (for both students and developers).

The Gadget Contest: The deadline is December 17, 2008 and the winning students grab Canon Powershot SD870 Cameras, while winning developers get 80GB Zunes.

The Query Contest: After you register, you’ll have 24 hours to submit your answers. The first 50 successful participants for each group (for a combined total of 100) will receive a 1GB USB key, while all the contestants with the right answers will be entered in a draw for a grand prize. This is a Playstation 3 40GB for the students, and a 32GB iPod Touch for the developers;

The Ported Application Contest: The deadline is January 31st, 2009. The winning team or individual amongst the students will receive an HD Pavilion HDX Notebook, while the winning developer will score a Lenovo IdeaPad U110. The second prize for both of the two groups will a Garmin nüvi GPS.

The XML Contest: The deadline is January 31st, 2009. The 1st prize for each group will be a high-end 17″ Alienware Laptop (two laptops will be awarded in total). The second prize for both groups will be a Nintendo Wii (again, two in total).

Finally, two lucky XML Grand Masters, one developer and one student, will receive a Bose Wave Radio II.

I hope you consider enrolling now and best of luck! If you need some help with getting started with DB2 Express-C, you can download the free e-book which is available in several languages. Oh, and finally we have an Italian version as well.

Promote this post

Hey, would you give me a hand in promoting this post? If you are in the US or Canada, and mention & link to this post from your blog, you’ll receive a free XML Challenge T-Shirt and a Rubick’s Cube as well. All you have to do is send me an email (to acangiano at gmail.com) with a link to your blog entry, as well as your shirt size and complete mailing address. Thank you!

Merb: A few days ago Merb 1.0 was released. Congratulations to Ezra Zygmuntowicz on this important milestone, the Merb community and Engine Yard (who finances the project). Merb 1.0 wasn’t even out yet when some people had already started commenting on the fracturing of the Ruby community that this new framework might bring with this, and the impact that this high visibility “competitor” might have on Rails. I believe that having more than one widely adopted web framework will only benefit the Ruby community. Furthermore, it’s important to remember that this is not a zero-sum game. Ruby programmers are perfectly capable of learning two frameworks and using one or the other, depending on the project at hand. This is particularly true if we consider that Merb, for all of its advantages – and disadvantages – when compared to Rails, is not totally different from its forerunner. If you are an expert Rails programmer, you should be able to become proficient in Merb in very little time. To help with this process, the Merb community needs to concentrate on the documentation now, given that the API is finally stable.

Rails Myths: David Heinemeier Hansson began a series of posts about Rails Myths. I like the idea of seeing common myths addressed straight from the horse’s mouth. Over the past two years, Rails has received quite a bit of backslash and old fashion FUD, so it’s important to set the record straight, whether the myths are entirely fabricated or if there is some element of truth to them. Whether you agree with David or not, it’s also nice to hear two sides of the same story. In fact, at the beginning of my book I debunk a few myths, just to set the record straight regarding what some readers may have heard surrounding the framework. It was a fun part to write.

My Book: Speaking of my book, Ruby on Rails for Microsoft Developers, I’m getting closer to the finish line. I’m about to complete Chapter 9 (out of eleven chapters). The initial schedule I was provided with has been extended slightly so that there will be sufficient time to properly review the content and ensure that it’s up to date with the final release of Rails 2.2. Some people wondered what the “Microsoft Developers” part means. Is it for people that work at Microsoft? Is it for .NET programmers? Is it for people who develop on Windows?

The truth is that “Microsoft Developers” is probably just a marketing term that Wrox selected as a catch-all for of the aforementioned categories of programmers. As an author I’m trying to serve all of them well, by providing a guide that sneaks in much of the Rails culture and softens the migration path by using an Operating System, and to a certain extent, tools that they’re already familiar with. In my opinion one of the major obstacles when switching to, or trying, Rails when coming from the Microsoft world, is the culture shock. The documentation and most books assume that you are familiar with *nix systems and tools, and this can be frustrating for those who are forced not only to learn a new language and framework, but also an entirely new set of tools. As it’s targeted at Microsoft developers, the book obviously makes quite a few references and comparisons to the .NET world, where they fit. This is done so that the many .NET programmers amongst the group of so called “Microsoft Developers” will find the book particularly useful. Yet the book remains generic enough so that it can be used by any programmer (particularly Windows users), even those without any knowledge of the Microsoft .NET Framework or ASP.NET.

Python books: While on the subject of books, I wanted to mention that the final version of the Pylons book is available online. Despite the much less fancy UI, the book pretty much does what the Django Book did in the past. And both are available in print as well (The Definitive Guide to Django: Web Development Done Right and The Definitive Guide to Pylons). Pylons is a Python web framework that can be viewed as a Ruby on Rails clone, in a far greater way than Django could ever be considered.

Another thing I want to mention is that I received a copy of Expert Python Programming. I haven’t gotten to far into it yet, but from what I’ve seen so far, things look good. I hope to be able to read it through, over a weekend in the near future and then provide a proper review. Stay tuned.

Language Popularity: If you take a look at the TIOBE Index, you’ll notice a few interesting things: Ruby has dropped two positions since last year, and it’s now the 11th most popular language in the world. This shouldn’t be cause for concern though, as shown by this Ruby graph. Python on the other hand is increasing in popularity and moved from the 7th to the 6th most popular language. Interestingly, according to the index (the results of which are educated guesses only), Python would seem to be more popular than C#. I find this to be true, in terms of online activity within an increasingly vibrant community, but in my opinion, the job market hasn’t caught up yet. In fact, at least in Toronto, when there’s a Python opening it’s pretty much an event that’s worthy of being discussed on the local Python mailing list. C# openings are much more common. This may be different in Silicon Valley, of course. It would also seem that Delphi has experienced a huge come back, moving from the 11th position last year to the 8th one this time around. It’s hard to imagine that Delphi has had a similar level of adoption as C# and thus has become more popular than Perl, JavaScript and Ruby. Delphi is a great solution for Win32 programming, but I don’t quite believe this overly optimistic outlook. And if this is the case, where are all the Delphi jobs and buzz?

DB2: This interview shows a few good reasons why even smaller and medium sized companies are increasingly adopting DB2. And while the video doesn’t mention it, IBM is coming out with an updated version of DB2 Express-C 9.5. This new version, 9.5.2 or 9.5 FixPack 2, is going to introduce exciting new features, including an engine for full text search.

The Great Ruby Shootout These days you hear a lot of talk about parallel programming. Intel promotes it and despite their bias, it’s plausible that parallel programming will become important as the CPU market heads towards an increasingly larger number of cores, as opposed to focusing on the frequency of said CPUs. In the world of Ruby, this translates into multiprocessing, as opposed to multithreading due to the infamous GIL (Global Interpreter Lock). This means that Ruby will most likely approach the problem similarly to how Python 2.6 did with the multiprocessing module, which is a process-based interface. The obvious exceptions are JRuby and IronRuby, which establish a 1 to 1 relationship between green threads and OS threads.

For the shootout, it would be interesting to see some multithreaded code, so as to get a better sense of how well JRuby and IronRuby compare to MRI and 1.9, when more cores are available. In fact, the long-promised shootout will be performed on a quad-core machine with 8GB of RAM. If Charles Nutter, John Lam, or any of their team members would like to contribute some programs that are able to take advantage of “native” multithreading, I’d be very happy to include them in the Ruby Benchmark Suite, to be used for my shootout.

The repository requires some love and refactoring, since it needs to be split in two types of benchmarks. The simpler one will evaluate the execution time minus the startup time, while the more advanced benchmark will also exclude the time required for parsing and loading modules, classes and methods in the AST. It would also be nice to test each program with variable input sizes and report these results accordingly. Right now I’m very busy with the book, but as I become more available, I’ll start working on this.

Finally, I want to point out a very interesting article about performance and UIs. Slow is indeed a very relative concept, and it’s important to understand how to analyze and respond to the user requirements when it comes to the responsiveness of an application as a user interacts with it.

Hardware: I finally bought a Trackball made by Logitech and the Microsoft Ergonomic Keyboard (Microsoft makes great hardware). I don’t have wrist problems, but I’d like to see how these two affect my extensive computer usage. I plan to report my experience as soon as I’ve had a chance to use these input devices for a while, since I know this is a topic that interests lots programmers (many of whom end up being victims of RSI, and some of the IRS ). I also bought a bad-ass color laser printer which is quite handy when you’re a programmer and you are writing a book. I’ll let you know how it goes. What I didn’t buy, but still think is awesome, is the Flip minoHD. It’s the equivalent of an iPod for the world of camcorders. $235 for a camcorder that’s so perfectly compact, and yet that can record in HD, is a pretty sweet deal. I’m considering it for Christmas, assuming it reaches Canada by then.