Tom Purl’s Web Site

Release It!: Design and Deploy Production-Ready Software by Michael Nygard

My rating: 5 of 5 stars
I need to start by saying that this is one of the best technical books I have ever read. To me, it’s easily as enjoyable and useful as Code Complete, The Pragmatic Programmer, or The Mythical Man Month. If you’re a sysadmin, an architect, or a developer that works with medium-to-large-sized systems, then do the following:

1. Stop reading this post
2. Order this book from your library or buy it from The Pragmatic Programmer’s web site
3. Owe me a pint

What The Book Is Really About

Actually, there is one thing that I don’t like about this book, but it really has nothing to do with the book. The description of this book on the Pragmatic Programmer’s web site sucks. It’s vague, and it really gives the potential reader a tiny amount of insight into the book’s contents.

What it should have said is that this book contains *tons* of great information on designing, deploying, maintaining and improving medium-to-large-sized IT systems. It’s filled with patterns, anti-patterns, and general best practices that should be part of the shared lexicon of every developer, administrator, and system architect. Also, it does a good job of giving you enough information to be useful without boring you to death. And finally, it’s written very well and is a joy to read.

The Highlights

Thread Dumps & Garbage Collection Tuning

The internals of the Java Virtual Machine (JVM) have been a black box to me for the majority of my career in IT. Thankfully, this book has provided excellent examples of how you can troubleshoot and improve your system using tools that interrogate and manipulate a JVM at runtime.

For me, this was the most interesting and useful part of the book, and I am looking forward to seeing what can be gained by tuning and “poking at” the JVM’s that are in the system that I maintain.

Patterns and Anti-Patterns

It’s great to finally find a book that codifies some patterns that administrators and architects can use.

Transparency

I thought that I new a lot about monitoring and transparency before reading this book, but now I know better. I especially like the concept of a unified “OpsDB”, and I am eager to build something like this myself for the system that I maintain.

Integration Point Risks

I always knew that integration points (e.g. data feeds, databases, LDAP providers, etc.) added risk to you system, but the author does a great job calculating the actual risk. Also, he shows you many ways in which you can avoid brittle integration points.

Caveats

I have one warning about this book, but it’s half-hearted. This book is what I would all Java-centric. All of the case studies involve systems that are written in Java, and some of the sections will only apply directly to you if you are working with Java-based software.

But does that mean that you should avoid this book if you are working with Ruby, PHP, or .Net-based software? Absolutely not. Even though there are a few small sections of the book that won’t directly apply to your line of work, most of them will apply in an indirect way, regardless of your platform. And the other 94% of the book will directly apply to medium-to-large systems of every stripe.

View all my reviews >>

The Victorian Internet by Tom Standage

My rating: 3 of 5 stars
This book is a fascinating account of the history of the telegraph and how it changed the world. If you are a history and technology buff, you will definitely get a lot out of this book.

Please don’t be fooled by the title, however. This book does not make deep comparisons between the histories of the internet and the telegraph. A small chapter at the end of the book provides the only comparison between the two technologies.

Even with this flaw, this is a solid technical history book, and I really feel like I gained a lot of perspective.

View all my reviews >>

Rails Deployment: Production Configuration and Advanced Rails Tactics by Ezra Zygmuntowicz

My rating: 4 of 5 stars
Overall, this book had a lot of very good information, and it was very helpful to me as I deployed my first Ruby-On-Rails application into a “Production” environment.

Here’s the high points:

• Lots of good information on tools such as Capistrano, MySQL, Mongrel, Apache, and nginx.
• The authors clearly know what they are talking about.
• It’s helpful if you’re deploying a “toy” application (like I am) and if you’re deploying a large, clustered application.
• It doesn’t assume that you’re already an expert on either Web app deployment or Ruby-On-Rails.

Here are some of the things that could be better:

• This book was published over a year ago, and it already feels out-of-date. For example, there isn’t one mention of Phusion Passenger, even though this tool seems to be the new standard app server for Ruby-On-Rails in Production environments.
• This is very subjective, but I feel like the information could have been organized a little better. I felt as if the author jumped around a bit sometimes.
• Also, some of the passages were a little difficult to read due to their incorrect sentence structure. My writing isn’t perfect either, but I believe that the editor should have fixed more of these mistakes.

If you’re deploying a Ruby app in any setting, then this is a good book to get. I just don’t know if I would actually buy it.

View all my reviews >>

Agile Web Development with Rails: A Pragmatic Guide by Dave Thomas

My rating: 4 of 5 stars
In general, this book does a fairly good job of helping you create a rails-based application. Part 3 includes some great in-depth information on the topics that are briefly discussed in Part 2.

I only have one real gripe about this book. It packs in lots of topics (e.g. db theory, AJAX, unit testing, security, deployment), but it doesn’t really tell you much about them. Therefore, if you have a problem, then good luck figuring it out using the content in the book.

A good example is the final chapter which covers deployment. The chapter devotes only a few small paragraphs to configuring Apache for passenger. To me, this section was completely useless unless you were already an expert with Apache configuration. I ended that chapter with a broken Apache server and no resources (from the book) to begin fixing it.

Another problem that I had with that chapter is that it really didn’t follow the pattern that the chapters in Part 2 used. In those chapters, the authors would should you how to do something relatively small, show you how to test it, and then provide some troubleshooting information if the task was particularly complex. The deployment chapter gave you a *very brief and generalized* tutorial in each section, and then just assumed that everything went perfectly. It didn’t show you how to test anything, and it didn’t help you troubleshoot any possible problems.

Don’t get me wrong. I know that no book will provide all of the information that I would ever need about a subject, and thank goodness for the internet in these situations. I was just hoping that all of the chapters in a book that I actually bought would provide better information than some person’s blog.

So in general, I guess I would have to say that this was a very good book with some bad chapters that were tacked-on at the end.

View all my reviews >>

My Nokia 6101 just died after 2.5 years of faithful, inexpensive service, so I was in the market for a new phone in a hurry. When I originally bought this phone, I hoped that Google would have revolutionized the cell phone industry in America, making smart phone service more flexible and inexpensive. Well, the changes that I want still haven’t materialized yet, so I went looking for a new phone that was as similar as possible to my old trusty Nokia.

Another requirement that I had was that I wanted the phone to work with the T-Mobile pre-paid service. I’m actually a really big fan of T-Mobile’s price and network coverage

The closest thing I could find was the Nokia 2760. On occasion, it would be available on th T-Mobile web site, but it couldn’t be found when my phone died. I therefore checked the Walgreens and Radio Shack stores in my town until I found one at “The Shack” (as the employees seem to be forced to call it). It was $40 plus tax, which means that I won’t lose any sleep if my daughter tries to flush it down the toilet.

To “activate” the phone, I simply took the SIM card out of my old phone and placed it in the new one. 20 seconds later, I was able to receive calls using my mobile number. I didn’t have to contact T-Mobile even once, and my old “plan” seems to work with the new phone very well.

The biggest questions that I had when I bought this phone were “what was missing from my old phone” and “what did I need to buy”. Here’s the results:

Missing

• This phone doesn’t have any buttons on the outside like my old one did. I really liked having a volume and F-you button on the outside of the phone. The 2760 forces you to open the button to silence an incoming call, and I have yet to figure out how to adjust call volume without 5 button clicks.
• I can’t record video on this phone like I could with the old phone. This isn’t really a bad thing, however, since the old phone’s videos were just god-awful.
• Apparently, Nokia phones no longer come with a ringtone that sounds like a phone ringing. And I guess noticing that makes me some type of old fogie who can’t figure out why stores no longer carry Lawrence Welk LP’s. I tried to buy one from T-Mobile’s ringtone shop, but I couldn’t find one.
• The 2760 doesn’t have a little antenna nub sticking out of the top.

Different & New

• Bluetooth! I know I am the last person in America to buy a bluetooth-enabled phone, but I’m really enjoying it so far. On my 6101, I actually purchased the compatible serial cable from Nokia, which was around $50 if I remember correctly. I hate that I have to basically throw away that investment, but I am loving how easy it is to use bluetooth. Also, I purchased this bluetooth adapter from Newegg for $15, and it works very well on both XP and Ubuntu 9.04.
• The software interface has changed a little bit, but it’s nothing too revolutionary. If you’re used to your old phone’s interface, then this one should be very intuitive.
• I can now add MP3 ringtones from my MP3 collection. Sweet! Now I just need to find an MP3 of a phone ringing
• I can log into Gmail with this phone, which I couldn’t do on my old phone for some reason. That’s nice, but the interface and network speed are nothing to write home about.
• The battery model changed. My old phone’s battery model was BL-4C, and my new phone’s battery model is BL-4B. I don’t yet know if the two models are interchangeable, but I doubt they are.

What Hasn’t Changed

• The wall AC adapter looks like it’s identical. Based on that, it doesn’t look like I need to buy another car charger.
• The photo quality appears to be identical.
• The phone still has a ridiculously small amount of storage. I think the official amount is 11 MB. Oh well, I already have a digital camera and an MP3 player, so I guess I don’t need a phone that does all of that too.

Conclusion

If you like little Nokia flip phones, then this one seems to be as good as its predecessors. I’m pretty happy with it so far, and it’s hard to beat the price.

I apologize in advance for the corny, rhyming title

I’ve been using an Asus EEE PC 900 netbook for about a year now, and have used it mostly for light word processing and web browsing. I also have a MythTV server running in my basement on an old Duron-based system. I can do almost all of my personal daily work on the EEE PC, but when I need to do anything MythTV-related, I’m forced to switch machines.

This can be a pain, so I decided to try running the “frontend” for MythTV on my EEE PC. To my surprise, everything is working very well. It only took me about 5 minutes to install and configure the frontend software, and after that, I was able to do the following on my netbook:

• Watch live tv
• Watch recorded shows
• Edit shows (i.e. cut out commercials)

And the best part is that it’s all working very well over my wireless G network. Your results may vary, but at least it’s nice to know that this configuration works for some people.

Here’s some more information about my setup in case you want to try this yourself:

• My netbook has a 900 Mhz processor, 1 GB of RAM, and a solid-state hard drive
• I am using the integrated graphics card made by Intel. Apparently, it uses the i810 chipset.
• I am serving up standard-definition television

And finally, a few caveats:

• I don’t know the limits of the video card that comes with my netbook. The highest resolution that I’ve tried is 1280×1024 on a 17″ monitor, and it looked pretty good. I have no idea how it would look at a higher resolution on a more regular-sized TV.
• I have heard that his netbook simply can’t display HD recordings. I’m not an expert on this type of thing (since I don’t have an HD TV or monitor), however.
• As with any hardware purchase, don’t buy anything based solely on a blog post or product review. This system worked well for me, but it could work terribly for you for a variety of reasons. Do a decent amount of research before you spend any money. For example, the MythTV wiki and mailing list are great places to do exactly this type of research.

It’s unlike me to upgrade my systems very often since it can take so much time, but I was moved recently to upgrade both my “server” (to Ubuntu 9.04) and my EEE PC 900 (to Easy Peasy 1.5). In general, I’m very impressed with how much better Linux-on-the-desktop gets every 6 months, and I look forward to at least another 8 years as a happy desktop Linux user.

One of the great things about Ubuntu is that it really is just painless to set up some pretty sophisticated servers. For example, I use my Ubuntu server to record television shows using MythTv, which can be very difficult to install. However, using the Ubuntu packages, I was able to get my system up-and-running in less than 10 minutes.

I do have one very small criticism of Ubuntu, and it’s that they keep making it harder and harder to install ffmpeg from source. The “stock” version of ffmpeg that comes with Ubuntu can’t do a lot of cool things like convert videos to the H264 format, so one of the first things that I usually do after installing Ubuntu is compile a more robust version of that application. Well, the process I used to compile it in 8.04 definitely did not work with 9.04 for some strange reason. Thank goodness that I found this tutorial, which made things very simple.

One really great thing about the 1.5 version of Easy Peasy is that I can now use some Compiz effects with my EEE PC 900. Previous versions of Easy Peasy didn’t even allow me to turn Compiz on. Hooray for tons tap-dancing sprites on my screen!

Here are some of the resources that I used to set up my Ubuntu 9.04 and Easy Peasy 1.5 systems. Maybe someone else will find them to be useful:

• Installing ffmpeg from source
• NFS Server & Client HOWTO

Snapfish is one of those web sites that I use a lot even though I hate it because it’s favored by most of my family.  It’s interface seems to favor people who only use computers when they have to.  Also, it doesn’t give you many sharing options compared photo sites such as Picasa Web, Flickr, or Photo Bucket.

The number 1 reason I don’t like Snapfish, however, is that they don’t have a decent bulk-uploaded that works on Linux.  The one on Windows works very well, but since I’m in a Windows-free home, that’s not an option.  You can upload up to 10 photos at a time after entering the path for each photo, but this is tedious and slow.  For example, I wanted to upload about 45 pictures the other night, and it took me nearly 3 hours.

The good news is that I finally discovered a new way to easily upload more than 10 photos to Snapfish.  Picasa 3.0 for Linux allows you to upload your photos to 14 different sites, including Snapfish.  You simply choose the photos you want to upload using the Picasa application (the fat-client version, not the Picasa Web version), and then click on the Shop button at the bottom of the screen.  Then simply choose your favorite photo developer from the list, log on, and Picasa will start uploading your photos.  Sweet!

A few other nice things about the latest version of Picasa for Linux:

• There are installers for RPM-based distributions (like Red Hat and SuSE), Debian, and Ubuntu.  I’m using Ubuntu 7.10 (which makes me behind by 2 major versions), and it installed quickly and easily.
• Picasa also allows you to upload to Walgreens and RitzPix.  There are the only other photo developers that I use in addition to Snapfish, and I hate their native upload interfaces on Linux, so this is a nice bonus.

Even if you wouldn’t dream of using Picasa to manage your photos for some reason, if you use Linux and have ever complained about uploading your photos, you need to check it out.  It’s worth the space on your hard drive, even if you’re just using it as a glorified photo uploader.

Update (8/26/09):  Two strange things happened since I wrote this article.  First, uploading to Snapfish from Picasa 3 seems to be broken.  Second, if you have Flash 10 installed on your Linux machine, you can now bulk-upload photos to Snapfish using the Snapfish web site.

Update (8/8/09): When I was originally comparing Jruby & Groovy, I was under the impression that Jruby was a beta-quality product, and its cryptic error messages seemed to prove this point.  After a bit more research, I learned that Jruby is a robust and high-quality Ruby implementation and that all dynamic languages can give you cryptic errors on occasion.  Many thanks to the knowledgeable Jruby and Groovy developers who set me straight.

Background

I’m a middleware systems administrator for a living, and I often find that I need to write a script that has to interact with proprietary Java libraries. In the past, this meant writing a small Java program that would use the proprietary libraries, and then wrapping that program in a small shell script. This process was OK, but it did have its warts. For example, Java is a fairly verbose language. Going through all of the syntactic hoops just to write a simple program can be tedious.

A little over a year ago, I then discovered Groovy and Jruby. Both languages were very elegant, and I could see how they could both boost my scripting productivity dramatically. I therefore compared both languages for my scripting tasks, and, in the end, I determined that Groovy was just a better language. Here’s part of my rationale:

• A More Stable Interpreter – Jruby would often give extremely cryptic errors when you made a mistake, while Groovy did a much better job of pointing out any problems.
• A Compiler – At the time, Groovy had a compiler (groovyc) that use could use to compile your scripts into bytecode. This tool made it much easier for me to deploy Groovy code in my environment. Jruby has since introduced a similar tool, but it didn’t exist during my initial evaluation.

Now I’m on a new project, and we need to write a bunch of administrative scripts in a hurry. We have the same requirements as my old project, but just before I could dive into my Groovy interpreter, I found out that a lot of the Java developers on my team were ga-ga for Ruby. I therefore decided that it would be nice to evaluate both languages again, one year later. If Jruby is nearly as stable as Groovy for my needs, then it might be a good idea to start writing my scripts with it.

Evaluation

Before I could start my evaluation, I thought it might be a good idea to re-acquaint myself with Ruby. I read “Everyday Scripting With Ruby” a little over six months ago and thought that it was an excellent tutorial on both Ruby and agile scripting. I therefore decided to try running some of the examples in that book with Jruby to bring myself back up-to-speed.

In “Everyday Scripting With Ruby”, the first chapter encourages you to enter invalid code into irb, which is the Ruby interactive interpreter. This exercise shows you how to read the error messages returned by irb. Here’s the line of code:

 100 -= 43

And here’s what the latest-and-greatest (1.1.5) version of jirb (Jruby’s version of irb) returns when you enter that:

 irb(main):001:0> 100 -= 43
 SyntaxError: (irb):2: , unexpected tOP_ASGN

         from E:/apps/jruby-1.1.5/lib/ruby/1.8/irb/workspace.rb:81:in `irb_binding'
         from E:/apps/jruby-1.1.5/lib/ruby/1.8/irb/workspace.rb:53:in `eval'
         from E:/apps/jruby-1.1.5/lib/ruby/1.8/irb/workspace.rb:81:in `evaluate'
         from E:/apps/jruby-1.1.5/lib/ruby/1.8/irb/context.rb:219:in `evaluate'
         from E:/apps/jruby-1.1.5/lib/ruby/1.8/irb.rb:150:in `eval_input'
         from E:/apps/jruby-1.1.5/lib/ruby/1.8/irb.rb:259:in `signal_status'
         from E:/apps/jruby-1.1.5/lib/ruby/1.8/irb.rb:147:in `eval_input'
         from E:/apps/jruby-1.1.5/lib/ruby/1.8/irb/ruby-lex.rb:244:in `each_top_level_statement'
         from E:/apps/jruby-1.1.5/lib/ruby/1.8/irb/ruby-lex.rb:230:in `loop'
         from E:/apps/jruby-1.1.5/lib/ruby/1.8/irb/ruby-lex.rb:230:in `each_top_level_statement'
         from E:/apps/jruby-1.1.5/lib/ruby/1.8/irb/ruby-lex.rb:229:in `catch'
         from E:/apps/jruby-1.1.5/lib/ruby/1.8/irb/ruby-lex.rb:229:in `each_top_level_statement'
         from E:/apps/jruby-1.1.5/lib/ruby/1.8/irb.rb:146:in `eval_input'
         from E:/apps/jruby-1.1.5/lib/ruby/1.8/irb.rb:70:in `start'
         from E:/apps/jruby-1.1.5/lib/ruby/1.8/irb.rb:69:in `catch'
         from E:/apps/jruby-1.1.5/lib/ruby/1.8/irb.rb:69:in `start'
         from E:\apps\jruby-1.1.5\bin\jirb:19Maybe IRB bug!!

Yikes. I’ve been reading Java stack traces for seven years, but I really have no idea what this error message is telling me. If I honestly thought that line of code should work, or was tired and trying to meet a deadline, this stack trace would be anything but helpful to me.

Just to compare things a bit, I tried to same line of code in the 1.5.6 version of groovysh, which is the interactive interpreter for Groovy:

 groovy:000> 100 -= 43
 ERROR org.codehaus.groovy.control.MultipleCompilationErrorsException: startup failed, groovysh_evaluate: 2:
 [100] is a constant expression, but it should be a variable expression at line:
 2 column: 5. File: groovysh_evaluate @ line 2, column 5.
 1 error

Ok, still a little confusing, but much easier to follow. Basically, it’s telling me that “100″ should be a variable of some type instead of a literal. That makes sense.

I thought this might be an anomaly, and I wanted to give Jruby another shot, so I tried executing the next “broken” line of code from the book in both jirb and groovysh:

 (1 + 3) * 2 + 1)

First, let’s try it in Jruby:

 irb(main):002:0> (1 + 3) * 2 + 1)
 SyntaxError: (irb):3: , unexpected tRPAREN

         from E:/apps/jruby-1.1.5/lib/ruby/1.8/irb/workspace.rb:81:in `irb_binding'
         from E:/apps/jruby-1.1.5/lib/ruby/1.8/irb/workspace.rb:53:in `eval'
         from E:/apps/jruby-1.1.5/lib/ruby/1.8/irb/workspace.rb:81:in `evaluate'
         from E:/apps/jruby-1.1.5/lib/ruby/1.8/irb/context.rb:219:in `evaluate'
         from E:/apps/jruby-1.1.5/lib/ruby/1.8/irb.rb:150:in `eval_input'
         from E:/apps/jruby-1.1.5/lib/ruby/1.8/irb.rb:259:in `signal_status'
         from E:/apps/jruby-1.1.5/lib/ruby/1.8/irb.rb:147:in `eval_input'
         from E:/apps/jruby-1.1.5/lib/ruby/1.8/irb/ruby-lex.rb:244:in `each_top_level_statement'
         from E:/apps/jruby-1.1.5/lib/ruby/1.8/irb/ruby-lex.rb:230:in `loop'
         from E:/apps/jruby-1.1.5/lib/ruby/1.8/irb/ruby-lex.rb:230:in `each_top_level_statement'
         from E:/apps/jruby-1.1.5/lib/ruby/1.8/irb/ruby-lex.rb:229:in `catch'
         from E:/apps/jruby-1.1.5/lib/ruby/1.8/irb/ruby-lex.rb:229:in `each_top_level_statement'
         from E:/apps/jruby-1.1.5/lib/ruby/1.8/irb.rb:146:in `eval_input'
         from E:/apps/jruby-1.1.5/lib/ruby/1.8/irb.rb:70:in `start'
         from E:/apps/jruby-1.1.5/lib/ruby/1.8/irb.rb:69:in `catch'
         from E:/apps/jruby-1.1.5/lib/ruby/1.8/irb.rb:69:in `start'
         from E:\apps\jruby-1.1.5\bin\jirb:19Maybe IRB bug!!

Ok, again, this is complete giberish. What the heck’s a tRPAREN? Ok, now let’s try it using groovysh:

 groovy:000> (1 + 3) * 2 + 1)
 ERROR org.codehaus.groovy.control.MultipleCompilationErrorsException: startup failed,
 groovysh_parse: 1: unexpected token: ) @ line 1, column 16.
     (1 + 3) * 2 + 1)
                    ^

Ok, this is exactly what I hoped to see. A nice, clear message telling me what I forgot and what it is associated with.

Shortest. Evaluation. Ever

You may not be saying that this is a weird way to evaluate a language. Well, it wasn’t my plan to evaluate Jruby by looking at its error messages, but it was all that I guess I needed. Here’s why error message quality is important to me:

1. Based on my experiences with numerous up-and-coming scripting languages, the quality of the error messages is proportional to the quality of the interpreter. If this assumption is true in this case, then the Groovy interpreter still appears to be more mature than the Jruby interpreter.
2. Other programmers won’t know what to do when they see one of the Jruby stack traces. Even if I was able to train myself to read the Jruby stack traces, I doubt that my co-workers would have the time or inclination to follow suit.

So, once again, when it comes to my unusual needs, Groovy wins the battle of stability and ease-of-use. Before I end this post, however, I would like to say a few good things about Jruby so that I don’t appear to be partisan:

• I’m really happy that Jruby finally has a tool that will compile your .rb files into .class files. This will make it much easier for me to deploy Jruby applications in my environment some day.
• Jruby seems to be improving at a rapid pace, and it has a lot of support from companies such as Sun. I think that it will be stable enough for my needs within a year or so.

I noodled around with my MVP/MVPMC setup a little bit more, and discovered the following:

1. Live-TV with my MythTV backend actually works pretty well. I just needed to fix my timezone settings.
2. VLC transcoding, which allows me to view Xvid AVI’s using MVP, is a pretty CPU-intensive process. The default video quality level (labled “DVD”) used about 95% of the CPU cycles of my 1.6 Ghz Sempron 3100+. I ended up using the “SVCD” video quality level, which is still pretty good, and only uses about 65% of my CPU cycles.

That’s it for now. Soon, I hope to have everything set up properly so I can share some of the details that might matter to someone considering the MVP, such as the following:

• network topology
• configuration
• total costs