Testing, scripting and agile miscellany

This was the 2nd year for the Enterprise Ruby Conference – held at the Microsoft offices in Columbus – twice as big this year as last and likely to grow out of that venue next year.

For a more comprehensive overview on the full 3 days take a look at Josh Holmes’ blog – kudos to Josh for getting the space to hold the conference, blogging and giving a great presentation. Big thanks also to Joe O’Brien for organizing the event, getting great speakers and managing to present as well.

Giles Bowkett – The Safety scissors of Meta programming

Giles is an entertaining speaker and the topic itself is very interesting as it’s one of the key features of Ruby, it’s not “magic”, it’s part of a well designed, adaptable language. Every ruby programmer should understand this and not invoke the idea that this is a mystical, mythical, magical feature, this is core to the idea of Ruby and other Java.next languages. Interesting takeaway – he talked about code that generates code – is it cheaper to hire a developer or write one? At his previous job for the LA Times he wrote what he calls a mini-Giles which is still to this day generating code for them. Great book on the topic – Code Generation in Action – which I’ll pick up soon.

Stuart Halloway – Ending Legacy Code in our Lifetime

Stu and Neal Ford talked about Essence vs Ceremony – Ceremony can be irrelevant details in code that doesn’t contribute to the task at hand. Java is full of Ceremony and currently holds a position as the last ‘Next Big Thing’. Ruby is the current ‘Next Big Thing’, typical of the cycle of languages and paradigm changes in the industry ~10 years. Ruby is a low ceremony language which helps tremendously to communicate the essence of the code, more readable and maintainable code. Ruby and other Java.next languages (and language polyglotism in practice) will be the standard, just as Java is today, in about 5 years.

The challenge is that when the Next Big Thing changes according to this talk is that we need a way to not dump everything. As software developers, our goal should be to build this generation’s code so that the Next Big Thing won’t force a complete “do over.” He also mentioned Ola Bini’s pyramid of polyglot programming – multiple languages used for clarity and separating out pieces of the architecture that will change from those that are more static.

Charles Nutter – JRuby

JRuby is an implementation of the Ruby Interpreter in Java that runs on the JVM. Charles talked about JRuby and what it brings to the mix.

Leveraging the JVM allows JRuby to: take advantage of using Ruby simple syntax with Java objects, uses optimizations in HotSpot increasing the performance of Ruby code multiple times over the standard Ruby implementation, allows the use of Native threads, Unicode, all of Java’s existing libraries, and inline Java code along with Ruby code.

One of the side benefits of JRuby is the political gain that can be achieved by leveraging Java’s existing place in the Enterprise. Deployment can also be simplified by creating a war file, deployable on a standard Java app server. One example was in this or another talk, where Infrastructure engineers didn’t even realize they were deploying Ruby code for several weeks after it had been running in production.

Evan Light – Unit Testing J2EE from JRuby

Testing java and particularly J2EE – ejbs, etc. is hard. Testing Java with JRuby is easier since the language simplifies things. He gave examples on testing EJBs which is one of the biggest challenges. It’s much simpler in Ruby where you can dynamically add methods to existing Java objects, change method level access and mock out connections. JRuby is a powerful tool for simplifying the unit test creation and a good entry into the Enterprise. Evan’s also created a library – jrsplenda – that has JRuby helpers to simplify testing Java code with a combination of: Java reflection andJRuby metaprogramming. Cool stuff.

Neal Ford – Essence and Ceremony

Neal is a great speaker, I had the fortune of seeing him speak at Agile and then again here on completely different topics. As I mentioned previously, Ceremony and Essence was certainly a big theme from both Neal and Stu at this conference.

Accidental and Essential complexity. Essential complexity involves solving problems that are inherently large vs Accidental complexity where we’re introducing the complexity into the situation. Example: EJBs introduce a lot of Ceremony(Accidental complexity) by having half a dozen configuration and other files to get to the essential function of the code.

The attempt to commoditize software engineering: FAIL. The average developer is not ½ as good as the best developer; they are instead, many times less effective and potentially even a net negative.
“Bad developers will
move heaven and earth
to do the wrong thing.”
Glenn Vanderburg

Java is a language of frameworks, more of that to come in Neal’s next talk. EJBs, JSF and other frameworks all spawned out of Java to handle the inherit flaws in the language to develop tools, vendor buyin, add complexity(Ceremony) to solve difficulties in bending the language to the problem.

“How much of enterprise development does nothing than service accidental complexity?” Enterprise development should be using Essential languages to solve problems with excellent developers. A five week training course that makes a developer 10% more productive will pay for itself in a year.

Neal also hit upon the same idea expressed early about polyglot programming. Ruby and other dynamic languages are much more capable of change and should be used – to refer back to Ola’s pyramid – on the tiers that are apt to change more frequently due to changing business requirements, while Java/C and other languages can be kept at a lower static level which is less likely to change.

It seems that not only is Ruby going to play a large force in the next cycle of software development, but the general sense of the Ruby community will also change the paradigm towards a focus on testing, polyglotism in large scale development – use the right language for the right task – and expression of intent in languages closest to communication with the domain.

Stuart Halloway – Testing AntiPatterns: How to fail with 100% test coverage

Stuart talks about coverage tools and metrics and when 100% isn’t enough – coding choices(branching, et al) – and traps you could fall into. Good stuff, go read it.

Neal Ford – Design Patterns in Dynamic languages or ‘How to make C++ Suck Less’

A few speakers hit upon the topic of the GOF book which when I was coming up was a bible, right next to ‘Refactoring’ and other seminal books. The book itself is as noted, a split between ideological – a discussion of the ideas – and implementation in SmallTalk and C++. The latter caused a lot of people to view it as a cookbook with recipes in C++ that should be implemented on every project….a large mistake, according to at least one author and the speakers at ERubycon. The patterns themselves, are actually tied to workarounds and deficiencies in the language – C++ at the time and SmallTalk written the way a C++ programmer might approach it, losing a good portion of the value of the language.

As evidenced in Ruby Design Patterns and Neal’s talk, a lot of the patterns rose out of language limitations which dynamic languages don’t have and therefore, they’re either included in the language – e.g. Singletons – or trivial to implement. Factory patterns are prolific in Java and C++ and put a lot of Ceremony around getting a basic Object back from a call, while Ruby makes the same concept easy with no pomp and circumstance.

Jim Weirich – What the Enterprise can learn from your Mom

The basic gist of the talk was threading using multiple languages to cover the spectrum of how threading and concurrency is or generally isn’t built into the language. Jim gave some great examples working with multiple languages and simple problems that involved threads and concurrency.

While hardware gets faster, and pushs multi-core systems, most programmers and therefore applications aren’t taking advantage of them. Why? Writing a multi-threaded program is hard – there is some essential complexity. Jim gave examples in Ruby, Erlang and Clojure to demonstrate some of the challenges and different languages handling them.


Chris Wanstrath – GitHub, the lean, mean distributed machine

Chris talked about git and several models of development to fit everything from serving individuals to open source projects and using git as a replacement in enterprises, similar to the way that subversion is used now.

Github is obviously used extensively now for many open source projects, forking and merging are standard practice. We’re looking at moving Watir over to Github as a replacement for our svn repository on openqa.org, and using the git svn bridge for some of the code I’m working on at our company.


There were a lot of other interesting talks, that I didn’t get a chance to mention. This was definitely a great conference and one that I’d recommend attending. Next year is bound to be fun and I’m hoping to attend. Note to self, take copious notes on the topics instead of trying to remember and recap the entire conference.

I also think that next year could benefit from a change in format as attending 3 full days of talks is informative, but the brain tends to turn off after a while.