No Fluff Just Stuff

A few weekends ago (November 14-16), I attended the No Fluff Just Stuff software symposium. It was a three-day long event with some of the best and brightest in the Java, open source, and engineering-in-general space. I took a lot out of this conference, and I’m looking forward to going again in the near future. One of the great things about going to something like this is watching how the touring speakers use different tools. Even with applications that I use on a regular basis (such as TextMate), I was able to pull some new uses and features from the presentations. Here is my take on the sessions I attended:

  1. Groovy: The Blue Pill – This was the first talk from Scott Davis on Groovy. It was designed to be an easy introduction to the Groovy space for current Java developers. Some standout information:
    1. Groovy compiles to Java bytecode
    2. Groovy consists of only one .jar file
    3. Groovy includes a lot of Java cruft built in for free (such as automatic getters/setters, default constructors, etc.)
    4. Groovy can easily call Java methods and use Java objects
    5. Groovy can use inline values in Strings (called “G”-strings)
    6. You can easily insert XML, JSON, HTML, etc. into a Groovy string using triple quotes
    7. Unit tests are a great insertion point to begin integration of Groovy into a Java application (but Groovy currently only supports JUnit 3.x and not 4.x)
  2. Groovy: The Red Pill – This was the second talk on Groovy from Scott Davis. This talk was intended to demonstrate the real flexibility and power of Groovy rather than simply touting its interoperability with Java:
    1. Groovy can use “Groovy truth” which allows statements such as
      if(array) {}
      rather than
      if(!(array==null || array.isEmpty())) {}
    2. Groovy supports operator overloading
    3. Groovy supports closures and has some great support for iteration through collections
  3. Rapid Web Development with Grails and AJAX – This was the third talk on Groovy from Scott Davis which covered how Groovy and Grails integrate to create an incredible web application development experience. Unfortunately, much of the AJAX information was cut short due to a guy in our session asking a bunch of “Rails vs. Grails” questions. Some good points:
    1. Grails was inspired by Rails but is not a clone of Rails
    2. Grails is a full-stack solution and not simply a framework like Struts or Spring MVC
    3. Grails is database agnostic and supports practically every Hibernate dialect available
    4. Grails has some great IDE support
    5. Grails has great built-in AJAX and scaffolding support
  4. Give It a Rest – This was Brian Sletten’s first talk on REST (Representational State Transfer). I have a fair amount of practical experience with REST API’s (creating, consuming), but this was a great talk about the goal of a REST API and how it relates to an application as a whole.
    1. SOAP is overkill in many situations and increases complexity
    2. Over 85% of Amazon customers prefer to use the REST API rather than its SOAP counterpart
    3. REST is more than just URLs
    4. REST focuses on information spaces rather than code or objects
    5. REST can use HTTP return codes to dynamically point to moved resources
    6. REST uses HTTP verbs to indicate the desired action
    7. Since REST uses HTTP, it is stateless and takes advantage of built-in browser caching to reduce server overhead
  5. Spring 2.5: Spring without XML – This was Ken Sipe’s talk on Spring 2.5 without the XML-hell that many of us Spring 2.0 developers are wading through. I don’t currently use Spring 2.5, so it was difficult at times to follow where Ken was going. However, I soaked in a lot of the capabilities of Spring without XML and finding out exactly “how” to do something is much easier than the information gap of knowing if it is possible or not.
  6. Java.Next – Stuart Halloway spoke in this session about all the different languages that are making their way into the JVM. Most of his talk was simply about why this is happening and why it is good for the Java community (and, trust me, it’s very good for us!) I didn’t take too many notes during this session, but he definitely convinced me (although, to be honest, Scott Davis’ sessions on Groovy had me convinced already)
  7. Architecture and Scaling – This presentation, by Ken Sipe, was an outstanding pragmatic approach to creating an easily scalable application. Some good points:
    1. Scalability is about predictability (e.g. if you know what a load looks like with 200 users, you should know what it looks like with 400)
    2. Scalability can be horizontal (adding more nodes) or vertical (adding more resources to a node such as increased memory or CPU power)
    3. Performance is not equal to scalability. You often have to sacrifice up-front performance gains to make room for future scalability (one example great Ken used was a load balancer. Load balancers introduce latency to a project, but allow for multiple nodes to be inserted and, therefore, increase scalability)
    4. An engineer should always be trying to manage things outside their control (e.g. user behavior)
    5. Metrics are good; use them
  8. Git – Another Stuart Halloway talk revolving around the new SCM system called git. While I was already a bit familiar with git, this talk intrigued me enough to find an environment whereby I use it on a regular basis and can put it through its paces.
  9. Introduction to Hibernate – Scott Leberknight’s talk on Java Hibernate.
    1. Hibernate is a very popular open-source ORM framework
    2. Hibernate uses dialects to talk to a database
    3. Hibernate uses annotations to communicate relationships between objects (one-to-many, one-to-one, etc.)
  10. Rich Clients, Rich Data Linking and Consuming – These were the last couple of talks of the conference by Brian Sletten. He expanded on REST concepts and showed how RDF can be used for some pretty amazing data combinations. He also encouraged projects to move beyond their silos and expose their data to the rest of the web. He had some amazing examples of this sort of exposure, and I am excited to put some of his ideas to use at some point.

The conference was pretty amazing and I am very happy to have gone. In addition to the sessions above, there was a great keynote by Ken Sipe about inter-relational skills engineers should strive to build. A great quote from this keynote:

Your employer is responsible for your job; you are responsible for your career

Advertisements

About johnnywey

Welcome to A Regular Expression. This blog is designed to reflect my thoughts on life, music, software design, Apple, faith, philosophy, and whatever else I can think of.

Posted on December 6, 2008, in Java, Programming. Bookmark the permalink. Leave a comment.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

%d bloggers like this: