Gray Soft / Screencasts

Getting Ready for Ruby 1.9

2014-04-18T19:58:22Z

We've all been waiting for Ruby 1.9 to reach maturity for some time now. We've complained about things like Ruby's speed and weak character encoding support. We knew 1.9 could improve things, but it brings pretty big changes and a lot of Ruby 1.8 code needs updating before it can really be used there. For these and other reasons, the official production release came and went while most of us have stuck with 1.8 for our day to day needs.

I think we're reaching the tipping point though. Rails runs on 1.9 now and many other libraries are beginning to become compatible. We may not yet have the full range of 1.8 goodies available on the new platform, but many of the staples are moving over and it's looking like we can now do some serious work there.

Which means it's finally time for us to learn this 1.9 stuff.

There are several good sources of Ruby 1.9 information now, so you have choices. I'm going to tell you about three I like. Be warned, this is a super biased list, but I really hope it will be helpful to others.

My first recommendation is based on simple math: watch the Ruby 1.9 envycasts. It costs $16 and eats about an hour and fifteen minutes of your time. However, it pays you back with covering about 80% of what you need to know about Ruby 1.9. That's absurdly cheap, if you ask me.

These two screencasts are quite well done. You are in the very capable hands of host David A. Black, as he guides you through syntax changes, updates to the core collection classes of Hash, Array, String, and Enumerable, plus several new features including the adoption of Enumerator into the core, block local variables, and more. It's a content packed hour, for sure. It also includes the best description of the multiple assignment changes in Ruby 1.9 I have yet encountered.

Of course, nothing is perfect. I can add a few minor complaints about this series. First, David sometimes mentions syntax that has been removed without covering alternatives. For example, he mentions that : is no longer a valid way to jam an if or case condition on the same line with the code to execute when it matches, but he fails to mention that then still works for the same use. Similarly, he tells you that you can no longer build a Hash with {1, 2, 3, 4} (note the commas instead of using the arrow operator), but he doesn't mention Hash[1, 2, 3, 4]. That's unfortunate to me since the latter method has a nice upgrade in Ruby 1.9 and will now accept associative Array arguments: Hash[[[1, 2], [3, 4]]]. David is also careful to avoid some of the bigger new topics like Fibers, the Oniguruma regular expression engine, and most of the m17n functionality. That's pretty much a given due to the scale of his offering, and he freely admits that, but it does mean this isn't going to turn out to be the only 1.9 resource you will need. Finally, the videos are missing the excellent chapter headings that I've found so useful in using Peepcode and Pragmatic Screencasts as reference material. It's important to stress that these are all minor issues and both videos are very worth a watch.

At the risk of being called a traditionalist, my second recommendation is going to be the classic advice Rubyists tend to give: grab a copy of the new Pickaxe. There are some other options for a Ruby reference now and they are good. However, the Pickaxe is still the best choice, in my opinion. There's no other single source that provides an introduction to the language, all 1.9 syntax changes, details about Fibers and Oniguruma, new methods from the popular Object#tap() to the lesser known Process::daemon(), and all the cool additions to the standard library like ripper, json, or even just the improvements to shellwords. Its m17n coverage isn't quite as in-depth as mine, but it's very serviceable and probably a lot less intimidating to the casual reader. The Pickaxe really is one stop shopping and that's why I can't live without it.

For my final suggestion, I'll go with something fun: come learn Ruby 1.9 in an all-day workshop run by Dana and myself at Lone Star Ruby Conference 2009! I ran an I/O training at last year's conference which turned out great in spite of all my first time trainer mistakes. I've used what I learned there to plan a much better session for this year. That includes bringing Dana on board as my partner, since she has years of experience doing these trainings. Pat Eyler recently interviewed us about our workshop, so check that out for more details on what we have planned. You can even stay for the rest of LSRC!

Whatever path you choose, it's time to start getting up to speed on Ruby 1.9. If nothing else, install it along side your 1.8 interpreter and start trying things out in it. Start getting familiar with it and see what it's still lacking for your personal needs, if anything. The sooner we complete this transition, the better things will be for all of us.

XMPP and Metaprogramming Screencasts

2014-04-17T18:53:28Z

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.

Getting Git Thanks to PeepCode

2014-04-11T14:40:06Z

It's pretty clear that Git has landed. More and more projects are migrating to Git for their version control needs and developers have another system we need to get up to speed on.

I'm usually a traditional dead-tree book learner, but this time I decided to try the PeepCode approach. I had heard good things about them and I can now tell you that reputation is well deserved.

PeepCode has two resources available for those wanting to learn more about Git. First, there is a one hour screencast called Git covering everything from installing through basic usage. There's also a newer 120 page PDF book called Git Internals, that ships with some different screencast material. You can purchase either product for $9, which really is a steal in my opinion. Both are well done, but let me break down their strengths for you below.

The original screencast is a great resource for the developer who wants to get up to speed on Git in a hurry. You just watch for an hour, perhaps try a few examples as you go, and you should come out the other side with basic Git usage skills. An added bonus is that the screencast covers Git's Subversion integration which is a topic you don't want to miss, but it's sadly missing in the PDF book. It also has some good tips on configuring the gitk browser under Mac OS X.

The downside of the screencast is that it will probably leave you thinking Git is just an alternative implementation of Subversion if you don't know any better. It did for me. Unfortunately, that's pretty far from the truth and understanding that is really the key to Git enlightenment. That's where the PDF book comes in.

The Git Internals PDF begins with a lengthy explanation of how Git is really nothing like Subversion. You could be forgiven for thinking this is a pretty big waste of space for developers who would prefer to get right too using Git, at least until you read the first few pages. This section is easily the reason to get the book as it will make you really understand why we should all be learning Git as well as helping you understand why the Git commands work a little differently than other version control systems you may be use to. This section is pure gold and it's importance cannot be overstated.

Beyond that, the book includes at least as much basic usage as the screencast and more in depth coverage of several topics. In addition, the PDF books ships with over an hour of screencast coverage mirroring the usage examples in the book. (These same screencasts are now also available freely as the first nine episodes of the author's GitCasts series, but you'll get them in higher quality with the book.) This slightly exceeds the content of the original screencast, so you get more bang for your buck here. I found that watching a screencast and then reading the prose coverage made a nice one-two punch that helped me to absorb what I was learning. The book also has a little coverage of GitHub, which is a wonderful resource for Git users. It will take you a few more hours to get through the book and its screencasts, but it's time well spent that should pay you back during day to day Git usage.

Since this was my first Peepcode experience, I had no idea what to expect in terms of quality. I can now tell you that it's pretty top notch. The screencasts are large, high quality movies. They have a great table of contents so you can jump right to a section you want to reference with the flick of a popup menu. The PDF book was also well produced and sized perfectly for onscreen reading. My eyes really appreciated that.

Both the screencasts and the book have some minor formatting issues. The screencast presenters clear the screen frequently as they go, which is generally a plus as you don't have hunt through a terminal full of content to find a new topic. It does require you to be quick with that spacebar to pause the movie though, if you would like a chance to follow along by feeding the command into your own terminal. In a couple of cases (configuration settings stick out in my mind), the descriptions seemed to continue on after the screen had been cleared, so I didn't know I wanted to copy the command in time to save myself some rewinding.

The book's main issue is that wrapping can be a little abrupt. The only place this really becomes a nuisance is with shell commands which are sometimes split over multiple lines with no visual indication that the content continues from the previous line. Again, these are minor and infrequent annoyances that don't drag down the overall experience too much.

It's hard to pick a favorite between these two great ways to learn some Git, but the explanation of how Git works in Git Internals is the must-read that tips the scales, in my opinion. If you can spare the extra time, go for the book. Don't forget to look into the Subversion integration built into Git though, as it's one of the great topics the book doesn't include. Or you can just grab both the screencast and the book for cheaper than most other technical manuals on your shelf.