PragDave

So I've been doing some music...

A while back, I was asked during an interview what I'd do if I had three months off. I said I'd take piano lessons.

Well, my wife read that and very sweetly got me some. And then reality hit home. I really do have totally uncoordinated hands. I try to play, but I'm getting nowhere.

At the same time, I still enjoy noodling around with music. So my piano teacher (in a move motivated by self-preservation, no doubt) suggested we should look at composition instead. And I've been having a whole bunch of fun ever since.

But then Chad Fowler reminds me that the test is having it heard, which is kind of scary. But here's my first piece. Be gentle...

(Update: people asked for the transcription: it's here. Some of the pedal marks are screwy: I'm using Encore, and it seems to move them around every time I save. I might well end up going back to Sibelius. Forgive any amateur mistakes.)

New lambda syntax in Ruby 1.9

I'm slowly getting used to the new -> way of specifying lambdas in Ruby 1.9. I still feel that, as a notation, it could be clearer. (I'd personally like just plain backslash, because that looks pretty close to a real lambda character, but that's not going to happen.) But having punctuation, rather than the word lambda, makes a surprising difference to the way my eyes read code.

For example, you could write a method that acts like a while loop.

def my_while(cond, &body)
  while cond.call
    body.call
  end
end   

In Ruby 1.8  and 1.9, you could call this as

a = 0
my_while lambda { a < 5 } do
   puts a
   a += 1
end

But my brain finds that seriously hard to scan. The Ruby 1.9 -> syntax makes it slightly (just slightly, mind you) better:

a = 0
my_while  -> { a < 5 }  do
   puts a
   a += 1
end

I suspect this is just a question of time. In a year or so, we'll parse the -> syntax in our heads without thinking twice. Once it does become natural, I suspect we'll find all sorts of new uses for procs.

Code in Presentations, Part II

OK, enough people asked, so...

http://github.com/pragdave/codex/tree/master

Every good relationship starts by establishing some basic ground rules. Here's ours: you're on your own. Totally, bleakly, and emptily on your own. No support. No requests for enhancements. No cards on your birthday. And I want to continue to see other developers.

But I will consider patches. In particular splitting it up so it can be installed as a Gem would be really nice. You'd probably need some kind of generator to create a new slide show. I'd guess this would contain just a Rakefile, a slides/ directory and an html/ directory.

Enjoy.

Zachary Got His Black Belt Today

Zachary has been studying karate for almost 5 years now. About 2 months ago he got cleared to test for his black belt. Since then, he's been in intense training, leading up to two consecutive weekends of testing. Last week was the formal stuff—a verbal presentation and his kata. This weekend was the fighting part. He had to go through a set of eight self-defenses he'd created, then do some grappling. The session finished with 15 consecutive 2 minute sparring sessions with a mixture of classmates and black belts, with a 30 second break between each, topped of with a no-holds sparing session with an instructor, followed by a session of two-on-one sparring. It's been a couple of hours, and I think all of our heart rates are all still elevated.

He has worked so incredibly hard for this. I'm so proud of him.

Now I have to work out how to live with a teenage son who is both bigger than me and formally trained in martial arts :)

Our take on presenting code

Back in March, Jim Weirich posted some notes on a clever technique for getting code into Keynote presentations. It struck a chord with me, because I've been suffering the same problem for a long time now. Eventually, the pain of putting together the Studio content with Mike Clark and Chad Fowler drove me to find a solution. (The pain wasn't working with Mike and Chad—it was creating and keeping up to date many hundreds of slides, most of which contained code.)

The solution we went with was based on the way we do code in the Bookshelf books. Rather than embedding the code in the slides, we write regular old programs. Then, in the slide material, we reference the source file (and optionally say which section of that source file), and the appropriate code gets dragged into the slide, syntax highlighted, and hyperlinked back to our editor. Here's how it works.

Create Your Material

We've given up using Keynote and Powerpoint. They're a pain with version control, and they make it easy to fall into the eye-candy trap, favoring glitz over content. Instead, we create our material is plain text files using Textile markup. Typically we use one file per major topic, and the use an index file to bring all these individual files together into a single overall presentation/

Within the material, we can include material from external files using the :code directive.

Here's the source for an individual slide:

h1. const_missing
Correctly handles nested modules
:code code/meta/const_missing.rb

and here's what appears on the screen:

The code gets inserted onto the slide and is syntax highlighted. The blue text below the box shows the file name (so attendees can find it in their collateral material). It's also a txmt: hyperlink—click it and the file opens in Textmate, so we can edit and run it.

Using Parts of a Source File

You often just want to show part of a larger source file. We do that by including START:tag and END:tag comments in the original source. (This works in any language, and not just Ruby source). In the slide markup, you indicate the part(s) you want to include in square brackets after the file name:

h1. method_missing

:code code/meta/my_ostruct.rb[impl class=code-small]

This says to look at the source file code/meta/my_ostruct.rb and only include on the slide the stuff between START:impl and comments. We'll also display it using the CSS class code-small.

The ability to include parts of code is invaluable when you're doing a sequence of slides that builds a solution: you can show each part of a source file in turn.

Building the Presentation

The toolchain that takes all this is remarkably simple, because most of the work is done for us. We use a simple Ruby script that takes our original slides, embeds the source code from external files, and then runs Textile to produce an HTML version. We then add a header to that HTML that drags in two incredibly useful Javascript libraries.

For the presentation itself, we use Eric Meyer's S5 system. It gives us nice looking slides, simple to use navigation, and lets us present in our own browsers or (potentially) on our students'.

For the syntax highlighting of code, we use SyntaxHighlighter. This clever piece of code doesn;t require you to mark up the code elements inthe HTML. Instead you just flag your <pre> blocks with an appropriate class and it does the parsing and highlighting in the browser. It means that really large decks can be a little slow to load (but the still beat Keynote on elaspsed time), but it also means your HTML is really clean.

Finally, we have a Rake task that lets us built the whole presentation or just individual chapters.

The whole thing took about 4 hours to get working, and probably another 4 hours on and off to tweak it based on experience. The code's not really in a state that can be released (so please don't ask), but it wouldn't take much to produce something you could do the same with.

It Actually Works in Practice!

So far, we've done two studios using this stuff (Advanced Ruby and Erlang), and I've used it in a number of conference presentations. I wouldn't switch back to regular presentation software for any code-based talk. (I'll still use Keynote for non-code slides, though.)

A Few More Slides

Here's the source:

h1. initialize_copy

Container wrappers such a OStruct have a potential problem

:code code/meta/my_ostruct_problem.rb[class=code-small]


h1. initialize_copy

:code code/meta/my_ostruct_ic.rb[impl class=code-small]

h1. const_missing

* Module method whenever undefined constant references in that module

** (Module is a module, and acts as a global place for @const_missing@)

* Mostly used to autoload classes

* Not as easy as it looks (Rails' @dependencies.rb@ is 500 lines long)

h1. const_missing

:code code/meta/const_missing_autoload.rb[class=code-small]

And here are the resulting slides:

Silly Useful shoulda trick

Playing with the shoulda testing framework, I came across a small but useful trick. Because the tests are written inside closures, local class variables are available inside should blocks. They're only evaluated once, so they don't take the place of setup blocks, but they are a nice way of storing test-wide values. Somehow, I like the look of this better than using instance variables or constants—the tests seem to be more uniform and balanced.

require 'test/unit'
require 'shoulda'
require 'date' 

require 'csv_to_html/age_calculator'

class AgeCalculatorTest < Test::Unit::TestCase
                                  
  birth = Date.parse("2003-05-02")

  should "be year difference if now later in year than birth" do
    now = Date.parse("2008-06-15")
    assert_equal 5, AgeCalculator.age_given_dates(now, birth)
  end

  should "be year difference if now later in month than birth" do
    now = Date.parse("2008-06-15")
    assert_equal 5, AgeCalculator.age_given_dates(now, birth)
  end
         
  should "be year difference minus 1 if now earlier in year than birth" do
    now = Date.parse("2008-04-15")
    assert_equal 4, AgeCalculator.age_given_dates(now, birth)
  end

  should "be year difference minus 1 if now earlier in month than birth" do
    now = Date.parse("2008-05-01")
    assert_equal 4, AgeCalculator.age_given_dates(now, birth)
  end

end

Test-Driven Rails Studio

I have a blast teaching at the Pragmatic Studios.. Mike and Nicole run excellent courses, the format is incredible, and the students enthusiastic. I love presenting with two or three other instructors—it keeps the energy level high, and I always manage to learn a lot from them.

Which is why it's a shame I won't be able to be at two of the upcoming Studios, Advanced Rails in Denver on June 12–14 and Test-Driven Development with Rails on June 9–11. I'm doubly bummed because the latter is taught by Jim Weirich and Joe O'Brien, both old friends from the Ruby community. I've never heard Joe teach, but I've often sat and admired Jim as he takes some complex subject and reduces in to its basics in the most incredibly entertaining ways. If you're in to Rails, and want to take your testing to the next level, I believe there are still some seats available. And if you do get there, tell 'em I said hi! I'm jealous.

Ruby Symbols in 1.9—End of an Era (and a good thing, too)

:rip.to_i

Ruby symbols have always been immediate objects. That means that, inside the interpreter, they were represented as small integers which reference the corresponding symbol text in a lookup table. This made them fast, but it also left code open to denial of service attacks (particular in the context of web applications)—malicious clients could force server code to create arbitrary numbers of symbol table entries, and these were never garbage collected.

Some recent changes in Ruby 1.9 point to the transition away from symbols being immediate objects. In particular, they lose their integer representation, and hence the methods Fixnum.id2name, Fixnum.to_sym, and Symbol.to_i have been removed. I'm expecting to see symbols migrate to the heap as 1.9 continues to evolve.

Just shipped tons of books (literally)

In the last week we shipped out two much anticipated books: Advanced Rails Recipes and Deploying Rails Applications: A Step-by-Step Guide. We've finally reached the kind of shipping volumes where we get special treatment at the Post Office—I'm now allowed to make deliveries around the back, driving my truck up to the loading dock between all the 50' monsters. It's an interesting insight into their business. The vast majority of stuff sitting out there during the day is the free advertising fliers that get added to your mail—pallet upon pallet of them. If we want to save the forests, finding some way of banning those things would be a start. (But, of course, they probably subsidize the mail, so doing so would double the cost of postage. In this case, that's a price I might be willing to pay.)

Also (getting back on topic), Mike Clark has made a 12 minute video highlighting some of the more visual recipes in his book. Check out the link on the book's home page.