ThoughtShapes - Closures in Ruby, Part I - Comments

Jay, Thanks a ton for

Rjae Easton — Mon, 07 Apr 2008 15:13:00 -0400

Jay,

Thanks a ton for extending the usefulness of this post.

Once you open your mind to the concept of closures, whatever the syntactical sugar may be, you begin to find all sorts of applications. I have one concern about closures: they lower the barrier of entry on concurrent programming. In other words, I am concerned because closures make it so a developer can be writing concurrent code, without even knowing it. I hope any senior developers out there such as yourself remind their team that closures can be a loaded gun.

It is certainly great to see dynamic language support making its way onto the .NET Runtime playing field. I wonder how far off we are from having (Visual Studio) solutions that contain both C# projects and Ruby.NET (or whatever it gets called)? The thought sits just fine in my mind because each language has its own strengths and weaknesses.

Thanks again Jay.

Hi! Sorry for being so

Jay — Sun, 06 Apr 2008 21:07:57 -0400

Hi!

Sorry for being so delayed in posting here but life, vacation, child illnesses etc kept me from it :)
This is pretty interesting stuff. Before this post I hadn't spent time looking into the performance characteristics of the different ways to do closures in Ruby. I was just loving closures in general and how easy of a tool they are to use in Ruby. :)

So I took your code and ran it on my machine. I happen to be running on a MacBook pro and have 2 Ruby vms. JRuby 1.1 RC2 and the CRuby vm everyone uses. It's interesting to note that in JRuby

call_with_block                0.031000   0.000000   0.031000 (  0.030000)
call_with_block_from_lambda    0.019000   0.000000   0.019000 (  0.020000)
call_with_block_from_proc      0.018000   0.000000   0.018000 (  0.018000)
yield_with_block               0.016000   0.000000   0.016000 (  0.016000)
yield_with_block_from_lambda   0.013000   0.000000   0.013000 (  0.013000)
yield_with_block_from_proc     0.012000   0.000000   0.012000 (  0.013000)

CRuby numbers on my machine:

call_with_block               0.100000   0.000000   0.100000 (  0.100587)
call_with_block_from_lambda   0.020000   0.000000   0.020000 (  0.019553)
call_with_block_from_proc     0.020000   0.000000   0.020000 (  0.019233)
yield_with_block              0.010000   0.000000   0.010000 (  0.010333)
yield_with_block_from_lambda  0.010000   0.000000   0.010000 (  0.011263)
yield_with_block_from_proc    0.010000   0.000000   0.010000 (  0.011194)

While in JRuby the numbers seem less clear, I still think the elegance of yields and blocks needs to be a factor until such a time as performance tuning needs to be examined.

Also I hadn't been using yield all that much but I haven't written to many functions that take a block explicitly, yet. I'm still getting into that swing. But I'll be sure to go back and make sure I'm using yield :)

good stuff!

Closures in Ruby, Part I

Rjae Easton — Thu, 20 Mar 2008 10:11:31 -0400

Closures are a powerful concept in some languages - a powerful tool in others. In my mind a tool is something I can ask for by name - as in, "I'd like a reciprocating saw, please." Languages where closures are truly a tool include Lisp, Python, Ruby, among others. For the time being I will use Ruby to discuss closures - although a switch over to Lisp may be necessary.