No Fluff Just Stuff: Denver Fall ’08 Wrap

The effect of a No Fluff, Just Stuff conference is not unlike that of a conversation with a beautiful woman: afterward, you feel simultaneously like you can do anything, and also like you’re the biggest moron ever to walk the face of the earth. The analogy runs out of gas pretty quickly after that, but still: you can’t help but feel pumped when you’re done with the weekend.

The networking was, as always, first-rate. I got to reconnect with Denver-area peers I already knew and make new acquaintances as well. The speakers themselves are also very accessible at No Fluff, and I enjoyed getting to get to know several of them a bit. Most of these guys are pretty big guns, but you never get the idea that they believe their own press, as the saying goes. If you want a chance to talk to or even share a meal with published authors and industry thought leaders, this is the conference for you.

Here’s a brief summary of some of my favorite sessions:

JVM Memory and Garbage Collection, by Ken Sipe. Ken led us through the structure of the Java heap and the life cycle of that Java objects that live in it. He showed us the heap monitoring tools we should be using. My ignorance of the JVM’s memory management was nearly complete before this session, so it was quite an eye-opener for me. I now see how a poorly configured heap can hobble the performance of a program that should otherwise run well on a given hardware configuration, and I know how to begin diagnosing such a problem. This was one of those sessions that leaves you wondering, “How could I not have known that?” But now, next time I run out of memory, -Xmx is the last thing I’ll be doing.

It occurred to me while listening to Ken speak that some exposure to embedded systems would be good preparation for this material. Only during Ken’s keynote that night did I discover that he (like another outstanding software engineer I know fairly well) began his career in firmware. So there you have it.

Security Code Review, by Ken Sipe. My notes on this session were not great, due to the combination of flaky WiFi and my strange and unexamined unwillingness to take notes in anything but Google Docs. (And yes, Docs supports offline editing with Gears now, but you can’t create a new document without an Internet connection.) However, I had two takeaways: first, that security considerations ought to pervade the development process, rather than be tacked on the end in an external review, or worse, in response to damaging exploits and bad press. The second was Ken’s proposed threat model, which struck me as a handy and reality-conforming way to think about the bad things that people can do to your software.

JSF: Whirlwind Tour, by David Geary. I am not a JSF user, nor am I a likely JSF adopter in the near future. I understand that JSF enjoys very good uptake in the enterprise, but most of my work is done outside of a classical enterprise context, so it’s probably just not something I’m going to do much. Going for the throat, one might even say JSF is the buttoned-down nerd of the technologies covered at NFJS, relying heavily on tooling, enjoying the embrace of the likes of Oracle, and being all JSR-y as it tends to be. I mean, compare this to the shorts-and-Birkenstocks free love of Grails! No contest among the self-proclaimed cool kids.

Nevertheless, if there’s anybody who can make JSF fun, it’s Dave Geary. This is a technology that is in no way near and dear to my heart, but I really enjoyed learning the basics in this talk. You can’t go wrong listening to this guy. (And for the record, you can go wrong thinking you’re too cool for JSF. It may, in fact, be a bit more buttoned down than other options in the space, but there are more developer jobs open right now for it than for Grails, hot shot.)

Git Control of Your Source, by Stu Halloway. This was one of four very good Stu talks I attended, and easily the most impactful. The cool kids have been refusing to allow me at their lunch table since springtime for my continued use of Subversion, and now I have some idea why. I have heard Git sold as a decentralized version control system, which synchronizes many noncanonical repositories across a project rather than rely on one centralized server—sort of a postmodern VCS, in terms Brian Sletten might appreciate. Stu actually didn’t cover that aspect of Git all that much, but instead focused on its more sophisticated concept of what constitutes a controlled file, a “commit,” a branch, a merge, and so forth. VCS scatology was discussed. He  made the point strongly that SVN discourages branches by imposing too much cognitive cost on the practice (largely through the anticipated difficulty of resolving merges or changing plans with a branch-in-progress), which is precisely the kind of thinking about tools we should be doing more of. It’s not the mechanics of what is technically possible with a tool that are important, but rather the woodgrain of that tool or the intellectual sensibilities it engenders that matter over the long term. Git doesn’t want you to worry about what will happen to the repository when your workstream is interrupted, and it makes it cheap to accommodate those interruptions when they occur. I predict this more than anything else will turn out to be a compelling reason for its adoption. We shall see.

This weekend was the first opportunity I’ve had to hear Stu talk, and I’m very glad I did. He’s a great speaker and a quotable guy, plus his laptop has a name nearly as clever as mine.

FP on JVM, by Venkat Subramaniam. I have in the past described Venkat (accurately) as a live-coding ninja. His Livecode-Fu was in evidence in this talk, in which he covered the basic concepts of functional programming with examples mostly in Erlang, Haskell, and Scala (with some Groovy for illustration purposes). Having been a Computer Engineering major, I can still do some elementary op-amp circuit design, but I am complete functional programming n00b, never having seen so much as a line of Lisp or Scheme in my undergraduate program. This left me at a bit of a deficit at the start of the talk, but Venkat did a good job introducing the requisite concepts and illustrating them in code. This truly was a good introduction to functional programming concepts in emerging languages of the JVM (plus Erlang, which does not run on the JVM) in Venkat’s inimitable and highly dynamic style.

Sometimes Venkat’s live coding feature becomes a bug when you try to take notes on one of his talks. There’s no way I can type as quickly as he can bang out code in his highly Bundled copy of TextMate, but happily the slides contained complete listings of everything he did. It will be easy to refer to them for review going forward.

Groovy Metaprogramming, by Jeff Scott Brown. Mere minutes before I left the home office for the start of the conference, I was coding an ugly hack to work around a “bug” in a Groovy MarkupBuilder I was using to render some XML in a Grails action. The darn thing wouldn’t emit XML for an element called “phoneNumber,” and I couldn’t immediatley figure out why. I hacked it into submission in a most shameful fashion, realizing there had to be a better way, but not knowing what it was. When Jeff covered closure delegates, I smelled something promising, but when he went over Builders, I knew I had my fix. I actually changed the code right there in the session and committed it to the SVN repository (not yet having sufficiently internalized Stu Halloway’s Git talk). Thanks, Jeff!

I already knew a fair amount of the Groovy metaprogramming material besides that, but this fix was definitely worth the price of admission.