:Running Down the Way Up » java

Erich Gamma on Flexibility and Reuse

jc — Tue, 31 May 2005 14:56:37 +0000

Artima is publishing a series of articles with Erich Gamma. Part 2 is out and it is an interesting conversation regarding flexibility, reuse and frameworks.

Of particular interest are these bits:

“We prefer many small frameworks over one heavyweight framework.”
…
“Because the bigger the framework becomes, the greater the chances that it will want to do too much, the bigger the learning curves become, and the more difficult it becomes to maintain it.”

This makes sense, and it contrasts what I’ve experienced. However, doing this is far more difficult then it sounds. Smaller frameworks allows for more choice and plug-ability, but you have to have an intelligent and productive team to understand how to take advantage of this flexibility without getting bogged down with all of the choices.

On the other hand, a larger framework that does everything can have its merits, especially when there is a team of people that need to use it. It creates conformity. However, to me this is just an initial benefit. As the framework grows in complexity and strays from its core functions, the less benefit it starts to produce. As Eric states, it becomes harder to maintain, and harder to learn. But when do we know this is happening? Is there a clear indicator?

Just how dynamic can you get?

jc — Fri, 29 Apr 2005 00:04:16 +0000

I’m extremelly interested in figuring out how to integrate scripting languages that run on the JVM to make java application development (in particular web apps) more dynamic.

Stopping and restarting containers to add functionality is something that I can no longer accept. Being able to make changes to functionality without recompiling or repackaging is also something that i can no longer accept. Starting to sound like Ruby eh?

In today’s world you need to be able to respond to change ever more quicly then before, regardless of how often times such a request that causes a change is completly insane. If your customer needs a change, you better be able to give it to them or they’ll find someone else who isn’t so stuck up in their “properness” to do it.

This doesn’t mean that I believe it is ok to abandon proper practices and approaches, but I do think that there is more that I as a Java developer can do to allow my applications to adapt to change quicker.

Integrating dynamic scripting languages that run on the JVM like Rhino, Groovy, JRuby or Jython, is one way that I believe this can be achieved. For example, why write a struts action in a java class? Why can’t this be done with a script?

The good news? Others have thought of this. Struts has an extension to support BSF, Spring has Groovy support as an alternative way to wire up dependencies (tres cool). A little bit of this, plus a good dose of convention over configuration, may just go a long way.

Or maybe i should just use Ruby

Eclipse web tools 1.0M3 available for Download

jc — Mon, 28 Feb 2005 07:13:29 +0000

There is a new release of the Eclipse web tools project. If you don’t already know, its essentially the tools that come build into WSAD but opensourced and now part of the eclipse project. get it here and watch out for all the extra files you need to download.

zero configuration with hibernate?

jc — Sun, 27 Feb 2005 14:05:59 +0000

When looking into Ruby on Rails, one of the nice things about it, is the almost complete lack of configuration. A domain object in Rails is ‘automagically’ able to be persisted. Even something like a database table name is ‘guessed’ from the class name itself rather then the programmer providing the information in some sort of configuration.

Compared to Hibernate, arguably the best persistence framework for Java, where configuration is an absolute necessity, Ruby on Rails with ActiveRecord is pretty dang nice.

The question is, why can’t the same exist in Hibernate or in some other Java persistence framework? Why can’t we learn something from the Ruby community and Ruby on Rails, and apply it to Java?

One could argue that you need a dynamic language to do what is possible with Ruby on Rails. Is this really true? Why do java apps need so much configuration? How can we create systems that are able to guess at the configuration that is needed by inference and by having nice defaults and providing hooks where configuration customization is required?