blog community

Two months ago I bought a Mac Book Pro. For some reason I just wanted to try working with MacOS. And i'm happy i did, because I'm completely in love with it since I started it first.

While I didn't really plan on using it for work, I haven't really used anything else since. Windows just feels clumpsy now. And having the latest version of Office intalled I don't have any problem integrating with the rest of the company. As long as you don't plan to play games, and don't need specific windows software, you're good to go.

So why do I like it that much better? First of all it is much easier to use a lot of different application windows at the same time. While the Windows taskbar gets very messy as soon as you open more than a few applications, I don't have any problem with it at MacOS. There are multiple reasons for this. First of all the dock (the thing at the bottom of the screen). This is both your start menu and the taskbar at the same time. There is no difference in switching to a running app, or starting an application. To keep the dock clean you only put the most used apps in it off course. For any other application I use a little tool called QuickSilver. This tool enables you to start applications by pressing ctrl-cmd-space and typing the first letters of the application's name. Easy.

Besides the multiple window thing, it feels that MacOS is much faster. I'm run Vista on a really fast machine too, but it feels much slower. For some reason Vista has a lot of harddisk activity slowing down my machine dramatically. I turned of indexing and some other services, which helps, but it's still not perfect. It has plenty of RAM btw. I didn't have a single performance problem on my Mac however, while i'm keeping a lot of heavy applications open at the same time (Netbeans, Intelij, Eclipse, Word, Powerpoint etc.).

And than the last thing. Since i'm bringing my Mac to work, every single person entering my room notices that it looks that much better... ;-)

The JavaFX Preview is release today, just in time to make the time frame of July as announced at JavaOne this year. Congratulations to the development team :-)

I just had a look at the release, and while it's not completely finished yet, it shows things are really  coming together now. I'm also happily surprised to see the Netbeans plugin has improved a lot, including basic drag & drop of components. Project Nile is also part of the Preview release and includes export plugins for Photoshop and Illustrator.

The one thing I'm a little disappointed about is that Swing components are still not natively usable as Nodes. You have to use a ComponentView instead. This will not be a problem any more as soon as we get a extensive set of JavaFX components. James Weaver made a nice start with this on his blog. I'm hoping there will be a rich set of components soon, this will be crucial for JavaFX to be picked up by the masses.

I'll be playing around with this release the next few days, and write a more detailed post soon.

You can download the release yourself from http://javafx.com. A good starting point to learn more about JavaFX is the official reference page: http://java.sun.com/javafx/reference/

Introduction

The last few weeks, Jamie Craane and I have been working on a small but usefull tool called Folder Visualizer. The idea of this tool is that it can scan your harddrive and make a visual representation of where the largest directories are located on the harddisk. This is most useful when cleaning up space. The project is available at Google Code: http://code.google.com/p/folder-visualizer/

Under featured downloads you'll find a .air and a .jnlp file to start both versions directly. 

 Besides the usefulness of the tool itself, the main important thing of this project was to compare JavaFX and Adobe AIR. We both like both platforms, but we wanted to have a case study that shows the cons and pros of each. Jamie created the Adobe AIR variant while I did the JavaFX one.

Step one was to create the algoritm of the directory scanner. We initially did this in Groovy. This post is not really about Groovy, but once again we found Groovy to be much easier than plain Java for the task at hand. Jamie had to re-implement the algoritm in ActionScript later, because AIR can't call Java libraries. More about that later.

JavaFX

Implementing the app with JavaFX was really easy. There is a quite steep learningcurve however if you're just used to Java. JavaFX is nothing like Java. This is a good thing because JavaFX can be seen as a DSL for UIs while Java is a general purpose language. It also means a big challange when you just get started with the language. The disadvantage of JavaFX is that there are not that much components available yet, and that components doesn't look really cool by default. This means you have to do everything yourself, and even a simple application like the Folder Visualizer requires custom drawing. The other side of the story is that this gives you limitless possiblities to style your application just as you want, because you're not limited to out-of-the-box components. 

 The most important reason to choose JavaFX over AIR might be the fact that JavaFX runs on the Java platform. Note that I'm talking about the Java platform and not necessarily about the Java language. This means we can leverage all libraries and existing code that we have on the Java platform.

But didn't Flex/AIR integrate with Java also? You might have seen examples of Flex applications using a Java backend. This is just remoting over HTTP however, and not really direct platform integration. This is not a problem for online applications (Flex), but it is for offline desktop applications. You don't want to do remoting locally just to be able to call Java libraries... 

AIR

The strongest point of AIR/Flex is probably the large amount of high quality components available. This means you're application looks good, even if you didn't do any custom skinning. The same is true of basic animations/transitions, it's just something you declare on a component. Because of this, it's (at least at this point) easier to create an application in AIR than creating the same application with JavaFX. There is a point however where you do need custom drawing. For example, to create new components. This is a lot harder than JavaFX. 

As soon as there are more components available for JavaFX, the advantage might go to the side of JavaFX because it than has both the possibility to draw stuff yourself, and use out-of-the-box components. We still have to wait and see how this develops however.

The same is true for tooling at this moment. Flex/AIR IDE support is ok (while not great to my opinion) but the JavaFX tooling isn't really much yet. Both IDE support and a designer tool can be expected shortly after the JavaFX release. 

The biggest con of AIR is the lack of Java platform support as said before. This is specially true because the ActionScript language really misses out on important features such as threading, and the language itself also can't keep up with a language such as Groovy. A bigger issue is the fact that you can't use Java libraries of course, and people have to re-invent the wheel for ActionScript. Take a look at ActionScript dependency injection frameworks for example.

Conclusion

JavaFX is just not finished yet, so if you have to choose a technology right now, go for Flex/AIR. Looking ahead in time however, there are some really big advantages of JavaFX over AIR. It will completetly depend on the availability of tooling and components for JavaFX to decide which technology is the better choise in the future.

Today I tried to configure log4j in my portal project. No logs appeared however, and the log4j.properties file seemed to be completely ignored. I found that there was a log4j.jar in my shared app, and this was the source of the problem.

 When the application was loaded, the application's classloader loaded the log4j.properties. The WebSphere classloader loaded the log4j.jar however, which is unable to see the log4j.properties file that was loaded by the first classloader.

The obvious solution is to either hava both the log4j.properties and log4j.jar in shared/app (which I don't advice) or have both in your application.

 

General session

Adobe must have been happy with today's general session. We started the morning with another session from Bruce Eckel and James Ward about Flex. I saw most of it already in their university session earlier this week, but all of it keeps impressing me. What I didn’t see yet before is what Flex can do with offline clients and data synchronization. Using this you can basically just disconnect your client from the internet, keep on working like you would normally do, and when you reconnect all data will be synchronized. Pretty neat J

For the people who were not yet amazed about Flex after this session there was more to come. Stephan Janssen, the guy behind JavaPolis, presented version 2 of Parleys.com. At Parleys.com you can view all the talks from JavaPolis and some other conferences. Version 2 of the website is now completely build in Flex and really looks stunning. This is just another great example of what you can do with Flex. The new version of Parleys.com is going to be online as soon as Flex 3.0 is out of beta somewhere in January/February.

After all the Flex talk it was Sun’s turn to talk about some mobile related stuff. First of all they gave a small demo of the game framework they created in Netbeans 6. Having this tooling it’s very easy to do all the basic things you’ll have to do when creating a game. Too bad I’m not into a lot of mobile development.

The last part of the session was a talk about Sun about what is going to happen to the mobile world with things like JavaFX on the horizon.

JPA 2.0

The first session after the general session I attended was about JPA 2.0. A very good overview of all the things that are going to be in the new JPA spec. Basically they are mainly adding everything that was missing in version 1. Nothing very exciting, but just making the JPA more and more complete.

JSF 2.0

Another session about new specifications, JSF 2.0 this time. The main thing they are doing is looking at all technology out there that improves JSF and the way JSF is used. They are not inventing anything new, but standardizing things such as Facelets and AJAX usage. I have mixed feelings about the new specifications. On one hand, it’s for sure that JSF will be much more useable in the new incarnation, but on the other hand, nothing really new is going to happen.

Hibernate Search

Hibernate Search is basically a bridge between the Lucene search engine and Hibernate. By writing annotations you can index entities’ fields, making them searchable by Lucene. By doing this your application can implement much better search capabilities. Think about mixing entities fields’ in a search and getting results when your search query contains spelling errors. This can be extremely useful things for many applications, and it’s easy to implement with Hibernate Search.

Webbeans

I did quite a lot with Seam in the past year, so I’m also following the Webbeans specification closely. The main thing they seem to be doing is abstracting the concepts behind Seam and Guice to make them useable in different kind of environments. Implementations can than make use of this more abstract model to implement a framework such as Seam. Specially in the field of dependency injection a lot is done to make the mechanism more flexible. I’m looking forward to see how the spec. will be implemented by for example Seam, and how Webbeans will be used in a Java SE environment.

JSR 311 – JAX-RS

JAX-RS is the API for creating REST services, that will be part of JEE 6. The API makes it very easy to create REST services, focusing mainly on how resources can be made available with a URI. The presentation was good, but I was really missing a demo. Besides this presentation I really noticed that everybody is talking about REST. It seems to be that your only cool if you’re doing REST, and Webservices are so old fashion now.

Beowulf

In the evening they played Beowulf in one of the big rooms. Metropolis is pretty much the best cinema’s I’ve been to, so this was a lot of fun. Specially the sound is really great.

Session 1 – Thinking in Flex

I started the second day with a session about Adobe Flex, presented by Bruce Eckel and James Ward. I really enjoyed the session, not only because the topic is interesting but also because Bruce and James are very entertaining speakers. The fun thing is that they do actually really present together, instead of both presenting a part of the session. What works really well is that they ask each other questions during the talks and demos, making everything so much more clear. While I can’t really believe that they really have this questions, it really looks like it. This makes the session more easy to listen to, and also keeps it dynamic.

The session was pretty much divided into two parts, the first part discussing mainly why traditional web interfaces are not user friendly and giving examples about more responsive applications build in Flex. Too bad that once again some demos gave some problems because of the bad internet connection, luckily the speakers handled this well.

While the first part of the presentation was absolutely interesting, the second part was even better. This part was all about code. They started with a very simple, 2 line demo, that could show photos from Flickr. The cool thing about Flex is that even a 2 line demo looks amazing. The rest of the talk they pretty much expanded the demo slowly, explaining the different ways to use a XML service in an application and showing how to get separation of concerns in a Flex application’s code. This was very interesting because it gave some idea’s how to use  Flex in a real environment, being bigger than one screen and 5 lines of code.

The talk finished with some examples of AIR, which enables you to create desktop Flex applications. This is another interesting development in the RIA world. The gap between internet applications and desktop applications is closing, and ‘write once, run everywhere’ get’s to a whole different level.

I visited some other talks about Flex before, and it keeps surprising me how well it all works. As some may know, I’m a big fan of Seam. Having Flex around however, it makes me wondering why you would want to use any framework that’s still rendering it’s output as HTML , instead of running in a VM. Of course a framework such as Seam makes it easier to implement the whole stack of an application from database access to UI, while Flex still has a gap between front-end and back-end. To an end-user however, most Flex applications will be more usable. For the past weeks I’m thinking about how the concepts of Seam and Flex could be used together, but didn’t really have the time to sit down for this yet. I hope to blog more about this soon.

During the lunch it was a lot more crowded than the first day, since all booths where now set up. I’m really wondering how everybody will fit into the building tomorrow when there are almost twice as much visitors as today.

Session 2 – JavaFX in Action

The second session I attended was about JavaFX. Since I really like the concept of JavaFX, and see this as one of the major interesting new technologies at the moment, I was really looking forward to this session. The session was a major disappointment to me however. Maybe not everybody share this opinion, because I actually did hear some more positive comments, but to me the session was pretty much a big waste of time. In the three hour session, we just barely touched the basics of JavaFX, while I expect some more in-depth topics in a session called ‘JavaVX in Action’. Anyone who spent half an hour browsing websites and reading documentation would properly not hear anything new here. The problem was that the pace was just way too low, spending too much time talking about unrelated topics, and the code examples where too basic. The session left me just where I started, still having many questions about how to use JavaFX in practice.

Funny detail however was that the session’s slides where written in a JavaFX application, which seemed to work quite well.

I’m still really wondering what will become of JavaFX. The technology itself seems to be quite amazing, and much work is being done to get the compiler ready. The question remains if JavaFX can be competing with technology such as Flex. Flex is production ready and is supported with good tooling. For JavaFX it is not even clear yet how we will run it in a browser, and tooling support still has a long road ahead. Flex is a commercial product of course, so this might create some space for JavaFX. I guess we’ll find out in the coming year.

Session 3 - Jazz

Today’s last talk was Erich Gamma’s talk about Jazz. Jazz is IBM’s new toolset that is supposed to conquer the world by delivering a tightly integrated set of tooling for working in a software development team. Jazz contains pretty much everything a team need to collaborate; from SCM, issue tracking and continuous integration to a project portal giving an overview of a project’s status. I’m generally not a fan of IBM tooling at all, and was a bit skeptical about Jazz too. While some things still remain unclear, the presentation left me thinking that Jazz is actually something that could really make a team run better. The idea’s behind Jazz are actually distilled from the way the Eclipse team works. As many may know, Eclipse has a reputation of always releasing on time, and always releasing quality. This is quite amazing because the Eclipse team has more than 60 developers spread around the globe. To make a team like that work together successfully is really a big achievement.

However, I’m still wondering how well Jazz will scale down to small (< 10) teams, and how well the software will work in practice. I’m also wondering about the licensing model that is still very vague at the moment.

Presentations and internet…

Something else I noticed during the past two days, is that almost every presentation completely rely on an internet connection. Many demos are done online, and it actually is a real problem when the connection doesn’t work well (which is the case in almost every session so far). Are we really that used to always having an internet connection now that we can’t work without it at all anymore?

A small thought about JRuby

Yesterday I had a short discussion with one of my colleagues also visiting here about JRuby. While I do like script languages, I don’t really get the why Sun pushes JRuby as much as they do. Why don’t they push Groovy for example? Groovy is a dynamic language running in the VM, being able to do everything  such as Java classes invoking Groovy classes, that JRuby does for a much longer time already. The only thing I can think of is that Sun tries to pull JRuby developers to the Java platform. Besides this question I do think JRuby is cool by the way, and guys like Charles Nutter do a great job there.

Speaking of colleagues by the way, make sure you also check out Bert Ertman’s blog about JavaPolis, he has visited some other sessions the past two days also.

Yesterday Info Support hosted a university session about JBoss Seam. University sessions are an initiative of the NL-JUG (dutch Java User Group) to share knowledge. I was the speaker for the evening and gave a presentation about the main concepts behind Seam. After the presentation we had hands-on labs prepared, so that everybody could get his hands dirty with Seam. Our experience is that hands-on labs help a lot with understanding and remembering the topics covered in a presentation.

As far as I heard all reactions were very positive. So if you are a NL-JUG member and didn't join yesterday's session, make sure you join our re-run session at the 27th of this month (27-11-2007). You can register at the following website: http://www.nljug.org/pages/events/content/university_20071127/

The following pictures were taken during the labs.

At the project I'm currently working we do a lot of mocking. What we found is that our test methods sometimes contained a lot of duplicate code for setting up mocks. If you need some mockobjects in only two or three methods, you might not want to make the mock objects class members if the other tests methods do not use them. What you'll than get is dubplication of the initalization of the mocks in the methods you need them. Take the following class as an example.

public class ExampleTest extends TestCase {

            public void testWithMockA() {

                        MockControl mc1 = MockControl.createMock(ClassToMock1.class);

                        ClassToMock1 mocked1 = (MockControl)mc1.getMock();

                        MockControl mc2 = MockControl.createMock(ClassToMock2.class);

                        ClassToMock2 mocked2 = (MockControl)mc2.getMock();

                        /*Set up expectations etc.

                           Might be a lot of code

            */

                         mc1.replay();

                         mc2.replay();

                         assertEquals(10, classToTest.execute(mc1, mc2));

                        mc1.verify();

                        mc2.verify();

            }

            public void testWithMockA() {

                        MockControl mc1 = MockControl.createMock(ClassToMock1.class);

                        ClassToMock1 mocked1 = (MockControl)mc1.getMock();

                        MockControl mc2 = MockControl.createMock(ClassToMock2.class);

                        ClassToMock2 mocked2 = (MockControl)mc2.getMock();

                        /*

                        Very similar mock setup, only one return value differs

                        */

                        mc1.replay();

                        mc2.replay();

                        assertEquals(10, classToTest.execute(mc1, mc2));

            mc1.verify();

                        mc2.verify();

            }

}

You might say that it’s a testclass and it doesn’t matter that much there is some duplication. True at some point, but it still bugs me. The problem is you can’t just create a method that sets up the mocks, because you need access to the objects from your test methods.

Here is a very simple solution to this, which makes use of an inner class. The innerclass contains public members for every object you need access to (you could use getters of course), and a init() method. After doing this, the example from above will look like the following.

public class ExampleTest extends TestCase {

            public void testWithMockA() {

                        WithMockSetup setup = new WithMockSetup();

                        setup.init();                  

                        setup.mc1.replay();

                        setup.mc2.replay();

                        assertEquals(10, classToTest.execute(setup.mc1, setup.mc2));

                        setup.mc1.verify();

                        setup.mc2.verify();

            }

            public void testWithMockB() {

                        WithMockSetup setup = new WithMockSetup();

                        setup.init();                  

                        /*Do that single line of extra setup */

                        setup.mc1.replay();

                        setup.mc2.replay();

                        assertEquals(10, classToTest.execute(setup.mc1, setup.mc2));

                        setup.mc1.verify();

                        setup.mc2.verify();

            }

private class WithMockSetup {

                        public MockControl mc1;

                        public ClassToMock1 mocked1;

                        public MockControl mc2;

                        public ClassToMock2 mocked2;

                        public void init() {

                                    /*Set up expectations etc.

                                       Might be a lot of code

                                    */

                        }

}

}

This will remove most of the duplication without making everything global, and without making your tests unnecessary complicated.