For example (note, the “import BigDecimal._” is the same as “import static java.math.BigDecimal.*” in Java):

object HelloWorld {
def main(args : Array[String]) = {
// Import BigDecimal into the scope of this block of code
import java.math.BigDecimal, BigDecimal._

val a = ONE.add(ONE);
println(”One plus one is: ” + a)
}
}

Martin Odersky, the inventor of Scala, is currently busy writing a book of which a pre-print version is available at Artima. At the moment, Scala is not yet ready for prime time (there are still some funky bugs in the compiler and some rough edges in the language itself, and IDE support is not yet complete), but there’s a good chance that this is going to be an important new programming language in the next two or three years.

The second session I went to today was “Distributed Computing and MapReduce: Technology Selection, Implementation and Deployment Made Easy” by Eugene Ciurana. He explained what MapReduce is - an algorithm for processing large amounts of data efficiently in two steps (”map” and “reduce”). The idea came from Google. Eugene explains how it’s used in the company where he works to analyze log files from webservers, to find out from which countries people are accessing their website. There are a number of implementations of MapReduce available, for example the open source Hadoop from Apache and commercial products from for example GigaSpaces, GridGain and Terracotta. He also used Mule (see also this case study from Eugene).

My third session of today was “Performance Tuning a Web Shop with Open Source Tools” by Jeroen Borgers of Xebia. Often, when developers have to solve a performance problem, they make a guess about what’s wrong with the application and try to fix that, but in reality the only way to know what’s really wrong is by measuring instead of guessing. Jeroen talked about a project in which he used tools such as JMeter and JAMon to measure performance, and JARep, a reporting tool for application performance data that he wrote himself.

After lunch I went to “How to Choose your Java Web Framework” by Shashank Tiwari. It’s a question that ofcourse interests a lot of developers, because there are hundreds of frameworks and it’s not easy to determine which one you should use. Besides discussing the characteristics of the most popular frameworks he also talked about whether you should use a framework at all, because there are also some disadvantages: you’ll have to deal with a learning curve, for simple applications a framework can unnecessarily complicate things, it can cause infrastructure bloat, and it presents challenges for testing and maintenance. Ofcourse he didn’t come up with a perfect recipe for choosing a framework. He finished with two conclusions: For simple applications, it doesn’t matter a lot which framework you choose (or if you use a framework at all), so you shouldn’t waste much time on it; for larger applications, that are part of a bigger system, it’s probably best to go for a “full stack” solution such as Spring or JBoss Seam, because you’ll have less integration problems in your project.

The last session I went to was “Real Google Web Toolkit Applications” by Jeff Dwyer. Google Web Toolkit is a web application framework by Google which allows you to program in Java, as if you’re writing a Swing desktop application. It compiles your Java code into a web application with JavaScript. He showed how GWT works by looking at a real-world example application which integrates GWT with Spring MVC. GWT is one of those things that’s on my list of things to look at sometime.

So, it was an interesting conference, I’ve learned a number of new things and got some new ideas. Thanks to JavaRanch for giving me a free ticket for this conference!

At 9:10 I went to “Spring 2.5 On the Way to 3.0″ by Jürgen Höller (one of the main committers on the Spring framework). He explained some new features in Spring 2.5, and went quite deep into the technical details of the @Autowired and other annotations - which was quite boring. He spent so much time on talking about those details that he had almost no time left to talk about 3.0. Spring 3.0 will be for Java 5 and newer only, and some new features that it will have are an expression language, support for REST and some preparation to support servlets 3.0. I wonder why they’re going to give it version number 3.0 instead of 2.6, since it didn’t sound like it would be a lot different from the current Spring 2.5.

The next session I attended was “Groovy in the Enterprise: Case Studies” by Guillaume Laforge. As the title suggested, he showed some examples of where and how Groovy has been used by companies. He discussed a number of use cases, such as: using Groovy as a developer tool (for example for testing or extending Ant or Maven), using Groovy to extend your applications (for example by using the Java scripting API to run Groovy scripts from within your application), using Groovy to create a DSL and using Groovy and Grails for web development. There was some overlap with his presentation about Grails that I attended yesterday.

At 11:40 there was an expert panel session titled “Languages: The Next Generation” with Ola Bini, Ted Neward and Guillaume Laforge. They discussed about the programming languages that are currently popular or that get a lot of attention. I found the session a bit disappointing, I had expected more. The panel didn’t come up with a clear answer or vision about what the next generation of programming languages is going to be. The only conclusion they came to was that Java is here to stay and that other languages such as Groovy, JRuby and Scala will be important additional languages, but they’re not going to completely replace Java.

After lunch I went to “Lifecycle APM: Monitor, Diagnose and Prevent Performance Issues” by Alois Reitbauer (from dynaTrace). This session was a “vendor tech brief”, so there was some marketing talk, about dynaTrace’s tool that allows you to follow transactions through a whole chain of systems (so that you can monitor and debug performance of the system).

At 13:50 I went to “JRuby on Rails: Web Development Evolved” by Ola Bini. He spent a lot of time on explaining the Ruby programming language, and had unfortunately not a lot of time left to explain how Rails works on JRuby, which was what I was interested in (I’ve already used Ruby for some time, so the intro to Ruby was not so interesting for me). Anyway, Ruby is an interesting, easy to learn and easy to use programming language, and I’d recommend any Java developer who wants to learn some other language to have a look at it.

The next session I went to was “Concurrency & High Performance” by Kirk Pepperdine. He’s a well-known guy in the field of high-performance and concurrent programming in Java. Writing software that efficiently uses multi-core processors is not easy, but it’s becoming more and more important with the current trend of multi-core processors. One of the things Kirk mentioned was the fork/join framework that will be added in Java SE 7. One book that I want to read someday soon is Java Concurrency in Practice, I’ve heard that it’s a very good book.

At the end of the afternoon there were “fireside chats”, which were sessions in which a few people did some short demos and then discussed among each other and with the audience about the things they demonstrated. I went to the fireside chat titled “Zero Turnaround in Java development”, which was about developing in Java in such a way that you don’t have to go through stop / recompile / redeploy / start cycles all the time. Guillaume Laforge showed how you can edit your Groovy web application on the fly. Geert Bevin showed how the RIFE framework supports the same thing, and Jevgeni Kabanov (from ZeroTurnaround) showed his (commercial) tool JavaRebel, which is a JVM plugin that allows you to reload classes in a running JVM. They discussed about the use and limitations of their tools and answered questions from the audience.

I arrived here late in the evening last Tuesday and I’ve hardly been outside the hotel (the conference is held at the hotel), so I haven’t seen Prague yet. Tonight there’s a “meet a stranger” dinner - you could put your name on one of five lists, and you’re going out to dinner with the other people on the list. So I’m going to a restaurant in the center of the city tonight with a few other people to have traditional Czech food.

The first day started early at 8:00 AM with a keynote by Stephan Janssen from BeJUG (famous for organising JavaPolis, which has now been renamed to Javoxx). His keynote was about different RIA (Rich Internet Applications) technologies. He gave an overview of the different choices that you have for the client side, server side and data protocols to communicate between the two (HTML, XML, JSON, Hessian, …). He demonstrated his Parleys website, which is an AIR multimedia-application (have a look, it’s a very interesting website with lots of presentations with video and slides from the past few JavaPolises and other conferences). Besides the AIR version, he also had an implementation of the Parleys website done in GWT and also one done in JavaFX. He calls JavaScript “VoodooScript” because writing an application in JavaScript and DHTML requires black magic to make it work in all the webbrowsers that people might use.

After the keynote I went to a session titled “Integrating JPA and Hibernate with Rich Internet Applications” by Shashank Tiwari (from Saven Technologies). He talked about using Hibernate (as an implementation of JPA, the Java Persistence API) on the server for a client written with Adobe Flex. There are different ways to do this, you can use LCDS (Lifecycle Data Services, a product by Adobe) or an open source alternative such as GraniteDS or dpHibernate. He gave an idea of how you could use those libraries by showing some examples of configuration files. I found this talk not the most interesting one I’ve seen on the first day (probably because the topic wasn’t really relevant to my current job).

The third session I went to was “Monitoring, Management and Troubleshooting in the Java SE 6 Platform” by Jean-Francois Denise (from Sun). He first talked about JMX and how to write MBeans or MXBeans for your application so that you can monitor and manage your application with a tool like JConsole. Besides JConsole, Java SE 6 comes with a whole list of other useful tools, such as: jinfo, jstat, jstack, jps, jmap and jhat. Sun is working on a new tool, jvisualvm, which looks like a new and improved version of JConsole, which Jean-Francois demonstrated. This was an interesting session, and it reminded me of JMX and all those tools. I think JMX is a very useful API that people unfortunately often overlook; it’s not that hard to write MBeans and tools like JConsole can be very useful as a simple memory profiler and for managing running Java processes.

Next was another keynote, “Getting Ready for the Cloud”, by Nati Shalom from GigaSpaces. I was afraid that this was going to be not much more than a marketing talk, but it wasn’t really. Nati talked about cloud computing: instead of having a few big servers, you have a large amount of smaller computers to do the work. This has certain benefits for scalability.

The first session after lunch that I wanted to attend was “Comparing Dependency Injection Frameworks”, but a few minutes after the talk was supposed to start, it was announced that the presenter wasn’t there. So I went to “SOA Using Service Component Architecture” instead, by Mike Keith. This session was about SCA and Open SOA. SCA is a set of specifications about components and their interfaces for using in a service oriented architecture. It specifies components that have input and output interfaces, properties to configure them and how they can be wired together. There are also specifications for how SCA is implemented using for example Java, webservices, C++, PHP and other technologies. In Java, you can use annotations to specify a component and its interfaces and properties. The good thing about SCA is that it makes it possible to wire together service components that are implemented in different technologies, because the components will have a standard interface.

The next session I went to was “Simplifying Java EE Development with Grails” by Guillaume Laforge. It was a straightforward presentation about Groovy and Grails. Grails is a web framework and a set of tools that enables you to quickly build a (CRUD) web application, just like Rails (for Ruby). I’ve played with Ruby and Rails myself, but I haven’t really looked at Groovy and Grails much yet. Looks like an interesting language and framework to have a look at when I have time.

The last session of the first day that I went to was “Better Enterprise Software with the Spring Portfolio” by Eberhard Wolff (from SpringSource). He talked about a case study in which he used different Spring technologies, such as Spring Beans, Spring Webservices and Spring Batch. The Spring framework really tries to be a big framework which you can use for almost anything, and its popularity shows its success. While watching this session I thought back about the session about SCA, because there seemed to be some overlap in the way that you declare components with annotations in the way that SCA specifies and in how you declare and configure different kinds of components with annotations in Spring.

And now the first day is already over. I always feel that time goes by very quickly at conferences.

Well to be honest those frameworks are pretty solid and stable and the documentation is easy to find. But on the other hand there are several annoyances when you are used to the Rails way of life.

What I miss most of all is the short edit-debug cycle. When I was working with Rails I figured this to be a minor improvement but right now I’m missing it the most. Every single small change leads to a project compile, log on to the application server, project (un/re)deploy, clear cache and then refreshing in the browser. The whole procedure takes multiple minutes, while in Rails I corrected the typo and refreshed the browser in a single second.

The second in order of frustrations is the number of XML configs, we got the struts config files, the iBatis config files, the spring config files and web config files. I would suggest drop the configs, I want my Rails conventions back

The last one I’ll mention is the enormous number of levels of indirection between a page call and page result. In Rails there will be some call-chain from controller to model and all, but it’s pretty clear, most of it is hidden by the framework and the conventions. In this project there are multiple ways along config-files, java-interfaces, businesslayers, model-layers, view layers, facades, multiple strutsactions, i.e. no conventions at all.

Of course it’s not all better in Rails. Read my Rails blog and you’ll notice there was a list of annoyances just as well, of which some don’t apply to good old Java. For instance it’s nice to skip the nil-errors as a result of typo’s in variable names(@eror instead of @error) which were one of my biggest frustrations in Rails. Or the joy of being able to refactor a methodname with one click. And of course the Java debugger kicks ass compared to the Ruby on Rails debugger.

Still it feels like a bit of a step back with all the extra work and coding that needs to be done to realize the same. So for programming web applications of this type I would prefer Ruby on Rails over Java (Spring, Ibatis, Struts). Programming in Ruby on Rails made me much more happy

On the other hand there are more things to consider (reliability, maintainability etc.) when selected the right tool for the job. Neither Rails nor Java is the silver bullet.

Head First Servlets & JSP, First Edition is based on Servlets 2.4 and JSP 2.0 (Sun exam CX-310-081).
Head First EJB is based on EJB 2.0 (Sun exam CX-310-090).

However, there is a positive point to mention:
A second edition of Head First Servlets & JSP exists. If you’re thinking about buying this book read this first. As you can see the latest SCWCD exam doesn’t differ much to the discontinued one. So maybe we shouldn’t throw these books aside.

Vincent Partington from Xebia has been blogging about J2EE performance problems he and his colleagues have encountered.

They have compiled a top 10 list. It is a very interesting read, as it is all very recognizable
See http://blog.xebia.com/2007/04/30/ejapp-top-10-countdown-wrap-up/

(and TheServerSide.com as that is where I stumbled across the link to Vincents blogposts)

The immediate cause: InfoQ’s has published an interview with Gaving King about the evolution of Seam, Gavin’s version of a framework telling you how to build (web) applications. I’ve written about Seam before and at that time in my opinion the framework was based on some interesting ideas and principles but lacked simplicity mainly caused by hard to set-up working examples. Never looked at it again (although the intentions were there ….) and I’ll point out immediately I’ll probably won’t look at it right now. So what’s so interesting about the interview? Besides some nice food for thoughts about the implications of a fine grained AJAX approach on database load and some old insights about the effects of state management on clustered environments, not very much. Except for one small comment Gavin makes as a reply to someone commenting exactly what has hit me one year ago. Let me quote:

Comment: I haven’t gotten the time to try out the new Seam release but I hope that setting up a project has gotten easier.

Gavin King’s reply: seam-gen makes it *super* easy, at least for EJB3 on JBoss users. We will be working on expanding the functionality of seam-gen to support other usecases (JavaBeans+Hibernate, Tomcat, J2EE, etc).

And that answer shows exactly what is completely wrong with the so called enterprise edition of java: There is no simple straightforward one-way road for doing things! Choices, choices, choices and a lot more choices that make life easy to model but hard to implement. Isn’t the power of application frameworks that choices are made four you? I would expect a framework like Seam dictates me to take the EJB3 route and pave things in such a way I really start to like the usage of EJB’s. Gavin, seam-gen is okay the way it is, actually it is right what was missing in your initial try. Instead of focusing on other choices, focus on more/better/advanced code generation! Expand into real functionality and help developers by filling room instead of giving it. Another illustration from the exact same interview: the different JSF frameworks Gavin lists. They seem to talk with each other to guarantee smoothness. Gavin calls this maturity, I rather use the term abstemious. A small sidestep without going into a fully blown JSF discussion but isn’t it remarkable (that’s the right word for maturity!) within EE we need a standard (JSR 299) as a glue between two other standards (JSF and EJB) in order to deal with application components in a unified way.

Right now I see a lot of developers (technical designers, architects, name them) spending too much ineffective hours on the which framework to utilize and which standard to adopt question. (not even mention the effort that can be thrown away due to steep learning curves and unexpected showstoppers after the answer to this question once again has lead to unknown trails). One can argue technical design is all about decision making and deciding what to apply is part of it. But in my point of view, technical design is all about the decisions that need to be made in order to translate a business problem into a technical solution. It’s not about choosing frameworks for every layer we can think of. Why are we programming Java? Not because at the start of every project we reconsider it. Nope it’s because we know the language and we know the language is capable of building what is desired in a (cost) effective way. And maybe once in a while we enter some self reflective mode to find arguments that reach beyond the arguments needed to make choices in a project context. And once in a while we pick up innovations, jump on bandwagons and maybe leave the paths we’re walking. Simply because we (as in the average software developer) know that when we do this every day, we can not keep pace with those who don’t.

Why is it frameworks and standards are treat in a different manner? What makes the adoption of yet another framework or standard so tempting?  The steps of changing seem to be relatively small. Due to the it’s all Java isn’t it and hey we have a new project so what the hack we’re here to learn aren’t we mentality, risks are not identified clearly. And as a result, unified application development is a farce and for every different twist, more glue is needed. And as soon as the need for glue is identified by more than one developer, new frameworks and standards arise.

Note, this blog entry is not meant to bash Seam nor the interview. It is meant to address a fundamental problem that has been floating around for a while and has been addressed in the past but seems to be persisting enough to get repeated every now and then. And Seam just functioned as a trigger (this time). Everyone who like to use Seam, go ahead, fine with me. If you do not mind, I’ll focus (projectwise) on a Spring based application design until Rails has really swallowed the way I think :-). But if you use Seam, stay with it at least the coming years (and so, stay with EJB3 and push Gavin to put all his energy in this choice instead of serving all other ways to technically layout an application).

A final thought: Is it a coincident Joel on software has published an article about choices (=headaches) on the exact same date as the interview publication? It probably is. But what Joel describes (15 ways to shut down your laptop) is exactly how we (as in the java community) build applications. Nuff said. Where’s my coffee?

The whole idea is actually super simple. AspectJ has been extended with two very handy mechanisms: a run time (actually load time) weaving engine and support for aspects that are expressed in Java 5 annotations. Using AspectJ’s API we do not have to rely on a separate compiler but the process of aspect weaving can be initiated whenever we like. And that is exactly the trick Spring is using. Aspects are actually Spring managed instantiations that influence other spring managed beans. When Spring is loading bean classes, cross cutting aspects are weaved in like a breeze.So, I grabbed the latest Spring release (2.0), read some more background information and started right away. Within minutes an AspectJ based interception of a completely meaningless but spring managed hello world bean was up and running. Cool! Hello world never has been so enlighting. To make things a bit more practical, I tried to implement a typical architectural constraint like “Methods on classes belonging to the an applications data access layer may only be called through methods of classes belong to the service layer.”. Normally this constraint is written down by software designers in a plain ms-word or odf ‘thou shall not’-document,  but using Spring AOP it can be expressed in a bit of xml (yep, Spring ….) and a Java class. ( I am not going to argue the semantic practicalities and implications of this constraint, for me it is just an example to express the ‘aha feeling’.) Okay, here are some interesting pieces of the class I wrote. Full details can be found in this posts attachment (acsa.zip). @Aspect public class SystemLayeringAspect { // ……define the pointcuts to identify different layers @Pointcut(”within(com.logicacmg..*.service.*)”) public void inServiceLayer() { }@Pointcut(”within(com.logicacmg..*.dao.*)”) public void inDataLayer() { }