The YOW! 2010 Australia software development conference was held in Melbourne and Brisbane a few weeks ago. With a huge thanks to my good friend Nicholas Muldoon from the GreenHopper team at Atlassian, I had the privilege of attending the Brisbane conference. The following are my notes and thoughts from day one of the conference.

 

Extreme Java Productivity: Enterprise Applications in Just Minutes

Ben Alex from VMWare SpringSource gave this presentation on Spring Roo. This talk was one of the a-ha moments for me, as I really have not spent much time looking at Roo until now, and I was quite impressed with where they have taken this product. The slides are available here.

• wanted to build productivity tool for Java developers
• development time only, runtime stack is Spring
• code generator active and passive
• goal was not needing to read the manual
• use ‘hint‘ and tab to help you setup the project basics
• ‘controller all‘ to get a web tier
• Roo keeps a log and this can be replayed as a script
• web tier is using Spring MVC – 35% of Java developers use Spring MVC, the rest still use Struts or a mix-and-match
• can run Roo without an IDE, if you do you need to you can install the AspectJ plugin
• minimal approach means Roo starts by creating a JAR and only creates a WAR when you need to create a web tier
• easy to throw away Roo if no longer want it (can also re-add it if you wish)
• ‘database reverse engineer‘ to incrementally keep up with the database changes
• can deploy to Google App Engine with one command, same with VMWare

Rails in the Large: How We’re Building (One of) the Largest Rails Apps in the World (for an Enterprise)

Neal Ford is always entertaining and in this talk he shared some learning from a large Rails development project. His slides are available here.

Neal started the talk with a visualisation of the activity on the project Subversion repository using Codeswarm. This is really cool but hard to explain, so here is a similar video of the Eclipse codebase. Look for the explosions, which are essentially big commits for releases.

• the pursuit – inception phase / iteration 0 – 2 to 6 weeks
• ove.com – asked Thoughtworks to build in .NET or Rails because existing developers were Java!
• started with 2 developer pairs and added 2 developer pairs every week until they had 11 developer pairs, 8 BA’s and 6 QA’s
• found that they needed more BA’s to pairs because of the ability to move through code quicker in Rails, traditionally about has about 3 pairs to 1 BA in Java
• demonstration trumps discussion, don’t convince on technology too early
• 3:1 ratio of test code to production code, typical for Rails
• when living on a submarine, have fun!
• run 8,996 unit tests in 4 seconds using unit-record
• rule: unit tests don’t hit the database, mock and stub everything (under 1 minute) – fight the battle to keep tests fast and invent stuff if you need to
• functional tests on the other hand can’t use stubs, run 3,964 tests in 248 seconds (under 5 minutes)
• DeepTest – realised that tests were only using one core, so parallelised the tests – want to hear fans running on the machine!
• Distributed DeepTest – use underutilised BAM’s (Bad Ass Machines) to run tests across the network
• key to agile software development is feedback loops
• Selenium Grid, used for User Acceptance Testing, problem is Selenium is really slow – took 8 hours sequentially, on grid was just over 2 hours
• use continuous integration for lots of things that need automation (CruiseControl.rb)
• VMWare Fusion to run dedicated applications locally
• use green / blue infrastructure for deployment, means you test on real hardware and you have a rollback in parallel
• project Mingle on the wall so there is a common canonical view
• cc_board – clear view of status without needing to scroll – information radiator
• jukebox.rb – plays a song when the build breaks, play a theme song upon successful checkin
• pairing stations – installed Adium, no email because it is poison to developer productivity, use machine names and add the pair names to the status, laptops for personal machines
• setup internal Jabber chat rooms
• used API’s to update Mingle status on successful checkin
• software is more about communication than technology
• 100% pair programming
• have fun, work does not have to suck!
• automate everything – do something that is painful more often that will force you to automate
• 1 click command to deploy to any development
• canonical pairing stations using radmind (Linux and OSX) to keep all the machines in sync, some overhead but better than keeping 11 machines up-to-date by hand
• for messaging started with message.rb as it was good enough, then moved to Starling when they needed it and understood what it would be used for
• use external tests to check that external services still work
• performance – use custom hand tuned SQL to do things like forcing indexes
• upgrading is hard, don’t put it off for too long
• you can solve anything with rock, paper, scissors and when you get really good you should check out worldrps.com

Integrated Tests Are A Scam

J. B. Rainsberger led this excellent talk on integrated tests. His blog posts (and the summary on InfoQ) on this subject go into a lot more detail. Finally his slides were impressive as they were drawn in real-time using an iPad.

• slow – delays feedback which means more mistakes and more integrated tests
• brittle
• misleading
• viral
• corresponding collaboration and contract tests
• the client always owns the interface
• basic correctness – each layer talks to the next layer correctly

Testing Your Javascript

Corey Haines delivered this talk, which I blindly hoped would give an answer to the age-old question on how to deal with JavaScript (there was no sliver bullet though). His slides are available here.

• has a bad name because it is just a scripting language
• hard to test, no good tools
• pain in testing means your design has problems – good design means it’s testable
• tools – Jasmine, QUnit, JsUnit, JSpec, should.is
• BDD – not tool specific, concept specific, feature level tests driving example level isolation tests
• 4 rules of simple design (Kent Beck) – tests pass (you need to be able to verify it works), no duplication (knowledge has only one representation), reveals intent (name your objects / variables well) and small
• SOLID principles – next level above the four rules for good design
• design guidelines – stratified design (layer cake design), find canonical representation of your data and get away from the DOM and wrap these with builders and behaviors

Domain Modeling with Processes – Adventures of an “object head” in Erlang land

Kresten Krab Thorup delivered this talk which walked through the challenges of developing Erjang (Erlang on the JVM). His slides are available here.

• Java designed in the client server age – coordination happened in the database
• Erlang is a perfect domain specific language for event driven programming
• patterns to ensure system is reliable
• build reliable systems in the presence of errors – isolation + concurrency
• emulator + BIF (built in functions) + OTP framework
• Kilim – coroutines and asynchronous processing for Java

Release It! Design and Deploy Production-Ready Software

Michael Nygard delivered this talk which detailed some of the content from his book Release It!

• author of Release It! plus 3 other books including Beautiful Architecture, 97 Things Every Software Architecture Should Know and the Java Developers Reference
• failure is everywhere and it costs a lot
• five nines equates to 25 seconds downtime per month – planned and scheduled – impossible!
• average availability is 88% (3.6 days) for JEE applications
• since 2004, most security attacks are now at the application level not the operating system level
• QA tests functional requirements, non-functional testing is timely and costly, we don’t test for longevity of under production load
• observed availability and stability over time
• increased interest in DevOps – dev2ops and devopscafe are excellent resources

Keynote: 50 in 50

Richard P. Gabriel and Guy Steele delivered this keynote that covered 50 language lessons in 5o words or less. Some of the highlights for me were Piet (a language that looks like abstract art, and changes in colour affect the program flow) and Shakespeare -(a language where the code resembles a Shakespeare play – they showed a great video of how this would look which was well done). I also relived programming of languages from my past and present including COBOL, JCL, BASIC, Python Ant and Java.

A copy of the keynote delivered at JAOO in 2008 is available online if you would like to watch or relive it.