GR8 Conference Europe Wrap Up

Last week was the GR8 Conference for Groovy, Grails, Griffon, etc. in Copenhagen Denmark.

Besides having an awesome Hackergarten event, there was a traditional conference as well. A few of us at work were lucky (or hard working) enough to go. We wrote our experiences up on the Canoo blog.

Post is here: http://is.gd/cn2PW

And DZone Upvotes always appreciated: http://is.gd/cn2YG

Groovy Interview and GR8 Conference Website

Søren over at the GR8 Conference European Headquarters was kind enough to ask me a few questions about Groovy. I find the itnerview an entertaining read, but then I'm maybe biased just a little.

Check it out here: http://www.gr8conf.org/blog/2010/04/15/70

Agile 2009 Day 0: Kanban Bag Stuffing

Spent about 4 hours today packing 1500 conference bags for Agile 2009. Luckily, several guys from the Kanban-Dev mailing list showed up to turn a scene from Modern Times into an unique exercise in Lean production.

I won't explain much about the "Pull" system or queuing theory backing Lean production; rather, I'll just explain what we did.

We had about 1500 bags to pack with more than 25 items each: a lot of flyers, several books (including past volunteer Ahmed Sidky's Becoming Agile), and even some agile hand lotion (wtf, right? But it beats the face creme I got at a triathlon called, I kid you not, "every manjack"). Anyway, it all needed to be bagged, carted, and trolleyed to the reception area. Uff da.

The group split into two teams. Our goal was obviously to get the bags packed as quickly as possible. The Kanban experiment was used to create a system of flow, in which each group had a steady stream of product through their production line. Bottlenecks meant the upstream production unit should slow down and not having work to do meant the upstream unit had to speed up. But it wasn't about working more or working less to achieve flow. It was about tweaking the process so that everyone working hard would result in the flow. The group had to self organize and evolve so that this steady state existed. Over two shifts of people this did all happen to a certain extent. We didn't have measurements to see who was fastest, but each process did improve over time. Here are some observations, along with how they might apply to software teams:

• Having no leader meant that every team member contributed new ideas to process improvement. Does the leader of your software team sometimes stifle innovation?
• Having two teams meant that competition fueled more frequent improvements. What external forces are driving your software team to evolve?
• Having no roles created a system where shouting "We're out of Agile Hand Lotion" meant that the person most capable of grabbing more lotion at that point in time immediately pitched in to do the job. Are the roles in your organization lightweight enough to allow the right person to contribute?
• Having one set of workers out-of-sight (running trolleys through elevators and hotels) meant that it was more difficult for the group to self correct their entire process. Finished bags did pile up and we were at a loss as to how to make the trolley's move faster. What parts of your SDLC are out-of-sight and out-of-mind?
• Not producing a Value Stream Map meant it was difficult to see the whole and fix the real problem, which was slow elevators. VSMs are much lower ceremony than most people realize, and we could have done one. Can your team truly see the whole?
• Many improvements were small and non-obvious in retrospect - "Why don't we pack the books last because they are heaviest?" and "Open the bags more quickly by pulling the handle like this." Does your company have a process group that focuses on the macro view to the exclusion of the micro view?
  

At the end of the day, pro facilitator Jean Tabaka of Collaboration Explained fame hosted our retrospective for us. The format was ORID:

• Objective – Focus on the facts, hard evidence data
• Reflective – Focus on how that made people feel or other associations
• Interpretive – Focus on the impact and significance
• Decisive – Focus on next steps
  

It was a typical retrospective in that we gathered data and created a shared understanding of the event in the Objective phase, talked about our feelings and personal experiences in the Reflective phase, generated insights in the Interpretive phase, and voted with dots in the Decisive phase to create a list of action items for next year. She and the rest of the team did a great job, and both Kanban and the retrospective were superb ways to kick off the volunteer sessions!

And just because I get a kick out of having foreign characters in my posts: 看板 is the symbol for Kanban. Whee!

Upcoming Speaking Gigs and Appearances

I have four speaking appearances booked this year (so far) in the Twin Cities area.

If you're in the area then please come out and say hi. If you're not then feel free to come crash on my couch. And if your JUG is within a motorcycle ride and you need a speaker then by all means contact me. My range is about 700 miles a day and I work for less than peanuts.

Here is what's confirmed so far in 2009:

Groovy Users of Minnesota
February 10, 2009
Groovy + IDEA For-The-Win (part of a larger IDE shootout)

Twin Cities Language User Group:
March 12, 2009
Groovy Metaprogramming (with Scott Vlaminck)
Expect greatness, we're super excited!

CITCON North America
April 24-25, 2009
Open Spaces Conference on Continuous Integration and Testing
Registration still open... it's free and in Minneapolis

Twin Cities Java User Group
July 13 or August 10, 2009 (TBD)
Zen and the Art of Java Concurrency
This isn't a catchy name. I genuinely plan to cover Zen Buddhism.

I'd love to fill up my calendar more... so please, please, please contact me if you have some sort of opening.

Thanks everyone!

No Fluff 2008 Conference Highlights

Another No Fluff conference has come and gone in Minneapolis. Fun, exhausting, and energizing, all at the same time. Thought I'd write up the highlights for anyone attending in the future.

Busy Java Developer's Guide to Scala Part One – Ted Neward

I wanted to attend this session ever since I heard a rumor about it at the Denver JUG... and it was one of my two must-see sessions. Strong typing, type inference, functional style, actor concurrency model, and pattern matching(sweet!). What's not to like? I've been putting off reading all the recent online tutorials until I saw this and wasn't disappointed. A must see.

Ancient Philosophers and Blowhard Jamborees – Neal Ford

I'll plug myself here and say I blogged about Aristotle's Metaphysics back in December. I approached the complexity issue at a language level, while Neal Ford talked about it at more of a system level. He also covered a lot of anti-patterns in a very funny, interesting way. Neal put a lot of time into making the slides and presentation amazing, resulting in a great, memorable keynote. Definitely stick around for this.

Transaction Design Patterns and Java Persistence – Mark Richards

These two sessions surprised me with the usefulness. It helps that we're coming up on some big decisions in this arena at my work. Comparing iBatis and Hibernate with live code demos revealed the sweet spots and pain-points of both frameworks. And looking at all the transaction management patterns made me realize just how naïve my past attempts at managing transactional code have been. These were great sessions for someone like me who hasn't touched Hibernate or JPA since Java 1.4 (you'd never guess from my resume!).

Gant – Andrew Glover

Ant works well enough, right? Uh, maybe not. I've always dismissed Gant as a tool for a problem I don't really have. Turns out I've wanted Gant all along. Plus, the integration with Ivy is slick. Just the idea of being able to step through my build script in my IDE debugger makes me happy. This is the session that I'll follow up on immediately Monday morning at work. But I kinda wish the session was called “Gant get enough of your love”. Hmm, maybe my Gant puns aren't any better than Andrew's.

Design Patterns in Dynamic Languages – Neal Ford

Having been a Groovy convert for a while now, it's nice to see a more advanced Groovy session. It's also nice to get some new ideas on places to use metaprogramming. Sure, it's the shiny new thing bound to be overused, but digging myself an unmaintainable hole of code is half the reason I learn new tricks in the first place. I'll leave the clean up to the maintenance programmers.

Why Can't Anyone Type on a Mac? - Everyone using a Mac

The only person whose live coding session wasn't riddled with typos was the guy using Windows. During lunch I investigated this further and found that everyone had normal sized fingers (with one hugely notable exception, you know who you are), so all this fat-fingering wasn't due to the presenters' physical features. Are Mac keyboards simply ergonomically bad? The crazy part of all this is that the guy using Windows was running it through Parallels on Mac hardware. The only explanation is that something about Mac OS is causing people to forget their typing skills. Can someone please explain this?

See you next year, so long, and thanks for the memories!