Advanced Ruby Studio

Back in July I attended the Advanced Ruby Studio in Reston, VA. At the time I had wanted to blog about it but my life suddenly became extremely busy and I left my blog to languish for several months. To rectify that, I’ve decided to write up this post providing an overview of the studio and my impressions. The instructors for the three day course were Dave Thomas and Chad Fowler, two elite Ruby programmers (and excellent teachers). While I wouldn’t consider every topic covered during the course advanced, I will say that there was a good mix of intermediate and advanced content (and some of the advanced stuff was really advanced!)

Day 1

  • Blocks, Procs, and Closures
  • Ruby Internals
  • Your Own Private Ruby
  • Design in a Dynamic Language
  • Types
  • Performance

Day 2

  • Metaprogramming
  • Creating Domain Specific Languages
  • Exotic Control Flow

Day 3

  • Library Organization
  • Distributed Programming
  • Debugging and Profiling
  • Ruby Extras

The first day we jumped right into blocks, procs, and closures. At first, I thought this would be primarily review for me, but Dave and Chad always provide those few extra tidbits which make it interesting. From there we delved into the Ruby source code and learned how to construct Ruby classes in C code and how to find our way around the Ruby source. “Your Own Private Ruby” covered how to build Ruby (with specific extensions) and how to manage multiple copies of Ruby on the same machine. There were so many goodies in the “Design in a Dynamic Language” portion of the day, I don’t want to ruin the experience for those who haven’t attended yet. The second day of the studio was my favorite, covering metaprogramming, DSLs, and control flow. There was so much material that it’s hard to do it justice in a short blog posting. The exercises/labs were integral to understanding the material and I’m glad the slides and source code were provided as they’ve turned out to be useful references to refer back to. The third day was the ‘choose your own adventure’ day where each of us voted on the topics for the day. Even though there seemed to be some interest in JRuby on the first day, that topic didn’t make the short list for the final day. Concurrency also fell by the way-side (though the slides provided contained more than enough material on Ruby threads). Distributed programming was largely review for me having played with DRb and the Rinda tuple space, though the discussion of multicast and the ease of dealing with binary protocol using pack/unpack was new and useful to me. The primary message regarding library organization is to follow the conventions set forth by Rails, though this was the portion of the class where we packaged our own gem and served it up to classmates. Debugging and profiling Ruby applications was partially review, having used benchmark, ruby-debug, and profiler. Yet, I had never thought to debug my Ruby applications using gdb even though I use it frequently at work to debug C/C++ applications. Mike and Nicole Clark really brought everything together. Their stewardship of the event made it truly remarkable (as they seem to do every time). Their goal is to ensure that every single attendee has a wonderful time and they appear to be willing to do whatever it takes to make it so. Next time you’re at one of their events be sure to thank them for their diligence. Overall, I found the course to be of tremendous value as it got me thinking about even more ways to use Ruby. The insight that Chad and Dave provided was integral to unlocking the reasoning behind the design of the language. As is true with all of the Pragmatic Studio offerings I’ve attended, this class reinvigorated me and left me energized to tackle more projects. For those who have never been to a Pragmatic Studio event before, one of the best alumni benefits is the mailing list you’re able to join afterwards — the signal to noise ratio is extremely high. Now, if only I could convince my employer to send me four or five times a year.