No Fluff Just Stuff roundup

This past weekend, the No Fluff Just Stuff event came to town, and this humble .NET author infiltrated the Java ranks.  This was my first NFJS event, and first of any Java event.  In fact, I’ve never opened Eclipse or wrote a single line of Java.  However, I’m extremely interested how other communities are solving the same problems as us (the .NET world), so I was really looking forward to seeing what kinds of innovation were coming out of the Java space.

The really interesting observation that I found that while in some respects the Java community has moved past many of the issues the .NET community faces, in some respects they are replaying the same mistakes.  And, like all conferences, I couldn’t get to all the sessions I wanted.  Here are the ones I could get to:

Friday

The NFJS seem to abhor pointlessness.  This was no less evident in the opening welcome, which lasted ALL OF 15 MINUTES.  Real quick, “thanks for coming, our agenda is on the back of your nametag”.  No lovey-dovey, hippie kumbayas, nor any narcissistic hero-worship keynotes.  Very refreshing.  Instead, we jump straight into the first session.

Domain-Driven Design and Development In Practice – Code Generation, Srini Penchikala

I came in with high hopes, but left a little disappointed.  The premise behind this talk was that DDD requires a ton of boilerplate code.  Entities, DAOs, Repositories, Hibernate configuration, and so on.  This would be a lot of work for developers to do, and with a large workforce, DDD would be hard to try and implement company-wide.  The creation of the boilerplate code would come from the business, in the form of a specification of “here are the nouns, and here are their attributes”.

But if code generation is really a solution, why not go with a convention-based framework that doesn’t need boilerplate code?  After all, the applications where DDD really shined for me is where there were no opportunities for boilerplate code as the domain was complex!  This is also the conclusion of the presenter, who at the end of the talk, basically said, “or you can use one of these convention-based frameworks like Rails, Django, Grails, etc. etc.  At that point, it looked like trying to use a screwdriver to hammer a nail.

Test-Driven Design, Neal Ford

First off, Neal is an awesome presenter.  In his talk, Neal demonstrated a very simple feature, and TDD influences design by showing both a Test-First, and Test-After approach.  The problem was to determine if a number is a perfect number.  The Test-After approach yielded something very familiar – a single static method, filled with special cases.  It wasn’t too terribly hard to understand, but seemed rather complex.  With the test-after approach, design issues were forced very early, yielding a much different result.

What’s even more interesting is the effect TDD had when a new requirement came up – deficient and abundant numbers.  TDD elicited a more flexible design, not intentionally, but because simple, testable designs are easy to adapt.  Neal then promptly went off the deep end, advocating reflection to test private members.  No.

If you ever get a chance to catch Neal give a talk, I highly recommend it.  Neal is a great speaker, and teacher.

The Productive Programmer, Neal Ford

Encouraged by his TDD talk, I stuck around for Neal’s talk on being productive.  This talk was divided up between mechanical strategies, using tools to work for you, using the keyboard and so on, and strategies with habits, such as not checking email every 5 minutes.  One of the more interesting ideas was the idea of a “quiet time”, where between the hours of 9 and 3 (excluding lunch), email, IM, Twitter, RSS readers and so on were switched off for greater focus.  It took quite a bit of discipline, but I did find myself concentrating a lot more.

On the flip side, I found myself needing to take regular breaks to get up and walk around.  I could keep a mental flow state for about an hour before I needed physical exercise to give my brain some rest.  All it took was lots of liquids to have some biological encouragement to do so.  This was quite the firehose session, so I gave up notes after awhile as Neal’s slide deck contained all the reference I needed.

Friday ended with a keynote from Venkat Subramanian.  While it was entertaining and informative, I don’t remember a single thing from it.  Other than Java developers seem to have a self-loathing aspect.  They seem to love the Java platform, but not the Java language.

Saturday

Saturday presented a lot of opportunities to learn how Java developers deliver value, so I tried to expose myself to as many completely alien ideas as possible.

GWT: An Introduction, David Geary

I’ve heard of the Google Web Toolkit, but never looked any further other than wonder why it was the same acronym as Given When Then.  The idea behind GWT is to create AWT/SWT/Swing-like applications (think WinForms) in a special version of Java, and have it compile to JavaScript.  Java compiled to JavaScript, quite interesting.  GWT has a lot of widgets out of the box, and it would be quite similar to developing WebForms applications in C# that compiled to JavaScript.

This meant that you could develop in a language you understand well, and have guaranteed cross-browser JavaScript support.  Interesting idea, but I haven’t built component-based websites in a while, and I quite like HTML and JavaScript.

Because jQuery is awesome.

Groovier Spring, Scott Leberknight

Groovy is an interesting language, as it is a dynamic, scripted language that can talk and be compiled to Java.  The other interesting thing is that straight-up Java can be compiled into Groovy, providing a nice transition to a dynamic language.

Combined with Spring, all I heard was this:

Except replace “Malkovich” with “annotations”.  The evolution of Spring, evidently, is to litter your code with annotations (i.e., attributes).  There were a few interesting ideas here, such as using IoC to inject scripts for dynamic behavior.  The example given was document generation, where you could load scripts into the database, and IoC would automatically get the latest script.  Because Groovy plays well with Java, it all worked out.

Real World Hibernate Tips, Nathaniel Schutta

I got nothing out of this one, except to note a few Hibernate features that aren’t in NHibernate, yet.

Git Going with Distributed Version Control, Matthew McCullough

A great “getting started” presentation for Git, this one had me convinced.  Most of the presentations I’ve seen so far focus way too much on the “how”, but hardly any on the “why”.  Matthew walked through scenarios showing how distributed version control would not only mitigate some issues, but other issues would completely drop off.

Interestingly, our team is now practicing Branch-Per-Feature, with Hudson as our branch builds, and Git could really help us out there.  Other places it can help is where I’m driving down a refactoring, and some defect comes in.  I could easily commit a branch, roll back to trunk in a snap.  I’m planning on running on Git myself for a week or two in a pilot program of sorts.

Sunday

One other interesting thing behind NFJS is that neither Saturday nor Sunday had any kind of opening welcome.  It went straight into sessions.

IZero: Starting Projects the Right Way, Stuart Halloway

IZero, or Iteration Zero, are all the things you need to do before you start writing software.  This talk wound up being a session on Q&A on how Stuart does agile.  It’s always interesting to see how other folks do Agile, but there’s nothing really that interesting to report here.

Taking Agile from Tactics to Strategy, Stuart Halloway

This was a far more interesting talk, as much of Agile talks only about running iterations/releases.  But, lots more needs to go on outside of that.  During this talk, I ran into an old colleague in the hallway, so I need to review this talk again.

Hacking Your Brain for Fun and Profit, Nathaniel Schutta

For once, it was nice to get a session that had absolutely no code, or the word “agile” in its premise.  This talk centered around how we can be more productive, and went over things like sleeping habits, exercise, and how our daily habits affect our effectiveness at work.  It was and entertaining talk, and pointed me to quite a few new books to check out, Such as “Brain Rules”, “Pragmatic Thinking and Learning”, “Outliers” and more.

Also, the book du jour was “Daemon” – which I highly recommend.

Programming Clojure, Stuart Halloway

Stuart is an excitable guy.  Get him talking about Clojure, and he’s real excitable.  Clojure is a Lisp, with again interoperability with Java.  It was more insight into functional languages, and how we can blend strengths of multiple languages on a single platform.

While all of the functional features of C# are nice, having something like F# as a first-class citizen in .NET rounds out the development story.  .NET should never be about C#, as all languages have their strengths and weaknesses.  Stuart showed quite a bit on how Clojure blew languages like Groovy, Ruby and Java out of the water.

Wrapping it up

NFJS was a great conference because of three reasons:

  • The speakers were excellent
  • The facility was excellent
  • The organizers were excellent

I plan on attending at least one non-.NET conference a year, and I hope more in the .NET space do so as we mature as a community.  Every community runs the serious risk of becoming an echo chamber.  But as languages are shared more and more across platforms (Ruby is a great example), these barriers are broken down more and more.

One other thing NFJS did well was spacing out talks.  Instead of trying to cram everything in one long day, talks actually had BREAKS between them!  Imagine that.  It set a much more reasonable pace, and allowed for conversations between talks.

The other big impression I got was how much Java developers seemed to move beyond Java as a language to Java as a platform.  This has always been one of .NET’s strengths, and pushing more languages as first-class citizens and rounding out the interop story will allow .NET to innovate in far more areas.

Related Articles:

    Post Footer automatically generated by Add Post Footer Plugin for wordpress.

    About Jimmy Bogard

    I'm a technical architect with Headspring in Austin, TX. I focus on DDD, distributed systems, and any other acronym-centric design/architecture/methodology. I created AutoMapper and am a co-author of the ASP.NET MVC in Action books.
    This entry was posted in NFJS. Bookmark the permalink. Follow any comments here with the RSS feed for this post.
    • Oliver

      I attended some of the same sessions. I agree code generation did not provide any interesting detail. Neal Ford and Venkat are great speakers. I agree with you going to .Net, Java and ruby makes a difference by seeing solutions to the same problems in different arenas.

    • http://lazycoder.com Scott

      I’ve been toying with GWT a little bit. It’s an interesting idea, especially for the “No magic strings EVER!” crowd. The idea of being able to develop a GWT app and deploy it to Google AppEngine is appealing. Except for the Java part.

      I found this a while back, haven’t tried it yet though. jQuery for GWT.

      http://www.gwtsite.com/gwt-jquery-gquery/

    • http://srinip2007.blogspot.com Srini

      Jimmy & Oliver, I want to thank you for attending my session on Model Driven Development with Code Generation. This is the 2nd part of the DDD series in NFJS presentations. In the first part (http://www.nofluffjuststuff.com/conference/boston/2009/03/session?id=13766), I discuss more about the design and development of a real-world DDD application. This 2nd part is more about the implementation of the DDD effort, with focus on how auto generation of Java code and configuration files can help the developers concentrate on the domain model rather than the infrastructure/boiler-plate code. We couldn’t use a solution like Grails as we are a Java shop, so the code generation was a good solution for us.

      I agree with you between auto-generation and convention-over-configuration frameworks like Groovy/Ruby, I would definitely go with the latter option. But when we had to pick a solution between hand coding and auto-generation, we chose the code generation option.

      MDD and Code Generation concepts are still valid in both Java and non-Java development environments.

    • http://srinip2007.blogspot.com Srini

      I forgot to mention in the previous comment, about the Domain Driven Design article I published last year on InfoQ. The article title is “Domain Driven Design and Development In Practice” (http://www.infoq.com/articles/ddd-in-practice); it covers the domain modeling and design from a practical stand-point on how one would go about taking a domain model and actually implementing it. I discussed various aspects that the architects and developers have to deal with when working on a DDD project.

      Let me know if you have any comments on the article as well as the NFJS presentation for improving the technical session.

    • Eyston

      “The really interesting observation that I found that while in some respects the Java community has moved past many of the issues the .NET community faces, in some respects they are replaying the same mistakes.”

      You mean .NET is replaying mistakes Java has moved passed right?

      “They seem to love the Java platform, but not the Java language.”

      My personal finding is that I love C#, envy bits of the Java platform, but don’t want to write Java because C# is just better. I would probably envy the Java platform more but the .NET platform has really made use of C# 3.0 that writing code is more enjoyable if even a bit lagging behind in features. Of course .NET platform is maybe ambiguous.

      “This has always been one of .NET’s strengths, and pushing more languages as first-class citizens and rounding out the interop story will allow .NET to innovate in far more areas.”

      I agree that having more specific languages is great, but I’m not sure I’ve seen it historically as a strength? I mean yah, C# and VB.NET co-exist, but all the other languages are pretty young and in very limited use (currently). I don’t see .NET really being much ahead of Java in that regard.

      I think targeted languages are a good thing though. I like that C# continues to evolve, but wonder if some parts of 4.0 you would be better suited to just use a different tool.