Java’s non-blocking IO (NIO) is a complex, yet amazingly powerful addition to Java to build scalable and performant network applications. The capabilities of Java NIO are particularly impressive if compared with alternative ways in the JRE to connect to web resources over http. Here is a small collection of libraries and tutorial, which can aid in building asynchronous Java NIO based http clients.

Open Source Projects

Tutorials/Examples

High-Performance I/O with Java NIO: Nice tutorial with lots of code samples

The Rox Java NIO Tutorial: Great in-depth tutorial, including examples for SSL

SSL Echo Client and SSL Echo Server: SSL Client/Server example using NIO Framework listed above.

Java NIO Tutorials by Jakob Jenkov: Great tutorials to get started with Java NIO

SSL NIO from onjava.com: In depth discussion on SSL and NIO

Problem

StackOverflowExceptions in Java and in other programming languages can be notoriously difficult to debug. The most troublesome attribute of these exceptions is that they occur in no specific place in the application. In specific, the location (class+line number) in which the exception is thrown does only point indirectly to the erroneous part of the application.

For instance, the StackOverflowException reported in the following stack trace …

Exception in thread “pool-1117-thread-1″ java.lang.StackOverflowError

    at java.util.concurrent.locks.AbstractQueuedSynchronizer.release(Unknown Source)

    at java.util.concurrent.locks.ReentrantLock.unlock(Unknown Source)

    at one.utils.jre.concurrent.JreConcurrency$4.unlock(JreConcurrency.java:146)

… has the same cause as this stack trace:

Exception in thread “pool-1115-thread-1″ java.lang.StackOverflowError

    at java.lang.String.endsWith(Unknown Source)

    at mx.gwtutils.MxroGWTUtils.assertNoSlash(MxroGWTUtils.java:311)

    at nx.core.nodes.v01.ReferenceData.<init>(ReferenceData.java:34)

    at nx.core.Nx.reference(Nx.java:156)

Solution

The first sensible action is to run the application multiple times and identify common patterns in the reported stack traces. In particular, the overflow exception is most likely caused by an undesired recursive loop involving one or multiple method calls. The first case can usually easily be identified from the stack trace. For instance, in the following example there is probably something wrong with line 36 in the tested class.

The latter case, that of multiple involved method calls, is often the more interesting (to use a daring euphemisms). For instance, a recursive loop might occur in the following constellation:

method 1 -> method 2 -> … -> method 40 -> method 41 -> method 1

In this case, it is significantly more difficult to find the original cause of the problem, since, theoretically, the cause might be in any of the involved methods.

The useful construct ‘assert’ in combination with the capabilities of Java Exceptions can be of great help to pinpoint the error leading to undesired recursion. The following guard will check that the total depth of the stack trace is below a sensible threshold (in the example 799 nested method calls). If this threshold is violated, the application will terminate with a message hopefully of greater aid than Java’s StackOverflowException.

assert new Exception().getStackTrace().length < 800 : “Stack overflow for message: “+ message;

Adding a number of such asserts in the methods involved in the stack overflow can greatly speed up the process of identifying the cause of the error.

Notes

• Asserts will only be evaluated when the JVM is started using the argument ‘-ea’
• While asserts should be disabled by default in production deployments and therewith the additional guards inserted in the code should not affect application performance, the performance penalty of getting a stack trace in Java (new Exception().getStackTrace()) is very high. Therefore, one might consider adding an additional Boolean flag to these asserts to assure they are only invoked when one is actively searching for the cause of StackOverflowExceptions.

The world is rife for a new dominant programming language! Actually, has been rife for a couple of years, which, however, does not stop Java and C++ from dominating the screens of many unfortunate developers. Apart from the inarguably impressive features offered by ‘new’ languages, such as Scala, Goovy, Ruby, Haskell, Clojure, Dart? and Go, I am highly suspicious of these languages: What happens to the billions of lines of code written in legacy programming languages? Will my Groovy app work with the next update of Groovy, or will it work in 10 years, when I have to update my app? I don’t want something big, not the total reinvention of computing but would already be happy with more concise syntax to create inline objects, type inference and simple closures.

Xtend defines itself as a language for Java developers. In specific, it allows to write code, which is similar to Java but improved in many ways. Compiling code written in the Xtend language generates Java source files. These files can easily be used with any ‘legacy’ Java application or library. I have assembled a little tutorial and introduction to get started with the Xtend language. Find below:

• How to install the Xtend Eclipse Plug-in
• How to materialize Xtend Example Project in your Workspace
• How to create Your Own Xtend Project
• A discussion of Xtend Advantages and Disadvantages
• Conclusions

Install the Xtend Eclipse Plug In

UPDATE: As Daniel pointed out below, Xtend is now available on the Eclipse Marketplace. Installing it from there rather following the instructions in this section, might be much easier!

• Open the install new software dialog in eclipse
• Connect to the XText release repository: http://download.eclipse.org/modeling/tmf/xtext/updates/composite/releases/
• Select all packages “TMF Xtext-2.1.0″ (or of a newer version if available)
• This includes the “Xtend2 SDK” mentioned in the Xtend tutorial. The other packages need to be selected since otherwise the Xtend editors will not work.

• Click Next again
• Accept EPL licence agreement
• Restart eclipse

Materialize Xtend Example Project in your Workspace

After the installation of Xtend is complete, the best way to get started is to install the Xtend example

• Create a new Example Project as shown below

• Or under the new project wizard select “Examples / Xtend Examples / Xtend Tutorial”

• Initially the project was not built correctly in my eclipse.

• However, after closing and reopening the project everything appeared to be (maybe the Infinitest plugin in my installation has caused the problem, so I have deactivated it).
• Below a screenshot of the examples provided by Xtend:

• You can right click the project and select “Run as JUnit test” to execute some of the examples

Create Your Own Xtend Project

After browsing and testing the provided examples, it’s time to create a new project with Xtend support.

Xtend seems to be nicely integrated with the eclipse PDE. Therefore, its easiest to create an Xtend project as eclipse Plug In Project. Using the PDE tooling such projects can be easily deployed as executable applications on numerous platforms. However, since Xtend generates plain Java files, we can always compile the generated files as independent Java application. Below the steps to create a simple Hello World application.

• Use Eclipse’s New Project Wizard to create a new ‘Plug-in Project’
• Adjust the source folder and output folder to sensible values (Maven anyone?) and create the project

• Open the MANIFEST.MF file in the folder META-INF
• Add the package org.eclipse.xtext.xtend2.lib to the [Imported Packages] on the [Dependencies] tab

• Also add the following packages:

com.google.inject

org.aopalliance.aop

org.eclipse.xtext.base.lib

• Create a new source folder for your project: src/main/xtext (Right click the project and select Build Path / New Source Folder)
• Now create a new package in the source folder src/main/xtext
• For instance, de.mxro.examples.xtend1
• Right click this package and select New / Xtend Class

• Select the name “HelloWorld”
• When prompted to add the Xtext nature to the project, click [Yes]

• Right click your project and select “Properties”
• Open the properties for Xtend / Compiler
• Change the output folder to src/main/java and deselect “Override existing files”
• Click [Apply] to apply the changes

• Go back to your file HelloWorld.xtext and define the following class:

class HelloWorld {

    def public void helloWorld() {

        val message = “Hello, World!”;

        System::out.println(”’«message»”’)

    }

}

Tip: writing the symbol “«” can be achieved by pressing CTRL + SHIFT + < (or ,)

• Now check the folder src/main/java. Here, a file HelloWorld.java should have been generated as follows

import org.eclipse.xtext.xtend2.lib.StringConcatenation;

@SuppressWarnings(“all”)

public class HelloWorld {
public void helloWorld() {
final String message = “Hello, World!”;

   StringConcatenation _builder = new StringConcatenation();

   _builder.append(message, “”);

   System.out.println(_builder);

}

}

Does not look 100% efficient but that’s the tradeoff for source code generation. I did not find out how to define static methods using Xtend, so we need a standard Java class to run this code:

• In the source folder src/main/java add a Java class “Application”, while checking create main(String[] args).
• Implement the following class

public
class Application {

    /**

     * @param args

     */

    public static void main(String[] args) {

        new HelloWorld().helloWorld();

    }

}

• Right click the file Application.java and select “Run as Java Application”

Volia! You should be friendly greeted with the output “Hello, World!”

Xtend Advantages and Disadvantages

After following this little exercise and browsing the Xtend documentation, these are a number of advantages and disadvantages I see in this languages:

Advantages

• Allows writing more concise code for the Java platform.

It is no secret that Java syntax is unnecessarily verbose. This sets the bar relatively low for better languages for the Java platform. Xtend has a number of very nice features to allow writing more concise Java code, my favourite example being type inference.

• Is fully compatible with most Java technologies.

Although the JVM has received considerable attention with alternative Java byte code generating languages such as Scala, not everything Java is Java byte code. Most notably, the Android platform draws on the Java language but is not compatible with generated Java byte code. The Google Web Tookit (GWT) is another technology working with the Java language but not with the JVM. Xtend enables to write code, which interoperates both the platforms build on top of the JVM (since its Java source files can be compiled into byte code) as well as platforms build on top of the Java language syntax.

• Performance

Since the Xtend language is close to the Java language and generates relatively optimal Java source files, its performance can be expected to be far superior to other improved Java dialects, especially Groovy. Moreover, since it does not generate byte code but Java source files, more compiler optimization can be applied to the applications.

Disadvantages

• Tight coupling with eclipse tooling

Xtend and Xtext are doubtlessly eclipse technologies through and through. This is a definite advantage for starting to use these technologies since they offer nice integration with the eclipse IDE. As a downside, however, code written in the Xtend language might be difficult to use with other tools apart from eclipse. On the other hand, the Java code generated by Xtend is vanilla Java code (apart from the lightweight Xtend library used in the generated code). This code, of course, can be used by most other tools. Therefore, I have chosen above to place the xtend source files not in the main Java source code folder of the project (src/main/java) but into a separate folder (src/main/xtext). This enabled to let Java code be generated into the src/main/java folder. From there, it can be picked up and used by other tools such as Maven.

• In places, insufficient documentation

The documentation available for Xtend is far from extensive. In comparison, the documentation available for Groovy is extensive including books and various web sites.

Conclusion

I believe that Java and C++ are the very best programming languages around. Not in terms of developer productivity, measured in implemented features/hours of course, but in terms of creating sustainable code. Most Java or C++ applications written a decade ago will still run today. Java programs even without the need to be recompiled. This makes one rather confident that a decade from now, still people will be able to compile and run written in Java and C++ today. Adopting terms from the finance industry, they are simply too big to fail.

Give that, I am very suspicious of any new programming language. That is it more elegant and allows me to be more productive are simply insufficient arguments. Code is too difficult to write that I would want to run into the risk of having to dump it ever. Xtend offers a neat compromise. It allows to write code in a more modern, more productive language but yet defining the application in plain old Java code. Therefore, I see Xtend primarily as a useful tool to generate Java tool. Even if Xtend becomes deprecated at some point in time, one always has the Java code to fall back to.

Mistakes to Avoid

As mentioned above, installing the plugin following the documentation provided on the Xtend tutorial page has not been a smooth process. Below a number of mistakes in installing the plugin, which are better avoided.

Do not install only the Xtend2 SDK

Installing only the Xtend 2 SDK package as shown below …

.. and creating a new class …

… will result in a problem being reported by Xtend.

Do not Install the Xpend/Xtend All-in-One Package

Selecting “Xpand/Xtend All-in-One” …

… with all these packages …

… will not allow you to create the Xtend example project.

Do Not Create an Xtext Project to Start an Xtend Project

Xconfused? An Xtext project does not automatically allows to get started with Xtext. It is better to create an eclipse Plug-in project as shown above.

References

Xtend Official Overview

Xtend 2 – the Successor to Xpand post by creator Sven Efftinge

One common theme in discussions of persistence is to be critical of the traditional SQL databases, which have been successfully used in business applications for decades. As alternative to these SQL databases, often so called NoSQL solutions are advocated. NoSQL, essentially, dramatically simplifies the kind of data, which can be managed by the database. Often, a simple key-value store is at the heart of the database. Such stores allow the user to store data in a similar way as it has long been known for the Map data structure. However, whereas the traditionally Maps have been used in-memory, e.g. to hold data temporarily, which fits on one system’s memory, NoSQL key value stores are designed to persist and scale up to millions or billions of key-value records, distributed among potentially thousands of servers. As can be expected, in the Java space, there is not one all-encompassing NoSQL solution but various (mostly free and open source) offerings compete with varying features.

In the following I discuss two categories of implementations:

1. Object Prevalence engines: which assure objects stored in memory are never lost and constantly backed up onto a hard disk.
2. Persisted Databases engines: which allow to work with key-value databases, which are larger than the systems memory by persisting parts of them onto a hard disk (or another persistence backend).

Object Prevalence

Object Prevalence systems keep all records in-memory. However, they are designed to keep a synchronized persisted copy of all objects on the hard disk. In case of a system failure or reboot they therewith can easily restore the state before the interruption. Object prevalence systems are often used to speed up applications, for which all required data can be stored in memory (Villela, 1^st of August 2002).

One prominent example of an object prevalence system is the open source solution Prevayler (http://prevayler.org). A significant limitation for such object prevalence systems is, of course, that the amount of data the application can work with is limited to the memory available on one server. To allow systems to scale, an object prevalence system can be distributed among various systems. A very well-performing open source solution for this purpose is hazelcast (http://www.hazelcast.com/).

Persisted Databases

While object prevalence systems are arguably one of the best performing solutions to store the data of an application, there are many use cases, in which data is only rarely accessed and therewith not required to be available in memory. For these purposes key-value stores, which keep only a fraction of their data in the memory are best suited. Below a number of examples implementing this pattern. To get started quickly, I think jdbm2 is a good option, for large scale solutions, you might have to consider Berkely DB – but this might end up being a pricy pathway.

Resources

JDBM

“HIVE-1754 – Remove JDBM component from Map Join” Apache Hadoop has removed the JDBM dependency from their codebase due to poor performance. However, they seem to have replaced the persistence backed map with a map solely in memory. So they did not really find a better alternative for JDBM but rather removed the necessity for file-based persistence altogether. The old implementation of JDBM used by them can be found in the source repositories: e.g. BaseRecordManager in hive-0.5.0, or how it was used in HashMapWrappper also in hive-0.5.0.

“JDBM2 released” Blog post with some additional info concerning JDBM2

SQL Alternatives

For an SQL database with a very low footprint and high performance see: http://www.h2database.com/

Other Resources

“An introduction to object prevalence” (Villela, 1^st of August 2002)

“Anti-RDBMS: A list of distributed key-value stores” (Jones, 19^th of January 2009)

“NoSQL Services Available” (Menon, 29^th of March 2011)

“The Jalapeño Persistence Library for Java” (intersystems.com)

“POJO Persistence” (on this blog)

Prevayler (http://prevayler.org)

hazelcast (http://www.hazelcast.com/)