Unless the method is directly calling itself, the only way to short-circuit a method when it recurses is to have it set some global flag which it can then check in recursive calls. If the flag is already set, the recursively called method bails out early. Once the original invocation is finished it unsets the flag.

It’s not safe to use a true global variable for this flag, since this would not be threadsafe. The safe way to do it (albeit not a terribly pretty one) is to use thread-local variables.

I decided to go ahead and write a macro which can turn any method into a non-recursive one. Here’s the code:

Let’s take a closer look at that.

The method takes an argument, method_name, which is the name of the method to make non-recursive.

Then it creates a name for the recursion flag. Since thread-local variables are global for the whole thread, we need a variable name which is reasonably unique. We get one by combining the current class and the method name.

We’re going to replace the method with a modified version, so we need to stash the original implementation somewhere. We grab an UnboundMethod object by calling #instance_method() on the current class:

Then we proceed to redefine the method:

The first thing the modified method does is check to see if the recursion flag is set. If it is, it bails out.

Otherwise, it sets the flag:

And then it binds the UnboundMethod stored in original to the current instance. This generates a Method instance, which it proceeds to call, passing any arguments along.

(Note that I wrote this code for a Ruby 1.8 codebase. If it were for 1.9 I would pass the &block down to the original as well. Since blocks in 1.8 can’t accept &block arguments, I can’t do that here so long as I’m using the block form of define_method. So this macro will only work for methods which do not take blocks.)

Finally, the code ensures that the recursion flag will be unset when the method is finished, even if an exception is raised.

Note that setting a thread-local variable to nil removes it:

I have no idea what :__inspect_key__ is, but as you can see the :foo key goes away after setting it to nil.

Let’s take a look at this in practice. Here’s are two methods #foo and #bar (original, no?). #foo is recursive, with #bar as an intermediary, preventing it from passing a recursion flag directly to itself.

Calling the #foo method results in a stack overflow:

But if we update the method with prevent_recursion, it successfully exits:

Although a much larger group of mentors will be announced, the current team is pretty impressive and represents management, finance, technology and other key skills for early stage companies. VentureBox will be offering mentorships, infrastructure and a milestone-based program to develop startups into investment-ready enterprises.

We think that VentureBox has great potential to help diversify the Central Oregon community and create sustainable, living wage jobs. That’s why we’re proud to be supporting and participating in the effort!

Perhaps the most well-recognized effort in this arena is the Bend Venture Conference. For several years, the homegrown BVC has attracted startups from across the Pacific Northwest to compete for cash investment and the and the attention of the regional angel and VC community. Previous investments have included some great companies ranging from medical devices to web-based SaaS  providers. This year’s keynote speaker is in none other than Andy Sack, the Executive Director of TechStars Seattle and the Founder and CEO of Lighter Capital.

The BVC is the highlight and in some ways the epicenter of Bend’s thriving entrepreneurial spirit. So we are proud to support the efforts of the conference organizers and hope to see you at the event.

And a huge thanks to Ben and Shane for organizing… See ya all there!

Miles Forrest interviews Avdi Grimm on his new book “Exceptional Ruby”. Dealing with unexpected failures in code is tough, and oftentimes error processing is dealt with in a haphazard way. Hear the 5 questions you need to ask before writing code to handle unexpected failures, as well as his story about a cascading failure that went from bad to worse.

You can listen to the interview and purchase “Exceptional Ruby” on the Pragmatic Bookshelf website.

DataMapper Core Contributor and Code Benders team member, Piotr Solnica, has written a great blog post for our partner Engine Yard entitled Using DataMapper and Rails with Legacy Schemas. Read it and you can say goodbye to your fear of inheriting a legacy app.

You can learn more about the project here.

We are planning a repeat performance next year. And, we are considering options for a summer/fall event in the next six months. We’ve kicked around the idea of a rumble, hackfest or even an agile theme. If you have any ideas or feedback that you’d like share, send an email to all the guys or drop us a tweet.

Finally, I want to send out a huge thanks to all the attendees, speakers and sponsors for making RoA 2011 so awesome!

“Piotr has been involved in DataMapper for several years now, and has been doing some amazing work on the DataMapper Property API, heading up our CI server configuration and many other areas… he’s been extremely helpful inside the channel and out.”

Congrats, Piotr… nicely done!