Screencasts

XMPP and Metaprogramming Screencasts

I've mentioned some nice screencasts I've found in the past. Well, I've been watching quite a few more lately and I've uncovered some more hits.

First, PeepCode has another excellent screencast on using XMPP with Ruby. This video explains what XMPP is and isn't, why it's important, and shows a good deal of information about how you can work with the protocol to accomplish some real world server to server or human communication tasks. You don't need any prior XMPP knowledge going into this one.

It's hard to overstate exactly how much PeepCode got right with this video. For example, I've seen quite a few screencasts now that byte off more than they can chew for a short video. That's not the case here. XMPP turns out to be perfectly bite sized in that a one hour video can serve as a strong introduction to pretty much all you need to know when using it. This has other advantages too. Since the creator isn't trying to squeeze too much content into too short of time, he can afford to drop some truly stellar related tips. In the case of the XMPP video these are what IM client to use when debugging, because it allows you to see the underlying protocol, and how to easily combine XMPP with DRb for fire-and-forget messaging. These extras really push this screencast over the top.

If you do any server to client communication, you need to watch this video.

For the other hit, we need to switch companies. My first experience with Pragamatic Screencasts was recently watching all of The Ruby Object Model and Metaprogramming series and I have to tell you that it's just fantastic.

Now if you are thinking, I use Ruby objects all the time and I do some metaprogramming too, do yourself a favor and keep reading. I said exactly that. In fact, I'm ashamed to admit that the series just never hit my radar until Dave Thomas gave me the episodes for free at a conference. Even then it took me months to actually sit down and grudgingly watch the first one. By the end of that one video I was hooked. I finished all seven of the current episodes by the end of the following day.

The first video alone is one of the best tours of the Ruby object model I've ever seen. It's on par with Ruby for Rails, in case you are familiar with that great book. The discussions of singleton/eigen/ghost classes and so-called "class methods" are excellent demystifications of formerly complex material. The explanation of how Ruby looks up method calls should also be required viewing for all Ruby programmers. I showed it to a student of mine and it lead us into an excellent discussion that really clarified some problem points we had run into in past lessons. All of that's just the first video!

The second video has some fantastic module coverage plus great details on lesser seen options, like doing prototype-based programming in Ruby. The third video shows off blocks, lambda(), define_method(), and even includes exercises you can try to compare your results with those given in the presentation. The fourth video is all about instance_eval() and class_eval() and recognizing when to use which.

The fifth video is a gold mine. If you are still at all skeptical, go watch this one video. I'm confident it will sell you on this series and then you can grab the other episodes.

In the fifth video, Dave Thomas builds a memoization helper using nine different metaprogramming techniques. We all know there's always different ways to build things, but here you actually get to see as many as Dave could think up. He talks a little about their strengths and weaknesses as he goes, so you can compare the uses. He also manages to drop amazing hints like how to rewrite methods without the tedious alias_method_chain() trick and how to use Class.new() to dynamically build classes. He will definitely wake you up and get you thinking!

The sixth and seventh videos dig into the hook methods Ruby provides. You'll see commonly used methods like included() and inherited(), plus some lesser known beauties like method_added(). The seventh video in particular is really in depth as Dave spends almost an hour digging into one metaprogramming application and iteratively addressing all of the issues that arise while trying to solve it. It's a solid example of real world programming.

Again, this is terrific coverage of everyday Ruby and beyond. If you enjoy my Ruby Voodoo series at all, I'm pretty confident you will love these screencasts.