Friday, July 15, 2011

Uber Conference 2011

I attended the 2011 Uber Conference in Denver this week and while it didn't "blow my mind", it did provide for some great camaraderie, learning and discoveries. The space, amenities, food and sessions were great. The only complaint I had is with the wireless access, which was spotty and very sloooooow.

The conference bills itself as "ultimate Java platform/agility experience" and it definitely delivered on the Java platform part. The most interesting sessions for me, and the ones that made the most impact, were the ones related to jRuby and the Spock testing framework. I still can't believe how easy mocking is with Spock.

I had some great conversations and I picked up a few shortcuts and recommendations for personal productivity applications. For example, I downloaded Evernote to capture my conference notes.

As in the last conference I attended, I was awed by the way new frameworks are abstracting away the tedious and repetitive parts of software development that don't add value.

I've got a long list of tools and technologies to explore and I need to understand closures and mixins.

On day one I attended the full day Android Workshop by Ted Neward where I got some exposure to Android, which appears to be a blend of Java, open source, and a mobile device platform. I developed the sessions's simple app using the SDK, development environment and emulator. The Android API is a different mental model for me. Another paradigm shift. It seems a lot like the Java Swing event model with registration and call backs.

At the end of the day my mind was full of Android but it was a lot of fun to expand my knowledge and stretch my Java comfort zone.

In the day 1 keynote presentation Terry Ryan talked about how to overcome the common resistance you'll encounter when you try to implement the technologies and tools you're passionate about. Terry spoke about the patterns, and personas that you'll deal with. As Terry pointed out, overcoming the resistence is simple, but not easy.

Day 2 was the official start of the conference. I attended the following sessions:

Continuous Delivery I and II by Jez Humble

Continuous delivery aims to avoid long periods between an idea that may provide value and the ability to determine if the value is real. The goal is to release minimum marketable features quickly and get immediate feedback. Also, continuous delivery results in software that's always ready so that software is not a company's bottleneck.

Jez posed a great question worth pondering: How long would it take your organization to deploy a change that involves just one single line of code?

Using DDD Patterns for Supple Design by Paul Rayner

This session was right up my alley because it dealt with ideas I've been exploring in my blog. I really enjoyed the discussion about ubiquitous language since I've been advocating for it at my current job. Some of the Domain Driven Development patterns that were presented: Entity, Value Object, Event, and Service.

Designing RESTful Services by Ian Robison

I'm currently reading Ian's book REST In Practice and struggling to comprehend the concept so it was good to get some additional perspectives. This was the most popular session that I attended.

My take is that REST is about avoiding coupling in machine to machine interactions by simply using the standard HTTP interface. The goal is to execute a specialized processes in a generalized way by focusing on what to do next and/or how to progress. A key point is that the "application" is what the client perceives it to be - the server is just a collection of resources that "look out for themselves" and aren't concerned about the overall goal the client is trying to accomplish.

Effective Java Reloaded by Matt Stine

This session was about writing better Java code by applying the tenets in the book Effective Java. The following tenets were review/discussed:

Make defensive copies when needed
Obey the general contract when overriding equals
Always override toString
Consistently use the Override annotation
Prefer primitive types to boxed Primitive
Use overloading judiciously
Remove empty arrays or collections, not nulls
Minimize scope of local variables

Java Web App Security: Develop. Penetrate. Protect. Relax. by Matt Raible

This session demonstrated how to implement web authentication via Java EE Servlet 3.0, Spring Security and Apache Shiro.

Software Craftsmanship: Positioning, Patterns and Practices by Peter Bell

This session, the sixth of the day, was a good day ending one since it mostly high-level and based on familiar concepts. We took a look at the state of the Software Craftsmanship movement and discussed its history, philosophy and practices.

There was an interesting discussion about the dust-up earlier in the year regarding the value of Software Craftsmanship.

On Day 3 I attended the following sessions:

JRuby in Depth I and II by Neal Ford

This was one of the two sessions that really made an impact. I hadn't previously thought about taking advantage of Ruby with existing Java projects. JRuby makes it possible. Ruby is just one of over 200 languages that run on the JVM but it's one of the oldest and most mature/stable.

This session presented a demo of jRuby and the Ruby syntax.

Git Workshop by Matt McCullough

I've been using Git and github as my code repository so this session didn't present anything significantly new but I did pick up a few shortcuts and ideas.

Tricks of the Trade - What Every Developer Should Know About App Security by Frank Kim

This session was a real eye-opener. Frank showed just how easy it can be to exploit app security flaws. He demo'ed how to exploit flaws with Cross-Site Scripting, Cross-Site Request Forgery and SQL Injection.

A couple of take-aways: hacking is not hard, and don't trust any data coming into your app - either from the client or your own persistence.

Design Patterns in Modern JVM Languages by Venkat Subramaniam

In this session Venkat demonstrated how the newer JVM languages (Scala and Groovy) make it easier to implement the following patterns:

abstract factory
fluency (closures)
pluggable behavior
execute around method
intercept, cache, invoke

On the final day of the conference I attended the following sessions:

Smarter Testing With Spock by Peter Niederwieser

Peter is author of Spock and provided some of the motivations and use-cases that were used to create Spock, which is a Developer testing framework based on Groovy, written in Java, and compatible with JUnit.

Peter presented demo's of the major facets of the framework. I was amazed and the simplicity and the obvious, self explanatory syntax of Spock. I was really floored by the ease of mocking and stubbing.

I'm looking forward to actually using this framework.

Functional Web Testing With Geb and Spock by Peter Niederwieser

I was a little lost in this presentation because I've not done web page testing and I'm not well versed with jQuery. But Geb is a powerful tools that really works for web testing.

All-in-all it was an excellent 4 days. Very enlightening and energizing.

No comments: