Gerbrand on ICT » ria

JavaFX 2.0

gerbrand — Fri, 18 Feb 2011 22:01:27 +0000

Yesterday I attended a NLJug meeting at Oracle at De Meern on JavaFX, called ‘JavaFX 2.0 EA‘. The meeting was presented by Roger Brinkley, who’s a called ‘Community leader’, of Mobile and Embedded. That he was formally part of Sun wasn’t hard to see based on his clothing and style.

Roger gave an overview of the new JavaFX 2.0, the road-map and the planned features. The software seems to be developed in an agile manner: the dead line is fixed, as is policy at Oracle (not meeting a dead line means exit for the responsible executive), but the final set of features is not.
The preview is available now for a limited audience, in May the first public beta will be released and in November the final will be available.

The most important news I heard:

JavaFX 2.0 will be a library (jfx.jar), rather than a separate scripting language JavaFX. The language works in the language Java of course, but you can use the language Scala, JRuby, Jython or other languages available on the JVM. JavaFX script is end-of-life. Fortunately, the syntax of the library calls is quite similar, and there’s a program to translate JavaFX script into equivalent Javacode. Curiously, the translator, FX Translator, is written in Scala.
Update 2011-06-15: I only heard about the fx translator at the here mentioned presentation. I could find little references to the translator: a back-reference to this posting (sigh) and the fxtranslator mentioned shortly in this posting on DrDobbs.
If you want to use the FXtranslator, you’ll have to contact Oracle for now. I guess Oracle will release the automatic translation tool in some time too.
The Swing-controls can be used from JavaFX 2.0. The ‘traditional Swing’ is now in maintenance mode, Oracle won’t create an new features for the original Swing library. Meaning, if you want to develop Swing applications, or more generally, desktop applications in Java now, you can best get the beta or coming GA of JavaFX.
JavaFX 2.0 will be available on neither the Mobiles nor Televisions! Oracle has accepted (Sun’s) loss, and will only focus on the desktop for the time being.
JavaFX seems practical on tablet-devices. However, since most tablet devices are enlarged mobiles (running a mobile os) ratter than flattened laptops (running a full desktop os), you can’t use JavaFX on any of those devices for the time being.
The JavaFX is supported on the MS-Windows platform only for the coming time, (but) it will run on Mac, Linux or other platforms unsupported. This means, you might miss the hardware acceleration when not using Windows. Mind you: Roger was using a Mac while doing his presentation and demonstration the code-samples so the MS-Windows-only support might not look as dramatic as it seems at first glance.
Of course JavaFX runs on the JVM 6 or higher. If all goes well, JavaFX will be part of JDK 8. Before that JavaFX can be downloaded as a plugin before from java.com, which will be not to painful for users, especially if they already have some version of the Java-plugin installed.

The JavaFX SDK contains a set of sample application called ‘Ensemble’. Roger presented a few impressive programs, and showed the source code. The audience, including the Oracle employee hosting the event was very tech oriented so everyone was eager to see the code of all the nice examples.

Furthermore, Roger frequently mentioned Podcasts. I have yet to listen to them, but maybe if I have some time left. Should find a way to broadcast audio while doing the dishes.
All in all a nice event. Oracle may turn JavaFX in something that might be practical and usable on a limited number of platforms, ratter then trying to take over the world (or more specifically taking on Android, Flex, Apple IOS).

As you might notice, I’ve got no code examples or screen-shots. I hope to get access to the beta release of JavaFX 2.0, I’m quite interested in trying out all those nifty things, and expect some nice blog postings on JavaFX soon!

Update 2011-06-01: The public beta of JavaFX is out! I’ve published on JavaFX on the Xebia-blog.

InfoQ, Tim Bray on the Future of the web

gerbrand — Tue, 24 Mar 2009 20:45:46 +0000

I often view or read the InfoQ, a site with articles on software development, programming. Almost all content they publish is very good. One I just saw was: Tim Bray on the Future of the web, an interview with someone of Sun. Interesting view has Tim on the web. He’s quite sceptical on RIA. Many ordinary users we’re quite glad when webapplications came – as they replaces often hard to use applications created using Visual Basic, VC++, Delphi and others with pull-down menu’s, ill-designs user interfaces. He also considers a bad thing if the back-button is disabled, many users find very relieving if they can go back once they’re confused. Gives you something to think about.
I don’t agree for entirely - they’re a lot of very good applications too, and there are quite confusing webapplications. But still, maybe for many applications he’s right.

Swing popularity rising

gerbrand — Sun, 15 Mar 2009 22:43:19 +0000

Years ago I developed several Swing application – most of them are still being used now. Later I switched to webapplication using http, javascript and html. I do like thinking about client-server communication, distributed software, databases and other parts of enterprise development. I never liked devoping client frameworks using any of the many webapplication frameworks like jsp/servlets, struts2, jsf. Somehow they never give the same ease of use. Usually it takes a lot more them having the application behave good, and still the GUI is slower and less responsive for the user. Even applicationd developed using advanced ajax frameworks like GWT are as good as application once written in Visual Basic or Delphi – considering a computer is now-a-days a whole lot faster.

Fortunately for developers Swing seems to be rising in popularity a lot. On Javaworld there are published articles on Swing, like this one on The Swing Cookbook, and on Dzone I found a weblog on Swing, or more specifically Java Desktop.
One of the reasons of the increasing popularity might by JSR 296, a standard for Swing. The standard is in development since 2006, but seems to be getting more attention lately. In a posting on JSR 296 and Swing suggests Swing might become obsolete – as Sun concerns- because of JavaFX. I don’t think (hope) Swing will disappear any time soon. Sun has a new architect on JSR 296 since last year, although there’s not that much progress on development or updates. On JSpring, a popular conference on Java in the Netherlands, there a session on JSR296, allthough Javapolis (now Devoxx) there was a talk on JSR-296 in 2006 already. I’ll be curious what will be told in that session.

Pattern in RIA

gerbrand — Sat, 17 Jan 2009 16:49:48 +0000

The Flex framework is getting more and more populair, and other similar RIA-frameworks as JavaFX and Sliverlight get a lot of attention. Some people see Flex as a alternative for webframeworks as Widget, JSF, Struts or GWT. However, there’s something fundementelly different. When program in Flex, you actually build a client-application. That application runs entirely on the client’s computers. The client connects to the server only when the client need information from the server. The client retrieves information via (web)services.

The pattern (as you can call it) is very unlike webframeworks, where the software runs mostly on the server. When a user accesses a webapplication, the webframework will generate html, javascript and xml and send that to the client’s webbrowser. The webframework also needs to create a (HTTP-)session along with a sessionid that is stored at the client-computer.
When a client performs some interaction, like pressing a button, a relatively complicated process is started: a javascript event or browser submit is emitted. The webframework will retrieve that event on the server using generated javascript- and html-code. Using the sessionid, the right user-session, containing client-data is loaded after which more automagic processes are performed.
You might wonder, what about Ajax ? The answer, with Ajax, or JQuery or other framework, the only advantage is, in case o a UI-event not the entire browserpage has to be reloaded and shown on the user, but only a part.

Not so long ago most enterprise software was developed as client-server: a client application would run on an users computer, while the server would consist of a database server. The client would make a connection to the database. The (business) logic of the software was contained in the application, while the database contained the data.
This development-model was quite easy for developers. I don’t have hard data, but I think the productivy was much higher back then. My guess is that, for many simple CRUD-like requirements, a average Visual Basic, Delphy, Clipper developer was a lot faster.
Of course one of the mayor problems back then, were the installation and maintance of the client computers. Webapplications pretty much solved that, as the only client software you had was the browser. Another problem is security: usually the client was connected with the server via a direct connection to the database. That means, if an unauthorized user would gain access to the client software he could do a lot of harm.
In webapplications, a user can only access the software by logging in the the webapplication. Without a username/passsword or other means of authentication, getting access to the server is very hard.

In modern RIA frameworks these problems are mostly solved. The software runs in a standardized plugin like the flash-player or java-player. That software is a lot easier to maintain then custom client software. A RIA-application accesses the server via a webservice. Fine-grained security can added accessed to the webservice, preventing unauthorized access. That way, access to the server/backend can be controlled.

All in all, modern RIA bring back productivity to the developer and the user. Developers finally don’t have to waste time learning yet another greatest framework (Struts, SpringMVC, JSF, ADF, GWT), and solving problems inherently part of webdevelopment (http-sessions, javascript debugging, html hell, generated code) . Users finally don’t have to wast time waiting for browser refreshes, loading times and timewasting slow operations.

For an overview on different RIA-frameworks, and more on this subject see: Rich Internet Applications: State of the Union . The term design pattern for RIA I got from the following presentation of a Adobe Evangelist on J-Fall ’08.