I've recently created a white-paper about several options to do TCP/IP programming on the JVM. I'm giving here the introduction and the table of contents to give you an impression what's this all about. The white-paper comes with full source-code and is 27 pages long, so it's a bit too much for a blog entry. Get it here, if you want to take a look.

Introduction

The purpose of this document is threefold. Firstly, it should give the reader a historical overview of the TCP/IP networking API's, programming paradigms, and various coding styles on the Java Virtual Machine. Secondly, it presents a couple of new options, programming-models, and demonstrates the same with Scala, one of the new languages available on the JVM. Lastly, a small and simple benchmark was conducted, to relate these different strategies with to each other on the metrics of performance.

The discussion is centred wholly around the Java Virtual Machine for a couple of reasons. First and foremost, one regularly deals with several programming languages and several libraries. Basing everything around the JVM provides the opportunity to eliminate issues such as the language implementation, memory management, interfaces to the host operating-system, etc. Besides this advantage, the JVM is the foundation for a large amount of Open Source libraries, tools, including excellent support from a couple of free IDEs that it became the platform of many web applications. The platform is mature, versatile and widely available.

To showcase the various API's, languages and programming models, and to give the programmer an impression as to how such source code looks like, five very trivial server programs that write a simple HTML page to any client, which tries to open a TCP/IP connection to such a server, were created. Since all five programs run on the Java Virtual Machine, this page-generating method has converged to a single utility-class, which is shared among the five programs. Therefore, risks arising from inconsistent behaviour and performance, because the programs were developed in different programming languages - Java and Scala, were eliminated.



Table of Contents

Introduction

Classic Java networking IO:Sockets

One connection = one Thread?

Java New I/O: Java NIO

Buffers/Channels

Non-blocking I/O

NioServer example

NIO Frameworks, enter: Grizzly

Problems with plain NIO

The Grizzly NIO framework

The Actor Model

Network API evolution

Threading API evolution

Actors: shared-nothing versus shared data

Scala

Functional and Object-Oriented programming combined

Statically typed

Running inside the Java Virtual Machine

Modern language constructs: closures, type interference, pattern matching, powerful literals etc.

Excellent Actor library nicely integrated in the language

A simple Scala server using the Actor Model

Sending messages

Receiving messages

Combining the Actor Model and NIO

The Benchmark

Benchmark setup

Observations

Page generation

Conclusion







More...