Then I stumbled upon some blog posts about Netbeans 6.5 and their scripting support for python, php, ruby(rails),groovy(grails). This reminded me about how much better Ruby, Ruby on Rails and JavaFX support was in Netbeans compared to Eclipse. Sure Eclipse has plugins for these platforms, but Netbeans support is better.

Now I started wondering, would Netbeans be better suited for all these scripting languages ? I gave it a try with the Grails framework, since I was interested in having a look at Grails anyway.
The following screenshot shows the app I ended up with. I know nothing fancy, just a few simple entities (movie, director) but still it’s a result (be it very small )

After working with the new Netbeans editor I must say I’m impressed with how easy it was to create this Grails app, without any experience with Grails or Groovy. I can see why people like groovy and Grails, although for a real comparison with RoR I should give it a bigger test-drive some day.

The conclusion of this story is that I’m impressed with groovy and grails now that I finally took the time for some minimal hands on experience. And Netbeans seems like the default editor for scripting; I now have postive experiences with JavaFX , Ruby and Groovy with Netbeans (so I guess it also will be just fine for Php and Python etc.)

note: netbeans 6.5 seems pretty stable for a beta, but the resources usage seems a bit high

Some links:
Blogpost:Netbeans with groovy & python
Blogpost: Netbeans with php, python, scala
Blogpost: Netbeans with javascript
Blogpost:Netbeans and Grails
Article: introduction to groovy + grails

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.

The prototype had to be constructed within a small time frame, so we chose to implement it with the JRuby on Rails. First of all because we wanted to get experience with (J)Ruby
on Rails on a ‘real’ client assignment and second of all, because we had a lot of fun and good experiences in the test-drives we had with RoR.

We decided to use a more-or-less agile development strategy. We developed using NetBeans 6 on Windows (later on we switched to Linux) and we debugged with IE and Firefox. Especially Firefox with firebug is essential when using Ajax.

During the process we used the following plugins to speed things up.

• Visualize_models to generate a picture of the data model to check for errors.
• Ar_fixtures for serializing the database to fixtures (and back).
• Act_as_authenticated and role_requirement for authorization scaffolding.
• ActiveScaffold for scaffolding on the admin interfaces.
• Gruff for realizing simple charts

This all resulted in a very short development track with nice results.

But of course not everything was perfect. We encountered the following problems throughout the project:

• Refactoring Ruby is not supported in tools, at least not sufficient.
• Hard to see code dependencies between methods/classes.
• JRuby on rails is still kind of slow.
• Date / Datetime conversion is kind of problematic (as with most languages in my opinion)
• Use of instance variables and partials can be tricky and result in hard to find nil-errors
• Migrations are not transactional. Errors in migration will leave you somewhere in between migration X and X+1

Some of these points will be better when tool support increases, others might be unavoidable .

But to make a long story short, we did finish the prototype within a really short time and we accomplished way more work then we imagined up front, so we could call it a success. I would really recommend (J)Ruby on Rails for our prototype / requirements courses. Because getting the base of an application up and running (the first 80%) goes extremely smooth and fast.
For full applications, I think we should realize that the benefits of Rails can’t be linear extrapolated for the last 20% because this typically requires specific functionality that is not available in the frameworks; like business rules etc.

Because of all this fuzz about scripting we decided to experiment a little with some scripting languages to position their value for Java software engineering. To investigate this value we gathered information about scripting in general and scripting in relation to Java. Then we developed a little toy-application to see how these scripting languages could be used together in one project.

We chose to implement a (scripted) calculator with Java, JRuby and JavaFX script. JavaFX is used for the generation of a GUI, JRuby for the extension points of the calculator (scriptable buttons) and Java for the primary calculations and glue between the environments/languages.

The conclusions of this little experiment are that JavaFX makes it possible to create fancy GUI’s and the built-in databinding is a real relief compared to the ‘event listeners’ in plain java Swing.
One of the disappointments is the lack of proper tooling, Netbeans provides plugins with some WYSIWYG, but is far from optimal. Another disappointment is the fact that JavaFX is not so stable, it appeared more then once that the JavaFX-interpreter created runtime-exceptions related to things like concurrent modification.

Conclusions concerning JRuby; this seems a lot more stable then JavaFX and it fits in pretty easily with the Java environment. JRuby is easy to use and the rubygems and all make it a nice environment to work in.

Note: The provided sourcecode is experimental and therefore does not necessarily comply with LogicaCMG rules and guidelines.

Sources

Sources with libraries

Report

Back in the nineties OO Developers were either hard core c++ hackers or a more modest but effecient python programmers (or maybe japanese lone wolf ruby writers). Nowadays, script language practitioners are called script-kiddies and real developers use Java or C#. Ten years ago programming was all about compiling your human readable files into native machine code, today we talk about managed execution. Meanwhile dynamic langauges have always been subject to native interpreters, which during the years have been optimized in every possible dimension to get them performing. But also this niche of software development is moving. 2006 will be known as the year microsoft shipped IronPython and sun brought in the JRuby developers (Does that mean after the movement from sourceforge to codehaus, the project will move again to java.net???) Within a few years C# and java developers will become the old fashioned hackers and the rest of the programming population does OO in a more dynamic way. Want to follow the buzz?, see google’s visualizations here and here (and probably in the future here also) 

[bandwagonesque mode off]

By the way, do not forget to attend the JRuby on Rails Javapolis session this year. And another by the way, and that is why I used the bandwagonesque tags, non-mainstream languages and the concept of managed execution is not something new. Boo  and Groovy are just two codehaus examples but I think Scala and Nice are also worth mentoning. And as a final by the way, this slightly sceptical view on scripting languages just made me realise I started my career ten years ago with the most underappreciated scripting language in existence