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.