James Carr

DesignFest at OOPSLA

I attended OOPSLA back in 2006 and was very impressed with the program… I got to meet a lot of big names in the software design and development community, met a lot of authors who’s books helped shape my software engineering mindset, and overall had a great time and learned a ton of new things. I even learned of db4o and AOP for the first time. For these reasons alone I decided to revisit OOPSLA a 2nd time.

First let me cover what I loved about the conference. It’s almost absent of “vendorness.” You get a lot of close interaction with a lot of smart people, and in retrospect I think that I enjoyed the conversations and new contacts I made over any of the sessions I attended. Likewise, some of the sessions were very good too… I especially liked Linda Rising’s session on initiating change in your organization. The only sad part is I missed Rebecca Wirfs-Brock’s sessions on design. I opted out as I had a co-worker attend her sessions, only to find out my co-worker finds design and UML diagrams boring. At least I did attend Rebecca’s keynote on Design, which was top notch.

This year was quite a bit different from the last time I went back in 2006 though. Noticeably, the attendance was a lot smaller. I think it was due to this smaller attendance that the sessions offered were somewhat limited and very specific… there were times when I was confused about what I should go to as there wasn’t anything scheduled in that particular block that interested me. This year also had a bit too much focus on DSLs. Yes, DSLs are awesome and hip and very very useful, but as someone just delving into them, there’s only so much I could absorb. Likewise, I was really hoping to attend more AOP sessions, but alas there were none (there were workshops, but no real tutorials or sessions).

I think OOPSLA needs to evolve a bit if it wants to continue and thrive. To me, it’s been a conference that brings together the top minds, engineers and developers in our industry to help improve and nourish our community. It’s a conference that one should be able to learn a lot from as well, so no matter how much our industry advances, we need to keep the barrier to entry small. Also, I think it’s the only conference I have attended that charges an arm and a leg for tutorials… although one can buy an all access pass, why not just be like Agile or other conferences and include unlimited session attendance / participation in the conference price?

I think a lot of people would like to see more modernism… there’s a lot of events and sessions around smalltalk and lisp (which is cool because I learned about Squeak at OOPSLA in 2006) but you won’t find many sessions or talks centered around javascript, groovy, ruby, or other interesting languages. The web facing portion of the conference is also quite absent with only one or two tutorials. Sadly, there was also no domain driven design sessions either.

I think the conference will survive though… and again one thing that marks today’s OOPSLA from OOPSLAs of years past is that a lot of the topics born or covered there have spun their own targeted conferences that draw large attendance numbers, and even those focus areas have many conferences.

In closing, I would like to say that Gail Harris DID do a great job of organizing the conference, and the Big Event at the Parthenon was completely awesome. I was also quite pleased that there were a few functional programming sessions mixed in as well. Although I plan to attend more web / agile based conferences next year, I am still going to try and attend OOPSLA yet again next year in Orlando… because despite any shortcomings, it’s still educational and fun!

Whew this session was a tough one for me to decide on what to go to. As I had previously mentioned, Ted Neward was giving a presentation on Scala this session. Jeff Brown had a session on using Groovy for builds. Nathaniel Schutta is presenting part two of Designing for Ajax, which would cover “advanced ajax” concepts including offline Ajax apps with Google Gears.

When it came down to it, I had to flip a coin to decide whether to go to a session on Scala or a session on Ajax… and Designing for Ajax won. Luckily I did convince a few friends to attend the Scala session though, so at least I played a small part in accelerate it’s exposure.

Anyhow, right off the bat what I like about the session. He covered CSS Selectors. Using CSS selectors to get what you want from your html document is probably THE most important skill you can have when working with javascript. Let me drive this point in… almost every single major javascript library provides some kind of support for CSS Selectors. I think it’s great that Nathaniel exposed everyone to this and mentioned my favorite library, jQuery (which is practically built on CSS Selector querying). Good stuff, good start… a lot of people were awed when they saw the simplicity of using CSS Selectors!

A lot of the session was dojo/prototype based, but very pleasing. Demos were given for achieving “in-place editing“, using Lightbox, and others. Google Gears was also covered briefly using the dojo offline toolkit… although I wish I could have seen a little more of it, but only because I have only scratched the surface of Googe Gears already and wanted to see more.

What Made Me Smile

A lot of developers these days, and even many book authors, will cop out and focus on programmatic aspects and ignore good, structural html… often opting to leave a bunch of crap invalid html on the page and passing a bad practice on to others. Nathaniel’s html was very structurally clean and made sense, using label tags for labels (with for attributes). People learning from his examples will possibly construct better html too.

What I Got Out Of It

I admit I was a little scared… once he covered Google Gears and left it, I was afraid I had chosen another session where I already knew the subject matter being presented well. Luckily I learned a few things about prototype and dojo that I hadn’t previously known. Of course anytime developers are proven that good, clean, and efficient javascript can be written, I’m happy. The common stereotype is that java developers HATE javascript, seeking out frameworks and tag libraries to generate it for them and complaining or cringing when they hear the word “javascript” mentioned. Seeing developers brace this great language more (while being aware of the pitfalls) is a great goal.

As an aside, I’m amused that all of Ted Neward’s sessions begin with “The Busy Java Developers Guide To…”, I guess that’s because us Java developers are always busy since we over-complicate everything.

Anyhow, the session started with Ted’s usual wit and humor, and then moved on to exploring the tools available for hacking the JDK. The first one delved into? JConsole. I had previously gotten a glimpse of JConsole at Ken Sipe’s session on Spring and JMX to manage and view MBeans… here I got to see in depth all of the possibilities JConsole provides… how did I miss it? Had I been sleeping the past couple years (the short answer to that is yes)?

Did you know you can grab a snapshot of the java heap? Change runtime configuration while the application is running? It’s almost scary when you think of all the possibilities and extremes you could go to with it. It’s really cool that you can use OQL to query the heap for different objects and get all kinds of information on their state at the time the snapshot was taken.

Unfortunately my laptop battery is about to die, so I’ll follow up this post later.

Bleh… Sunday mornings can be a little rough, and the No Fluff Just Stuff conference is no exception… I feel literally beat. Luckily Jeff Brown’s session on Grails was able to keep me awake.

I’ve dabbled with Grails a little before, but never really got into it and explored it further. Jeff gave a very good overview of Grails and a demo throughout the presentation on how easy it is to set up and run an application with Grails… it’s refreshing to see how easy it was. What interested me was the way Grails handles TLDs… no TLD files all over to manage.

Good stuff… the problem with the last day of NFJS is there’s almost too much good stuff going on.. .throughout the day it’s going to get harder and harder to figure out what to go to next.

Michael started the presentation off with giving us a rundown of hosting/startup options throughout the years, breaking down the costs of each approach. He basically grouped them into four categories:

Right away he had something new that kind of blew my mind…. EC2. The idea was to harness the processing power available to you from cloud computing for your site and gave an example of how to quickly create your own server image.

With this done, he walked us through a very small GWT application and an associated ANT build script for it, then deployed it and we could even go view it at the provided url (I had this on here earlier, but removed the link since it was only up for the presentation). All up and working in 15 minutes. In only 10 more minutes he also setup Nagios .

Thoughts

I thought it was just really cool how fast you could get a site up and running and the amount of configurability that you had with EC2. You could install virtually anything on it and do anything… it was just like your own linux server. Also great was that you could take advantage of clustering with minimal hassle and fees. It just really blew my mind what you could do… my friends and myself just felt like getting out of there, getting an EC2 account, and start coding right away… it seems like Michael has that effect.

Today I decided to be a bit pickier with the sessions I attended. I was going to go to Scott Davis’ presentation on Real World JSON, but decided against it since I already use JSON extensively and know how to serve it up from the serverside (as well as tools to nicely serialize/unserialize domain objects as JSON). Ditto on Ted Neward’s presentation on annotations… we’ve been using them a bit for runtime level behavior. So I decided to attend Alex Miller’s session on Design Patterns Reconsidered. Good choice.

Basically he covered four well known patterns: Singleton, Template Method, Visitor, and Proxy, looking at their pitfalls and possible ways to avoid those pitfalls. The first pattern explored was singleton.

Singleton in my opinion was a good pattern to start with… its the easiest and most widely used, which why its an easy target for abuse. The biggest problem? Singleton introduces a hidden coupling in the way it’s used. How am I supposed to test this class if it uses a Singleton somewhere that hits the database? ARGHHHHH!!!!!

The solution Alex presented was interesting… extract an interface from your Singleton and specify the user of the Singleton as a “Victim” and provide access to the Singleton via Dependency Injection using the interface. He tied this up by using Guice to show how effortless it can be. But his final comment on it? Just don’t use Singleton. Might have been a joke, but that’s something I agree with… 90% of the time when you use Singleton it’s only because you cant figure out a better way to get access to a resource throughout your application and you soon find yourself bitten by the choice of using it later.

I’ll post more on Template Method and Visitor later… but overall it was a very good presentation and drives the point that we really need to question how we use Design Patterns… we need to identify and get around the pitfalls that can arise when we use them.

Basically I went to this session since the last one from Ken Sipe was pretty good. As I came here though, I had no idea what the heck JMX is. Thankfully the first part of the presentation covered what JMX is, since of course you need to know what it is in order to even think about leveraging it in Spring.

So what is it? JMX was defined in JSR-3 (recognized need early and very mature) and defines monitoring services with notification services. It’s also a core part of JDK 5. There’s an evolution of JMX through multiple JSRs defining good things such as remote APIs, JVM monitoring and management, Deployment API, etc. There’s a lot out there on it… essentially JMX is just an API that provides gauges that allow you to just monitor all kinds of things going on your server/application.

Creating an MBean is pretty straightforward… create an interface that ends with “MBean” (However, with JMX 1.2 you don’t need to have the name end with MBean) that defines a set of methods for the publicly exposed API and a concrete implementation of the interface. Then you just register it with an MBean server (”just” … it can be slightly involved). The example given was a bean that reports number of active threads, free memory, and totaly memory. MBeans are commonly viewed from an administration console.

Types of MBeans:

Dynamic MBeans

Any MBean that is dynamic

Model MBeans

Extends ModelMBean interface, which extends the Dynamic MBean. It provides a generic template for managing resources and is very dynamic.

Open MBeans

Dynamic MBean which follows specific rules. These rules help promote interoperability.

The first half pretty much covered everything related to JMX and MBeans, but what I took away from it is you can use JMX to create monitoring services and notification services for your applications (Ken was able to setup SMS and Jabber notifications). This interests me… there was some weird and cryptic MBean menu in Cruise Control I had no idea what it was before. Now I know. And now I can do some very nifty stuff with it.

Where Does Spring Come In?

Spring takes away the pain of creating/registering MBeans. Although it’s hard for me to describe the difference, the first examples of “the old way” of creating/registering MBeans looked slightly complex and convoluted… the Spring way allows you to just any object (you don’t need an interface to implement) and make it an MBean as well as some “automatic” detection schemes.

Overall, nifty stuff. Uses? I might find use in this by writing some MBeans to allow me to get SMS messages when VERY bad things happen in my next JEE application.

Now this is a session that by just glancing at the title and the slides I know it’s going to be good. My co-worker Phil HATES Spring mainly because he hates XML files (at least from what I’ve noticed from his knee jerk reaction when he sees an XML configuration file). So, I’m ready to learn something about Spring 2.5!

The presentation has started off exceedingly good… Ken Sipe started the session by finding out what the need of the audience as he began the presentation. With a quick overview of the frustrations of Spring 2 (autowiring feeling too “magical”, long XML, required injections), what’s going away, and what started, Ken began moving towards the meat of the presentation: Annotations.

Spring 2.5 has a ot of annotation support, both for it’s own annotations as well as JSR-250 javax annotations, EJB annotations, and many more. Of interest is the @Repository annotation, which indicates a class functions as a repository and proxies it, converting any checked exceptions to unchecked exceptions.

Aspects

There’s a new pointcut for pointcuts in Spring 2.5 that allows pointcuts for beans as well as both vertical and horizontal stack selection (i.e. accountController -> accountService ->accountDAO). These are Spring only and not for AspectJ.

Stereotypes

He abriefly covered the Stereotype annotations that indicate “class types.” These include @Component, @Controller, @Repository, and @Service.

Factory Annotations

@Autowired is the first one mentioned… and for good reason. This annotation, as the name implies, implements autowiring of fields, constructors, setters, or config methods. There is also a lot of fine grained control over the autowiring. The @Qualifier annotation both qualifies a bean for autowiring and also allows for customization.

@Required marks a method as being “injection required.”

javax Annotations

What was noticible here was the @Resource annotation, which is used for injecting named resources (must be the Spring name, not the JNDI name). It’s also a debated whether to use @Resource or @Autowired … it’s up to the teams.

Thankfully at this point Ken stepped back and pulled up a demo making use of these annotations… pretty nifty, and it was quite interesting to see how this all glues together in a simple easy to follow application. The nice thing was that although an xml file was there, it only had 3 entries in it (a comparable example with everything in his app in Spring 2.0 would easy be a few pages of XML). The coolest thing I saw here was the autowired method names could be changed and they still got injected perfectly fine.

Spring MVC has a lot of nice annotations for configuration/specifying input/output, but I’m not into Spring MVC much… maybe I’ll come back and cover it later. Looks solid though.

The reduction of XML was covered even further… such as using <context:component-scan/> to include/exclude classes as beans. This was covered lighty… this just helps reduce the ammount of beans you need to define. You can also jsut move some properties out of XML… <context:property-placeholder/> is useful here… you can just specify a property file, which simpler and more concise than XML).

Spring with NO XML

You can use Java based configuration. Just marking a class as @Configurable allows you to just use the class for getting beans. Also, you can write your own parser that uses something besides XML to define configuration. This isn’t new though… its been around for Spring 2.0.

Auto-Discovery is where the meat is… you can set up a scanner that simply scans your packages and refreshes the context with the beans that currently exist. NIFTY!

All in all it was a very informative and fun presentation… I think I may attend the next session with the same presenter.

So, I chickened out of attending the Spring + JPA + Hibernate session… party because I know how to use it a little and partly due to the knowledge there would be strong pushback since we had previously used Hibernate at work. With that in mind, I decided to attend Developing Rich Internet Appications with Richard Monson Haefel.

The beginning was a little boring… but only because I wasn’t learning anything new… but I am sure it was interesting for those who were completely new to rich internet applications and wanted an overview of what was availble. I did learn one thing interesting though… JAWS, the java based screen reader for blind people has the capability to read applets and flash (specifically, Flex) applications. Something interesting to note when it comes to accessibility and section 508 compliance… although I still refrain from Flex due to the “plugin problem” … but it may be useful if developing a rich application that transcends the basic web technologies (video comes to mind).

A little interest was picked up midway when he introduced Silverlight and XUL. Silverlight has became interesting with Nokia’s announcement of supporting Silverlight on SymbianOS so it will definitely see some more market penetration in the future. I was very pleased he mentioned XUL… not too many people are aware of the application framework built into firefox. It seems like some have almost forgotten completely about XUL.

Curl was new to me… I had heard of curl before, as cURL. I almost hate the framework already for making me confused why a library for fetching content from remote URLs on linux is being presented as an RIA. But I’ll give it a look.

The presentation ended with a comparison of the different RIA available, the pros/cons and things to consider when choosing which is best for your application.

What I’d Like to Have Seen More Of?

I would have liked to see a lot more demos of “AJAX” toolkits…. I wanted to feel awed again like I did the first time I saw ExtJS or Script.aculo.us. I wanted to stand amazed at what was being shown to me. I didn’t get that feeling… for me it felt like 2005 all over again.

I also would have liked to see some more frameworks in the client/server space. AJAX has blurred the boundry between web applications and desktop applications, even more so with applications built for Google Gears or Adobe AIR that allow applications based on javascript, HTML, and CSS to run offline, without a dependency on a server, or use a server in the traditional Client/Server sense.

Ending Thoughts

The first day of NFJS (especially the first sessions) is usually geared towards people who haven’t heard of these technologies… in fact there were a lot of people in the presentaton that asked lots of questions and probably got a lot out of it. For someone developing AJAX applications since 2004 it was kind of a poor choice (unless you took a prolonged break and didn’t know what is out there now).

I’m at work finishing up some emails and waiting for the morning huddle to communicate a few things to my team, then it’s off to St.Louis for No Fluff Just Stuff …or as Than keeps calling it, “No Stuff Just Fluff.”

I’ll be posting live from the conference for anyone interested in the content of the sessions that I’ll be attending. Looking over the schedule, it looks like today’s sessions will be a little “light”, but only because I’m familiar with the technologies being discussed OR I have attended them in the past. For example, I have no need to attend yet another introduction to JSF… nor do I need to find out about GWT, dojo, Adobe Flex (I already know and use these!). And of course… how many groovy sessions have I attended? I have 2 Groovy books and a Grails book on my bookshelf, but I MAY still attend one of the sessions on groovy again.

Anyhow, here’s my projected schedule for today, subject to change:

Spring+JPA+Hibernate: Standards Meeting Productivity for Java Persistence by Ken Sipe

Well the standards created EntityBeans…. yea. and the community created Hibernate. Fortunately the standards body learned some lessons and created JPA. JPA requires a vendor implementation and none make a better choice then Hibernate. Combined with Spring this trio is a powerhouse when it comes to developer productivity on applications requiring persistence.

Spring 2.5 - Spring without XML by Ken Sipe

Spring 2.5 is brand spanking new, with a number of fantastic features. With growth of large and complex Spring applications which struggle with xml manageability and with the added pressure of Guice and SEAM there is a push for less XML, with solution leaning towards annotations. Spring 2.5 adds to the toolset provided in Spring 2.0 to provide a development environment where XML is greatly reduced… or eliminated if you so choose.

Grails for (Recovering) Struts Developers: A Groovy Alternative by Scott Davis

Struts enjoys an unprecedented marketshare in the Java web development space — 60%-70% according to most surveys. As newer, modern web frameworks come to the scene, very little attention is paid to the real costs of migrating an existing Struts application. This talk shows you ways to mix Groovy into a legacy Struts application, dramatically reducing both the lines of code and the complexity. We’ll also introduce you to Grails (a Groovy-based web framework) whose URL-mapping capabilities allow it to replace your Struts application without breaking legacy URLs.

On an unrelated note… I put in a contract on a house last night. If everything goes according to plan, I’ll be moving into my very own house April 2nd (I couldn’t close on April Fools Day )! Suffice to say I’m very excited… although I had a bit of doubt in my mind because I kept thinking “what if I get an amazing job offer? Then I have to sell it!” But decided to settle. Let’s think about it: I have a pretty good job that I love, friends that are great, a decent salary, and a town that is a great place to live. What if I live here for 5 more years? I don’t want to keep living in an apartment based on a mistaken assumption I may some day move.. and besides, I think my next job would have to offer enough that selling my house is the least of my concerns.

Anyhow, come April 2nd I (should) have my own chunk of land that I can call my own. WOO HOO!!