Wolkje.net Weblog

Java 7: new developments and rumours

As promised in my last post, I will write some more on the Java 7 developments. Since my last post, there are not that many new developments, but since I’m reading a bit more on the subject there are some things I want to mention here.

Project Coin

First of all, there are developments in Project Coin. Since this week is the last change to submit new proposals (and I think they don’t expect very interesting ones), the have created a short list of proposals which are considered for implementing for JDK 7. It is discouraged to discuss on the other proposals on the mailing list, which means effectively that these other proposals are rejected. The improvements which are considered for inclusion in Java 7 are the following:

• Strings in switch statments. This makes it possible to switch on a String object and uses cases which match on a String object as well (obviously).
• Improved Exception Handling for Java. This proposal includes catch blocks which handles multiple Exception types and safe rethrow of exceptions
• Autmoatic Resource Management. I didn’t discuss this in my previous post on JDK 7. In short, this proposal suggest a method which eases closing of resources after use. This feature, submitted by Joshua Bloch of Effective Java and the Collection framework fame, solve the difficulty of closing resources properly. Bloch gives an example of the required code for closing multiple resources, which can become quite complicated because it requires several nested try-catch statements.
• Improved Type Inference for Generic Instance Creation. This is the proposal which makes it possible to omit the generic type declaration when creating an instance of (for example) a collection. Example:
  List<string <List<String>&gt:> myList = new ArrayList<>();.
  Currently, one whould repeat the generic types in the right hand instanciation of the ArrayList.
• Elvis and other null-safe operators. This proposal describes the safe dereference operators, such as .?. It makes it possible to omit checks on objects for null values.
• Simplified Varargs Method Invocation. This proposal was also not discussed in my previous post. It presents a solution for warnings which are issued when a method combines varargs with non-reifiable array types (in fact using generics in combination with varargs). The proposal does not really include a language change, but moves the point where a warning is given in the mentioned case, namely at the definition of the method instead of at the moment the method is used.

The Project Coin mainlinglist now focusses on discussing the above six proposals in order to come to a final proposal. Chances are that these proposals will be included in JDK 7, however Darcy notes that probably only five proposals will be implemented and part of JDK 7. As every week, Darcy posted a list of new proposals that were submitted this week. This list will evaluated as the previous list, and possible acceptable proposals will be added to the shortlist.

No Java 7?

Another interesting point is made by Stephen Colebourne (of JSR 310, Date and Time API). He express his concerns regarding the fact that there will be probably no official specification for Java 7, which in fact means that there will be no ‘official’ Java 7, but only a JDK 7 implemented by Sun. There is no other way to create an official Java SE 7 JDK. In fact, this removes one of the strong points of Java, namely that it is an official specification and not ‘just an implementation of a language’.

This point is backed by Neil Bartlett of OSGi, who states that Project Jigsaw is also not backed by a JSR, apart from JSR-294 (superpackages). He is especially worried about this considering the rumours regarding a possible take over of Sun by IBM, since IBM will kill off Project Jigsaw according to Bartlett, since it is not in its interest to development such a project because it already has OSGi. It should be noted that former conclusions are only based on assumptions. Colebourne thinks he has a point, by pointing at the fact that most bloggers at Sun only mention JDK 7 and almost never use the ‘Java 7′ term.

Release plan and current status

Danny Coward posted an update on the release plan of JDK 7. There is a list of milestones which consists of a total of 8 milestones, where M8 is the final one which should be the final JDK 7. Currently we are at M2, which already includes the new Garbage Collector (G1), compressed 64-bit pointers, NIO2 and a method to close URLClassLoader. M3 should be released before JavaOne (at the earliest on the 21st of May). This release should contain some interesting improvements, inlcuding Invoke Dynamic, SCTP and SDP support (mainly intersting for mainframe stuff, I think), upgraded class-loader and improved unicode handling. This latter consist a fix which removes support for unicode characters which are not represented using the shortest possible way. It is possible to represent the same character using several byte patterns in UTF-8. This can lead to security problems when this is not handled correctly.

Last week, I wrote an article for our corporate weblog on the development of Java 7. Since the article was in Dutch, I didn’t post it on my personal blog. But I wanted to post some follow ups, and since it is not very easy to do this on the weblog of Finalist, I decided to translate the article to English and post it here. The translation is done pretty quickly, and thus very likely a bit rough on the edges. I think it is also interesting for non-Dutch readers. Read the rest of this entry »

In my opinion, most of the stuff on YouTube is not very interesting. However, today I stumbled upon a post on Slashdot which contains a link to a really inspiring video created by somebody with a lot of time, but most of all, a very creative and musical mind. What he does, basically, is gathering music-related video’s from YouTube and edit them in such a way that a new song is created. You should watch some of these:

There are at least six others, just take a look here: http://www.youtube.com/user/kutiman. All the original video’s are linked as well.

Today Apple introduced the first beta version of Safari 4. While I didn’t read much about this new upcoming browser, I am really enthusiastic about the new features of this browser. I was waiting for Google Chrome to come to the Mac, since I really like lightweight browsers, but Safari made the waiting unnecessary.
Safari 4 has major improvements in speed. According to the press release, the Javascript engine is three times faster than the one in Safari 3 and faster than the one in Firefox. Also the rendering of HTML is faster (according to Apple) and I think I can even notice this improvement.
Another change is that tabs are now on top of the window, so they do include the address bar (which is a big improvement usability wise).
The new browser contains all kind of graphic hotness, including coverflow for bookmarks and history and a 3d-like display of most visited webpages in every new tab of window.
What I personally really like in the new Safari 4, is the improved web developer tools. Safari 4 contains a Firebug-alike interface for every webpage, which enables you to inspect elements, view scripts, profile javascript, debug javascript, see load times and much more. I think with this improvement, Safari is one of the browsers which provides best support for web developers. You can try it for Windows and Mac OS X by downloading it from the Apple site.

Update - I already noticed that Safari 4 was fast, but according to these benchmarks, Safari 4 is really fast. In fact, the JavaScript performance is better than Google Chrome and 42 times faster than IE 7.

I wrote this article a while ago, but never published it. Since it is mostly finished, I decided to put it only anyway. Unfortunately it is in Dutch, maybe I will translate it into English in the near future.

XMPP en Smack

Instant Messaging is nog relatief jong in de geschiedenis van internet en lijkt daardoor nog niet zoveel gebruikt voor de communicatie tussen de gebruiker en een applicatie als bijvoorbeeld e-mail. Het verzenden van e-mails door een applicatie is tamelijk gebruikelijk. Het versturen van berichten naar een IM-client een stuk minder. Andersom, een applicatie bedienen door middel van e-mail of instant messaging-berichten lijkt nog veel minder voor te komen, terwijl er de nodige scenario’s denkbaar zijn waarin dit een efficiente en snelle bedieningsmethode kan zijn.

Enkele jaren geleden werd er een ISO-standaard gedefinieerd voor een protocol dat gebruikt kan worden voor instant messaging. Dit was het protocol dat door het Jabber-systeem werd gebruikt, en bij het standaardiseren werd omgedoopt tot XMPP. Hoewel Jabber/XMPP als Instant Messaging-platform nog niet de populariteit heeft van bijvoorbeeld MSN Messenger, ICQ of AIM/Yahoo IM, wordt het tegenwoordig toch redelijk veel toegepast. Bekende gebruikers zijn Google Talk, Apple’s iChat en Twitter-achtige applicaties die het gebruikt als een van de interfaces naar de gebruiker.

Uiteraard zijn er diverse gratis XMPP-servers, waarvan het in Erlang geschreven ejabberd de meest bekende en meest gebruikte is. Ook zijn er voor veel programmeertalen kant-en-klare bibliotheken om het protocol te integreren in een applicatie. Een XMPP-library voor Java is Smack, dat met weinig inspanningen een applicatie voorziet van XMPP-ondersteuning. In dit artikel zal ik een korte introductie geven in het gebruik van Smack.

XMPP

Het XMPP-protocol maakt in principe gebruik van een server. Het is echter vrijwel nooit noodzakelijk om zelf een server te draaien, al kan dit wel voordelen bieden tijdens het ontwikkelen van een XMPP-applicatie, zoals volledige vrijheid in de configuratie en dergelijke. Over het algemeen is het mogelijk om een publieke Jabber/XMPP-server te gebruiken.

XMPP is een modulair protocol, waardoor er diverse uitbreidingen zijn die extra functionaliteit toevoegen. Standaard biedt XMPP zeer rudimentaire instant messaging-functionaliteit, waaronder het registeren van gebruikers en het verzenden van berichten van een gebruiker naar een andere gebruiker. Uitbreidingen bieden mogelijkheden zoals multiuser-chat, wat de functionaliteit van een chatroom biedt, vergelijkbaar met een irc-chat. Ook zijn er uitbreidingen die verzenden van databestanden mogelijk maken en audio- en videocommunicatie faciliteren. De communicatie tussen de clients en de servers vindt plaats door middel van XML-berichten, waardoor het debuggen van XMPP-applicaties erg eenvoudig is.

Om werking van XMPP is vrij simpel. Om het te kunnen gebruiken moeteen gebruiker op de server worden geregistreerd waarbij minimaal een gebruikersnaam en wachtwoord moet worden opgegeven. Hierna kan de gebruiker zich aanmelden bij de server en is het mogelijk om berichten te verzenden naar andere gebruikers. Om een bericht naar een andere gebruiker te verzenden is alleen de gebruikersnaam noodzakelijk, die de vorm gebruikersnaam@hostnaan/Resource heeft. Naast het verzenden kan ook een lijst met contactpersonen worden bijgehouden, in XMPP-terminologie heet dit een Roster. Voordat een gebruiker aan het roster kan worden toegevoegd moet deze toestemming geven, omdat het dan namelijk ook mogelijk is om te zien of de betreffende gebruiker online is. Smack biedt een behoorlijk volledige implementatie van de XMPP-standaard. De belangrijkste classes in deze bibliotheek zijn XMPPConnection, Roster, AccountManager en Chat.

Simpele XMPP-service

Het ontwikkelen van een eenvoudige XMPP-dienst is met relatief weinig code te realiseren met behulp van Smack. In dit voorbeeld zal een XMPP-service worden getoond die een aantal standaard antwoorden geeft op berichten, afhankelijk van de berichtinhoud.

Om te beginnen moet er een verbinding met een XMPP-server worden opgebouwd:

XMPPConnection xmppconn = new XMPPConnection("jabber.org");
try {
	xmppconn.connect();
} catch (XMPPException xe) {
	xe.printStackTrace();
}

Er dient dus een nieuw XMPPConnection-object te worden aangemaakt, waarbij in bovenstaand voorbeeld een verbiding met de server jabber.org wordt gemaakt. De method-call connect() zorgt ervoor dat de daadwerkelijke verbinding wordt opgebouwd. Na het verbinden moet er worden ingelogd. Indien de gekozen gebruikersnaam niet bestaat, dient deze te worden geregisistreerd. In onderstaand voorbeeld is geen uitgebreide foutafhandeling aanwezig, om de code overzichtelijk te houden:

try {
	xmppconn.login("pietje", "pukje123");
} catch (XMPPException xe) {
	XMPPError err = xe.getXMPPError();
	if (err != null && err.getCode() == 404) {
		try {
			AccountManager am = xmppconn.getAccountManager();
			am.createAccount("pietje", "pukje123");
			xmppconn.login("pietje", "pukje123");
		} catch (XMPPException xe2) {
			xe2.printStackTrace();
		}
	} else {
		xe.printStackTrace();
	}
}

Eerst wordt getracht aan te melden met een gebruikersnaam en wachtwoord. Als deze niet bijkt te bestaan, stuurt de XMPP-server een xmpperror-packet met een foutcode 404, wat aangeeft dat het genoemde object niet bestaat op de server. In dat geval wordt getracht om het account aan te maken. Dit gebeurd met behulp een AccountManager-object, die wordt geleverd door de XMPPConnection-instantie. Na het aanmaken van het account wordt opnieuw geprobeerd om in te loggen.

Nu we zijn verbonden met de server kan er worden gestart met het luisteren naar binnenkomende berichten. Aangezien we op alle binnenkomende berichten willen reageren, moet er gebruik worden gemaakt van een PacketListener. Dit is een tamelijk generieke listener die alle type binnenkomende objecten kan verwerken, en waarbij dus wat filtering dient te worden toegepast:

class MyPacketListener implements PacketListener {
	public void processPacket(Packet packet) {
		if (packet instanceof Message) {
			Message mesg = (Message) packet;
			/* Code om message af te handelen */
		}
	}
}

Normaliter kan gebruik worden gemaakt van een MessageListener op een Chat tussen een gebruiker, die alleen pakketten van het type Message verwerkt en de rest negeert. In dit geval kan dat niet, omdat niet bekend is welke gebruiker een bericht naar deze client zal sturen en moet de PacketListener worden toegevoegd aan het XMPPConnection-object:

xmppconn.addPacketListener(new MyPacketListener(), new PacketTypeFilter(Message.class));

Het daadwerkelijke afhandelen van een binnenkomend bericht gebeurd dus nu in de class MyPacketListener. Om het een beetje eenvoudig te houden, reageren we op elk bericht. Als het bericht alleen bestaat uit ‘datum’ wordt de huidige datum en tijd terug gestuurd. Anders wordt er een algemeen bericht naar de verzendende gebruiker gestuurd:

Message mesg = (Message) packet;
Chat chat = xmppconn.getChatManager().createChat(mesg.getFrom(), new MessageListener() {
	public void processMessage(Chat chat, Message message) {
		System.out.println("Received message: " + message.getBody());
	}
})

try {
	if (mesg.getBody().equals("date")) {
		chat.sendMessage(DateFormat.getDateInstance().format(new Date()));
	} else {
		chat.sendMessage("De XMPP-client zegt 'hoi'");
	}					}
catch (XMPPException xe) {
	xe.printStackTrace();
}

Voordat er een bericht gestuurd kan worden moet er een Chat-object worden aangemaakt. Hier moet ook een MessageListener aan worden gekoppeld, die in principe alleen de berichten ontvangt die worden verzonden door de gebruiker die onderdeel uitmaakt van deze chat.

Verdere mogelijkheden

Voor een applicatie die XMPP alleen maar gebruikt voor notificatie en het eventueel ontvangen van berichten van gebruikers, zouden de voorbeelden al voldoende moeten zijn. Smack (en XMPP) bieden uiteraard nog veel andere mogelijkheden. Het eerste wat men nog tegen zal komen is de mogelijkheid om te ’subscriben’ op een gebruiker. De applicatie ontvangt dan notificaties wanneer de gebruikerstatus veranderd. Hiervoor dient echter toestemming te worden verleend door de gebruiker waarop men wil subscriben. Smack biedt de mogelijkheid om standaard toestemming te geven wanneer een subscribe-request wordt ontvangen, wat wel de beste keuze is als de gebruiker de mogelijkheid heeft om berichten naar de applicatie te sturen. In Smack wordt het subscriben op gebruikers volledig afgehandeld door de Roster-class, die bovendien een eenvoudige implementatie biedt voor het beheren van gebruikerslijsten.

Concluderend kan worden gesteld dat XMPP vele mogelijkheden biedt om notificaties te verzenden en ontvangen. De Smack-library biedt een gebruiksvriendelijke library om gebruik te maken van dit protocol en maakt het mogelijk om met relatief weinig code XMPP-ondersteuning toe te voegen aan een applicatie.

Each year during the middle of December, the European Java community gathers at Antwerp to get updated on the latest developments in their profession. This year, Devoxx was organised for the first time from 8 until 12 December. The event was sold out for the second time in a row. This contradiction is caused by the fact that Devoxx until this year was known under the name JavaPolis, but due to a dispute with regards to the Java brand, the name was changed into Javox and finally to Devoxx. In this post I will give my impressions of two days of this event. A Dutch version of this post is available at the weblog of my employer.

With 3200 visitors from 35 different countries, the event was completely sold out. The five days Devoxx is held, are split into two parts. The Monday and Tuesday were so-called ‘university’ days, consisting of longer in-depth talks taking three hours. The Wednesday, Thursday and Friday are the conference days, and contained the most interesting talks including some new announcements by the leaders of the Java community. Apart from the lectures, there was a booth floor with booths of Java related companies, such as IBM, Sun but also Microsoft and Adobe were present. I attended only the Wednesday and Thursday. Because of planning issues at work, it was not possible for me to visit the other days.

As expected, the main topics during Devoxx were the current hypes and trends in Java world. A major topic was of course JavaFX, which was released only one week before Devoxx by Sun Microsystems. Also other Rich Internet Application platforms got attention during Devoxx, but remarkably less than JavaFX. Another subject which got a lot of attention during the conference were alternative languages for the JVM, especially Groovy, Scala, JRuby and Jython. In various talks not directly related to Groovy or Scala, examples were giving using these alternative languages. This clearly indicates that these new languages have a important position in the Java-world. In fact, JavaFX is also an alternive scripting language for the JVM, but obviously this language has a slightly different goal, because this language is mainly focused on RIA’s. Finally, the upcomping improvements in Java 7 was also a hot topic.

Wednesday started with a keynote consisting of two parts, where the second part consisted of a relatively boring promotion talk on RFID by IBM. The first part, however, was a lot more interesting. Danny Coward of Sun Microsystems introduced JavaFX and gave several demo’s showing the capabilities of this new platform and presented the global architecture of JavaFX. JavaFX is aimed at rich internet applications and competes with Microsoft Silverlight and Adobe Flex, among others. The main advantages of JavaFX is the fact that it is based on Java SE and in fact produces Java Applets, which implicates that it will run on a large part of the current browsers without the need of installing additional plugins. JavaFX strong points are the ability to work efficiently with multimedia and animations, which opens a lot of possibilities for Java developers. There are already many plugins for existing IDE’s like Eclipse and Netbeans, but also for tools used by designers, like Photoshop and Illustrator. A big disadvantage of the current JavaFX version is the lack of controls for data focussed applications, such as buttons, radio buttons and checkboxes.

The Thursday keynote also consisted of two parts, but in contrast to the Wednesday, these were both very interesting. It started with a keynote by Joshua Bloch, author of the Effective Java book and one of the lead developers of Java SE 5. Bloch, currently working for Google, discussed some items of his Effictive Java book (the talk was apparently identical to the one he gave at JavaOne). The second part of the keynote was given by Mark Reinhold of Sun and consisted for the largest part of a discussion of Project Jigsaw. He also talked about the new features which will probably be part of the upcoming Java 7 release in 2010. Project Jigsaw is a attempt to modularize the Java SE and also enable Java applications to become modularized. The main advantage of this project is that it in the future will be easier to distribute Java applications and request a specific version of a Java library from within an application. The Java distribution will get profiles which are focussed on a specific task or platform. Examples of such profiles could be a mobile profile aimed at mobile phones, a desktop profile and a headless profile, which could be used by server applications. With regard to Java 7, he told that it will not contain closures (according to some people this is the death of Java…). Another remarkable notion is that Reinhold discussed the possibility to break compatibility in a future version of Java, which enables a clean-up of the Java language and libraries and introduce features which have a high impact on the language.

Of course, there is a lot more to write on Devoxx, since the amount of information is huge. Fortunately, all talks during the conference will be published on Parleys.com as podcast or vodcast. Interesting talks I attended where by Brian Goetz on concurrency in Java. During this talk, he presented the Fork/Join package, which could be part of Java 7. Goetz also did a talk together with Alex Buckley on the new JVM features to enable better performance of dynamic languages such as JRuby and Groovy. Bill Venners - author of the book ‘Programming Scala’ - did an very interesting talk on Scala during which he mainly focussed on writing tests in Scala. Two Jetbrains developers presented how IntelliJ IDEA coped with alternative languages and how it coped with multi-language projects and especially the cross-language refactoring features. Another talk by the tech-lead of the Jersey JAX-RS reference implementation introduced JAX-RS, which can be used to develop RESTFul web applications. Of course there was also a delegation of the Java Posse team doing a Live Java Posse-podcast during which the guys from Attlassian gave away free beers. So all in all, Devoxx was really interesting for me and I attended a lot of interesting sessions which gave me inspiration for a while to experiment with some new languages and technologies! Hopefully I’m back next year!

Last week, Sun Microsystems introduced a new version of their Integrated Development Envorinment NetBeans. Version 6.5 introduces a lot of intresting new features and got a lot of attention in the media. Since the rise of Eclipse, NetBeans was somewhat ignored by many developers or at least by the ones I know (including myself). In order to get more knowledge about it, I decided to try it and test if it was suitable for a project I am currently working on.

Version 6.5 introduces features like the possibility to migrate Eclipse projects to NetBeans, improved Maven support and support for PHP development. These features were the most interesting for me, since I am working on a project which uses Maven to build and was until now developed in Eclipse. The PHP support is interesting, because in my free time I do some occasional PHP development for a website I maintain. I didn’t use NetBeans yet for PHP development, but based on the screencasts on Netbeans.org I think this is one of the better IDE’s for PHP development.
One positive thing which is immediately noticeable, is the speed of NetBeans. I used NetBeans with a Java 2 EE project, based on MMBase and using Tomcat as application server. Compared to Eclipse, the response times of the user interface is much better.
When using Eclipse, I used WTP for testing my application on Tomcat. WTP uses seperate configuration files for Tomcat, which doesn’t affect your Tomcat installation. NetBeans provides similar functionality, but depends on the configuration files in your Tomcat directory. This has positive and negative effects. For example, it is easer to find problems with your configuration, but on the other hand, it is harder to use your Tomcat installation also for other stuff.
The Maven support in NetBeans is very good, especially compared to Eclipse. NetBeans uses the Maven pom.xml file as the main project file. The advantage of this, is that the build is identical to the build which is deployed on the production system and created by the continuous build. Eclipse doesn’t have a similar option. Another good thing in NetBeans is that when editing JSP files, after saving they are almost immediately deployed on the server. When using Eclipse, it takes several seconds before a changed JSP is deployed on the server and therefore is available to test.

Less positive in NetBeans is in my opinion the support for Subversion. Eclipse provides a ‘Team Synchronisation’ view, which gives a clear overview of changes of your working copy compared to the Subversion repository. NetBeans has a similar feature, but in my opinion it is a little bit more complicated and provides less overview than the Eclipse implementation. I think in general, the user interface of NetBeans is a bit cleaner, but I find it harder to get some views. For example, the log file of a application running in Tomcat is not always easy accessible. Another miss is the lack of a equivalent to the search windows provided by Eclipse. In Eclipse, ctrl-3 (or Command-3 on Mac OS X) provides a global search for almost every part the IDE has, including views, commands, files and types. The ctrl-shift-r shortcut in Eclipse gives an ‘open resource’ windows, which searches through all files in a workspace. NetBeans provides a similar windows, but the search is much slower, which is a bit annoying. In general, I think NetBeans has fewer (handy) shortcuts, but maybe that’s because I’m more used to Eclipse and its shortcuts.

After about a week of experimenting, I thing NetBeans is really a useful IDE and is certainly a competitor for Eclipse. Especially for dynamic languages like Groovy, Scala, Ruby, PHP and Javascript it is probably better than Eclipse. For Java development, I’m currently more used to Eclipse, but the features of both IDE’s are very comparable.

Tonight, I attended a lecture of Markus Völter (also founder of Software Engineering Radio, which I can recommend to listen to) about Domain Specific Languages. The lecture, organized by Sioux in ther ‘hot-or-not’ series, was quite interesting. He started with an introduction on what DSL’s are and what they are not (fluent API’s or ontologies are not DSL’s according to Völter). He continued with discussing various ways to implement DSL’s including using Ruby by implementing a DSL using the dynamic features of this language and Scala using a similar technique. In the second part he gave a demonstration with XText in Eclipse, which was very impressive. In only five minutes, he developed a text DSL for describing the states of a microwave, and generated a plugin for Eclipse for this DSL, including syntax highlighting and code completion.
Another demonstration involved JetBrains MPS.
All in all it was a interesting lecture, but sometimes it was a bit difficult to follow, especially since I’m not very experienced with DSL’s.

De iPhone als fluit:

Last week, the screen of my MacBook started to behave strange. Just to the left of the center was a band of approximately 5 centimeters wide with a distorted image. First it was only for a minute or so, but over the week it stayed longer until it eventually didn’t disappear anymore. So, my MacBook had to be repaired. Because the computer is owned by my employer and I use the system every day for my work, I got a temporarily replacement MacBook with similar specs, only a white one with a 2GHz processor (my MacBook is black with a 2,16GHz proc.).
Since about 4 months, I make regular backups of my MacBook using Time Machine with a 2,5″ 250GB external USB hard disk, but I never tried to restore a backup. This time, I thought, was an excellent opportunity to try if it works as expected. Since I had some difficulties for Time Machine (at least, I thought I had), like applications in the /usr/local directory and quite a lot Macports applications in /opt/local, and modified versions of some configuration files, I was curious if Time Machine would restore everything in its original state.
Read the rest of this entry »