Contents - Cultural View

Contents 

Articles 

Java (programming language) 1 

Web Language 15 

AgentSheets 16 

Oak (programming language) 19 

Lightweight Java 21 

.properties 22 

Apache Harmony 24 

Apache Muse 30 

Apache Shiro 31 

Java applet 32 

Associació d'Usuaris de Java de Catalunya 40 

Automated exception handling 48 

Bean Scripting Framework 49 

CJAN 50 

Celtix 52 

Chainsaw (log file viewer) 53 

clone (Java method) 54 

Comparison of Java and C Sharp 58 

Comparison of Java and C++ 82 

Comparison of the Java and .NET platforms 93 

Constant interface 100 

Java 4K Game Programming Contest 102 

CookXml 106 

Cougaar 109 

Deterministic Parallel Java 110 

Devoxx 110 

Doclets 111 

Elastic Path 112 

Electronic Disturbance Theater 113 

Event dispatching thread 116 

Facelets 118 

final (Java) 120 

FloodNet 122 

FormEngine 123

Generics in Java 124 

G-java 129 

GlassFish Metro 130 

James Gosling 132 

Gray Flimmer 134 

Todd Greanier 135 

Head First (book series) 136 

Jim Hugunin 137 

Inner class 138 

Interface (Java) 140 

Internet Foundation Classes 143 

JAD (JAva Decompiler) 146 

JAD (file format) 147 

JAMWiki 149 

JGroups 151 

JPicus 152 

Java Class Library 153 

Java Classloader 156 

Java compiler 159 

Java Development Kit 160 

Java Interface Definition Language 163 

Java resource bundle 163 

Java TV 164 

Java Work Framework 166 

Java annotation 168 

Java collections framework 172 

Java concurrency 173 

Java syntax 175 

Java: View Technologies and Frameworks 198 

JavaBeans Activation Framework 201 

JavaThreads 201 

javac 202 

JavaFX 204 

Jawin 208 

JExamples 209 

Jfig 210 

Jikes 211 

jnSynch 212

Michael Kölling 212 

List of Java keywords 214 

Marker interface pattern 220 

Name mangling 221 

Patrick Naughton 230 

New I/O 231 

Object type (object-oriented programming) 237 

Omniscient Debugger 239 

OpenJDK 239 

PHP/Java Bridge 244 

Java package 245 

Parboiled (Java) 248 

Plain Old Java Object 250 

Pluggable look and feel 253 

Primitive wrapper class 255 

Project Semplice 256 

Quark Framework 257 

REPLAY (software) 266 

Real time Java 268 

Resource (Java) 269 

Restlet 270 

Retrotranslator 272 

SLAMD 273 

SLAMD Server 275 

SLF4J 275 

Bruno Souza 277 

Static import 278 

StormMQ 279 

strictfp 280 

String Buffer 281 

Sun Web Developer Pack 283 

Swing (Java) 284 

SwingLabs 290 

Synth Look and Feel 292 

TeachScheme! 294 

The Java Posse 297 

Unified Expression Language 298 

Java Virtual Machine 299

Xerlin 304 

XStream 306 

References 

Article Sources and Contributors 308 

Image Sources, Licenses and Contributors 313 

Article Licenses 

License 314


Java (programming language) 

Paradigm Object-oriented, structured, imperative 

Appeared in 1995 

Designed by Sun Microsystems (Now owned by Oracle Corporation) 

Developer James Gosling & Sun Microsystems 

Stable release Java Standard Edition 6 (1.6.0_21) (July 7, 2010) 

Typing discipline Static, strong, safe, nominative, manifest 

Major 

implementations 

Dialects Generic Java, Pizza 

Influenced by 

Numerous; primarily: OpenJDK, HotSpot 

Ada 83, C++, C#, [1] Delphi Object Pascal, [2] Eiffel, [3] Generic Java, Mesa, [4] Modula-3, [5] Objective-C, [6] 

UCSD Pascal, [7] [8] Smalltalk 

Influenced Ada 2005, BeanShell, C#, Clojure, D, ECMAScript, Groovy, J#, JavaScript, PHP, Python, Scala 

OS Cross-platform (multi-platform) 

License GNU General Public License / Java Community Process 

Usual file extensions .java, .class, .jar 

Website [9] 

Java Programming at Wikibooks 

Java is a programming language originally developed by James Gosling at Sun Microsystems 

(which is now a subsidiary of Oracle Corporation) and released in 1995 as a core component 

of Sun Microsystems' Java platform. The language derives much of its syntax from C and C++ 

but has a simpler object model and fewer low-level facilities. Java applications are typically 

compiled to bytecode (class file) that can run on any Java Virtual Machine (JVM) regardless 

of computer architecture. Java is a general-purpose, concurrent, class-based, object-oriented 

language that is specifically designed to have as few implementation dependencies as possible. 

It is intended to let application developers "write once, run anywhere". Java is currently one of 

the most popular programming languages in use, and is widely used from application software 

[10] [11] 

to web applications. 

Duke, the Java 

The original and reference implementation Java compilers, virtual machines, and class libraries were developed by 

Sun from 1995. As of May 2007, in compliance with the specifications of the Java Community Process, Sun 

relicensed most of its Java technologies under the GNU General Public License. Others have also developed 

mascot 

alternative implementations of these Sun technologies, such as the GNU Compiler for Java and GNU Classpath.


History 

James Gosling and Patrick Naughton initiated the Java language project in June 1991 for use in one of his many 

set-top box projects. [12] Java was originally designed for interactive television, but it was too advanced. [13] The 

language was initially called Oak after an oak tree that stood outside Gosling's office; it went by the name Green 

later, and was later renamed Java, from a list of random words. [14] Gosling aimed to implement a virtual machine 

and a language that had a familiar C/C++ style of notation. [15] 

Sun Microsystems released the first public implementation as Java 1.0 in 1995. It promised "Write Once, Run 

Anywhere" (WORA), providing no-cost run-times on popular platforms. Fairly secure and featuring configurable 

security, it allowed network- and file-access restrictions. Major web browsers soon incorporated the ability to run 

Java applets within web pages, and Java quickly became popular. With the advent of Java 2 (released initially as 

J2SE 1.2 in December 1998–1999), new versions had multiple configurations built for different types of platforms. 

For example, J2EE targeted enterprise applications and the greatly stripped-down version J2ME for mobile 

applications (Mobile Java). J2SE designated the Standard Edition. In 2006, for marketing purposes, Sun renamed 

new J2 versions as Java EE, Java ME, and Java SE, respectively. 

In 1997, Sun Microsystems approached the ISO/IEC JTC1 standards body and later the Ecma International to 

formalize Java, but it soon withdrew from the process. [16] Java remains a de facto standard, controlled through the 

Java Community Process. [17] At one time, Sun made most of its Java implementations available without charge, 

despite their proprietary software status. Sun generated revenue from Java through the selling of licenses for 

specialized products such as the Java Enterprise System. Sun distinguishes between its Software Development Kit 

(SDK) and Runtime Environment (JRE) (a subset of the SDK); the primary distinction involves the JRE's lack of the 

compiler, utility programs, and header files. 

On November 13, 2006, Sun released much of Java as open source software under the terms of the GNU General 

Public License (GPL). On May 8, 2007, Sun finished the process, making all of Java's core code available under free 

software/open-source distribution terms, aside from a small portion of code to which Sun did not hold the 

copyright. [18] 

Sun's vice-president Rich Green has said that Sun's ideal role with regards to Java is as an "evangelist." [19] 

Principles 

There were five primary goals in the creation of the Java language: [20] 

1. It should be "simple, object oriented, and familiar". 

2. It should be "robust and secure". 

3. It should be "architecture neutral and portable". 

4. It should execute with "high performance". 

5. It should be "interpreted, threaded, and dynamic". 

Practices 

Java Platform 

One characteristic of Java is portability, which means that computer programs written in the Java language must run 

similarly on any supported hardware/operating-system platform. This is achieved by compiling the Java language 

code to an intermediate representation called Java bytecode, instead of directly to platform-specific machine code. 

Java bytecode instructions are analogous to machine code, but are intended to be interpreted by a virtual machine 

(VM) written specifically for the host hardware. End-users commonly use a Java Runtime Environment (JRE) 

installed on their own machine for standalone Java applications, or in a Web browser for Java applets.


Standardized libraries provide a generic way to access host-specific features such as graphics, threading and 

networking. 

A major benefit of using bytecode is porting. However, the overhead of interpretation means that interpreted 

programs almost always run more slowly than programs compiled to native executables would. Just-in-Time 

compilers were introduced from an early stage that compile bytecodes to machine code during runtime. Over the 

years, this JVM built-in feature has been optimized to a point where the JVM's performance competes with natively 

compiled C code. 

Implementations 

Sun Microsystems officially licenses the Java Standard Edition platform for Linux, [21] Mac OS X, [22] and Solaris. 

Although in the past Sun has licensed Java to Microsoft, the license has expired and has not been renewed. [23] 

Through a network of third-party vendors and licensees, [24] alternative Java environments are available for these and 

other platforms. 

Sun's trademark license for usage of the Java brand insists that all implementations be "compatible". This resulted in 

a legal dispute with Microsoft after Sun claimed that the Microsoft implementation did not support RMI or JNI and 

had added platform-specific features of their own. Sun sued in 1997, and in 2001 won a settlement of $20 million as 

well as a court order enforcing the terms of the license from Sun. [25] As a result, Microsoft no longer ships Java with 

Windows, and in recent versions of Windows, Internet Explorer cannot support Java applets without a third-party 

plugin. Sun, and others, have made available free Java run-time systems for those and other versions of Windows. 

Platform-independent Java is essential to the Java EE strategy, and an even more rigorous validation is required to 

certify an implementation. This environment enables portable server-side applications, such as Web services, Java 

Servlets, and Enterprise JavaBeans, as well as with embedded systems based on OSGi, using Embedded Java 

environments. Through the new GlassFish project, Sun is working to create a fully functional, unified open source 

implementation of the Java EE technologies. 

Sun also distributes a superset of the JRE called the Java Development Kit (commonly known as the JDK), which 

includes development tools such as the Java compiler, Javadoc, Jar and debugger. 

Performance 

Programs written in Java have a reputation for being slower and requiring more memory than those written in some 

other languages. [26] However, Java programs' execution speed improved significantly with the introduction of 

Just-in-time compilation in 1997/1998 for Java 1.1, [27] [28] [29] the addition of language features supporting better 

code analysis (such as inner classes, StringBuffer class, optional assertions, etc.), and optimizations in the Java 

Virtual Machine itself, such as HotSpot becoming the default for Sun's JVM in 2000. 

To boost even further the speed performances that can be achieved using the Java language Systronix made JStik, [30] 

a microcontroller based on the aJile Systems [31] line of embedded Java processors. In addition, the widely used ARM 

family of CPUs has hardware support for executing Java bytecode through its Jazelle option. 

Automatic memory management 

Java uses an automatic garbage collector to manage memory in the object lifecycle. The programmer determines 

when objects are created, and the Java runtime is responsible for recovering the memory once objects are no longer 

in use. Once no references to an object remain, the unreachable memory becomes eligible to be freed automatically 

by the garbage collector. Something similar to a memory leak may still occur if a programmer's code holds a 

reference to an object that is no longer needed, typically when objects that are no longer needed are stored in 

containers that are still in use. If methods for a nonexistent object are called, a "null pointer exception" is thrown. [32] 

[33]


One of the ideas behind Java's automatic memory management model is that programmers can be spared the burden 

of having to perform manual memory management. In some languages memory for the creation of objects is 

implicitly allocated on the stack, or explicitly allocated and deallocated from the heap. Either way, the responsibility 

of managing memory resides with the programmer. If the program does not deallocate an object, a memory leak 

occurs. If the program attempts to access or deallocate memory that has already been deallocated, the result is 

undefined and difficult to predict, and the program is likely to become unstable and/or crash. This can be partially 

remedied by the use of smart pointers, but these add overhead and complexity. Note that garbage collection does not 

prevent 'logical' memory leaks, i.e. those where the memory is still referenced but never used. 

Garbage collection may happen at any time. Ideally, it will occur when a program is idle. It is guaranteed to be 

triggered if there is insufficient free memory on the heap to allocate a new object; this can cause a program to stall 

momentarily. Explicit memory management is not possible in Java. 

Java does not support C/C++ style pointer arithmetic, where object addresses and unsigned integers (usually long 

integers) can be used interchangeably. This allows the garbage collector to relocate referenced objects, and ensures 

type safety and security. 

As in C++ and some other object-oriented languages, variables of Java's primitive data types are not objects. Values 

of primitive types are either stored directly in fields (for objects) or on the stack (for methods) rather than on the 

heap, as commonly true for objects (but see Escape analysis). This was a conscious decision by Java's designers for 

performance reasons. Because of this, Java was not considered to be a pure object-oriented programming language. 

However, as of Java 5.0, autoboxing enables programmers to proceed as if primitive types were instances of their 

wrapper class. 

Syntax 

The syntax of Java is largely derived from C++. Unlike C++, which combines the syntax for structured, generic, and 

object-oriented programming, Java was built almost exclusively as an object oriented language. All code is written 

inside a class and everything is an object, with the exception of the intrinsic data types (ordinal and real numbers, 

boolean values, and characters), which are not classes for performance reasons. 

Java suppresses several features (such as operator overloading and multiple inheritance) for classes in order to 

simplify the language and to prevent possible errors and anti-pattern design. 

Java uses similar commenting methods to C++. There are three different styles of comment: a single line style 

marked with two slashes (//), a multiple line style opened with a slash asterisk (/*) and closed with an asterisk slash 

(*/) and the Javadoc commenting style opened with a slash and two asterisks (/**) and closed with an asterisk slash 

(*/). The Javadoc style of commenting allows the user to run the Javadoc executable to compile documentation for 

the program. 

Example: 

//This is an example of a single line comment using two slashes 

/* This is an example of a multiple line comment using the slash 

and asterisk. This type of comment can be used to hold a lot of 

information 

or deactivate code but it is very important to remember to close the 

comment. */ 

/** This is an example of a multiple line Javadoc comment 

which allows compilation from Javadoc of this comment. */


Examples 

Hello world 

The traditional Hello world program can be written in Java as: 

// Outputs "Hello, world!" and then exits 

public class HelloWorld { 

} 

public static void main(String[] args) { 

} 

System.out.println("Hello world!"); 

Source files must be named after the public class they contain, appending the suffix .java, for example, 

HelloWorld.java. It must first be compiled into bytecode, using a Java compiler, producing a file named 

HelloWorld.class. Only then can it be executed, or 'launched'. The java source file may only contain one public class 

but can contain multiple classes with less than public access and any number of public inner classes. 

A class that is not declared public may be stored in any .java file. The compiler will generate a class file for each 

class defined in the source file. The name of the class file is the name of the class, with .class appended. For class 

file generation, anonymous classes are treated as if their name were the concatenation of the name of their enclosing 

class, a $, and an integer. 

The keyword public denotes that a method can be called from code in other classes, or that a class may be used by 

classes outside the class hierarchy. The class hierarchy is related to the name of the directory in which the .java file 

is. 

The keyword static in front of a method indicates a static method, which is associated only with the class and not 

with any specific instance of that class. Only static methods can be invoked without a reference to an object. Static 

methods cannot access any method variables that are not static. 

The keyword void indicates that the main method does not return any value to the caller. If a Java program is to exit 

with an error code, it must call System.exit() explicitly. 

The method name "main" is not a keyword in the Java language. It is simply the name of the method the Java 

launcher calls to pass control to the program. Java classes that run in managed environments such as applets and 

Enterprise JavaBean do not use or need a main() method. A java program may contain multiple classes that have 

main methods, which means that the VM needs to be explicitly told which class to launch from. 

The main method must accept an array of String objects. By convention, it is referenced as args although any other 

legal identifier name can be used. Since Java 5, the main method can also use variable arguments, in the form of 

public static void main(String... args), allowing the main method to be invoked with an arbitrary number of String 

arguments. The effect of this alternate declaration is semantically identical (the args parameter is still an array of 

String objects), but allows an alternative syntax for creating and passing the array. 

The Java launcher launches Java by loading a given class (specified on the command line or as an attribute in a JAR) 

and starting its public static void main(String[]) method. Stand-alone programs must declare this method explicitly. 

The String[] args parameter is an array of String objects containing any arguments passed to the class. The 

parameters to main are often passed by means of a command line. 

Printing is part of a Java standard library: The System class defines a public static field called out. The out object is 

an instance of the PrintStream class and provides many methods for printing data to standard out, including 

println(String) which also appends a new line to the passed string. 

The string "Hello, world!" is automatically converted to a String object by the compiler.


A more comprehensive example 

// OddEven.java 

import javax.swing.JOptionPane; 

public class OddEven { 

// "input" is the number that the user gives to the computer 

private int input; // a whole number("int" means integer) 

/* 

* This is the constructor method. It gets called when an object of 

the OddEven type 

* is being created. 

*/ 

public OddEven() { 

/* 

* Code not shown for simplicity. In most Java programs 

constructors can initialize objects 

* with default values, or create other objects that this object 

might use to perform its 

* functions. In some Java programs, the constructor may simply be 

an empty function if nothing 

* needs to be initialized prior to the functioning of the object. 

In this program's case, an 

* empty constructor would suffice, even if it is empty. A 

constructor must exist, however if the 

one. 

} 

* user doesn't put one in then the compiler will create an empty 

*/ 

// This is the main method. It gets called when this class is run 

through a Java interpreter. 


/* 

* This line of code creates a new instance of this class 

called "number" (also known as an 

* Object) and initializes it by calling the constructor. The 

next line of code calls 

you for a number 

} 

* the "showDialog()" method, which brings up a prompt to ask 

*/ 

OddEven number = new OddEven(); 

number.showDialog(); 

public void showDialog() { 

/*


dialog box 

* "try" makes sure nothing goes wrong. If something does, 

* the interpreter skips to "catch" to see what it should do. 

*/ 

try { 

/* 

converted into 

instead of a word. 

calculate() that will 

* The code below brings up a JOptionPane, which is a 

* The String returned by the "showInputDialog()" method is 

* an integer, making the program treat it as a number 

* After that, this method calls a second method, 

* display either "Even" or "Odd." 

*/ 

input = 

Integer.parseInt(JOptionPane.showInputDialog("Please Enter A Number")); 

calculate(); 

} catch (NumberFormatException e) { 

/* 

* Getting in the catch block means that there was a 

problem with the format of 

of a number. 

* the number. Probably some letters were typed in instead 

*/ 

numerical value."); 

} 

/* 

} 

System.err.println("ERROR: Invalid input. Please type in a 

* When this gets called, it sends a message to the interpreter. 

* The interpreter usually shows it on the command prompt (For 

Windows users) 

} 

* or the terminal (For Linux users).(Assuming it's open) 

*/ 

private void calculate() { 

} 

if (input % 2 == 0) { 

System.out.println("Even"); 

} else { 

} 

System.out.println("Odd"); 

• The import statement imports the JOptionPane class from the javax.swing package. 

• The OddEven class declares a single private field of type int named input. Every instance of the OddEven class 

has its own copy of the input field. The private declaration means that no other class can access (read or write) the


input field. 

• OddEven() is a public constructor. Constructors have the same name as the enclosing class they are declared in, 

and unlike a method, have no return type. A constructor is used to initialize an object that is a newly created 

instance of the class. 

• The calculate() method is declared without the static keyword. This means that the method is invoked using a 

specific instance of the OddEven class. (The reference used to invoke the method is passed as an undeclared 

parameter of type OddEven named this.) The method tests the expression input % 2 == 0 using the if keyword to 

see if the remainder of dividing the input field belonging to the instance of the class by two is zero. If this 

expression is true, then it prints Even; if this expression is false it prints Odd. (The input field can be equivalently 

accessed as this.input, which explicitly uses the undeclared this parameter.) 

• OddEven number = new OddEven(); declares a local object reference variable in the main method named 

number. This variable can hold a reference to an object of type OddEven. The declaration initializes number by 

first creating an instance of the OddEven class, using the new keyword and the OddEven() constructor, and then 

assigning this instance to the variable. 

• The statement number.showDialog(); calls the calculate method. The instance of OddEven object referenced by 

the number local variable is used to invoke the method and passed as the undeclared this parameter to the 

calculate method. 

• input = Integer.parseInt(JOptionPane.showInputDialog("Please Enter A Number")); is a statement that 

converts the type of String to the primitive data type int by using a utility function in the primitive wrapper class 

Integer. 

Special classes 

Applet 

Java applets are programs that are embedded in other applications, typically in a Web page displayed in a Web 

browser. 

// Hello.java 

import javax.swing.JApplet; 

import java.awt.Graphics; 

public class Hello extends JApplet { 

} 

public void paintComponent(Graphics g) { 

} 

g.drawString("Hello, world!", 65, 95); 

The import statements direct the Java compiler to include the javax.swing.JApplet and java.awt.Graphics classes 

in the compilation. The import statement allows these classes to be referenced in the source code using the simple 

class name (i.e. JApplet) instead of the fully qualified class name (i.e. javax.swing.JApplet). 

The Hello class extends (subclasses) the JApplet (Java Applet) class; the JApplet class provides the framework for 

the host application to display and control the lifecycle of the applet. The JApplet class is a JComponent (Java 

Graphical Component) which provides the applet with the capability to display a graphical user interface (GUI) and 

respond to user events. 

The Hello class overrides the paintComponent(Graphics) method inherited from the Container superclass to 

provide the code to display the applet. The paintComponent() method is passed a Graphics object that contains the 

graphic context used to display the applet. The paintComponent() method calls the graphic context


drawString(String, int, int) method to display the "Hello, world!" string at a pixel offset of (65, 95) from the 

upper-left corner in the applet's display. 

 

 

 

 

Hello World Applet 

 

 

 

 

 

 

An applet is placed in an HTML document using the HTML element. The applet tag has three attributes 

set: code="Hello" specifies the name of the JApplet class and width="200" height="200" sets the pixel width and 

height of the applet. Applets may also be embedded in HTML using either the object or embed element, [34] although 

support for these elements by Web browsers is inconsistent. [35] However, the applet tag is deprecated, so the object 

tag is preferred where supported. 

The host application, typically a Web browser, instantiates the Hello applet and creates an AppletContext for the 

applet. Once the applet has initialized itself, it is added to the AWT display hierarchy. The paintComponent() 

method is called by the AWT event dispatching thread whenever the display needs the applet to draw itself. 

Servlet 

Java Servlet technology provides Web developers with a simple, consistent mechanism for extending the 

functionality of a Web server and for accessing existing business systems. Servlets are server-side Java EE 

components that generate responses (typically HTML pages) to requests (typically HTTP requests) from clients. A 

servlet can almost be thought of as an applet that runs on the server side—without a face. 

// Hello.java 

import java.io.*; 

import javax.servlet.*; 

public class Hello extends GenericServlet { 

public void service(ServletRequest request, ServletResponse 

response) 

} 

} 

throws ServletException, IOException { 

response.setContentType("text/html"); 

final PrintWriter pw = response.getWriter(); 

pw.println("Hello, world!"); 

pw.close(); 

The import statements direct the Java compiler to include all of the public classes and interfaces from the java.io 

and javax.servlet [36] packages in the compilation.


The Hello class extends the GenericServlet [37] class; the GenericServlet class provides the interface for the server 

to forward requests to the servlet and control the servlet's lifecycle. 

The Hello class overrides the service(ServletRequest, ServletResponse) [38] method defined by the Servlet [39] 

interface to provide the code for the service request handler. The service() method is passed a ServletRequest [40] 

object that contains the request from the client and a ServletResponse [41] object used to create the response returned 

to the client. The service() method declares that it throws the exceptions ServletException [42] and IOException if a 

problem prevents it from responding to the request. 

The setContentType(String) [43] method in the response object is called to set the MIME content type of the 

returned data to "text/html". The getWriter() [44] method in the response returns a PrintWriter object that is used 

to write the data that is sent to the client. The println(String) method is called to write the "Hello, world!" string to 

the response and then the close() method is called to close the print writer, which causes the data that has been 

written to the stream to be returned to the client. 

JavaServer Pages 

JavaServer Pages (JSP) are server-side Java EE components that generate responses, typically HTML pages, to 

HTTP requests from clients. JSPs embed Java code in an HTML page by using the special delimiters . A 

JSP is compiled to a Java servlet, a Java application in its own right, the first time it is accessed. After that, the 

generated servlet creates the response. 

Swing application 

Swing is a graphical user interface library for the Java SE platform. It is possible to specify a different look and feel 

through the pluggable look and feel system of Swing. Clones of Windows, GTK+ and Motif are supplied by Sun. 

Apple also provides an Aqua look and feel for Mac OS X. Where prior implementations of these looks and feels may 

have been considered lacking, Swing in Java SE 6 addresses this problem by using more native GUI widget drawing 

routines of the underlying platforms. 

This example Swing application creates a single window with "Hello, world!" inside: 

// Hello.java (Java SE 5) 

import javax.swing.*; 

public class Hello extends JFrame { 

} 

public Hello() { 

} 

setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); 

add(new JLabel("Hello, world!")); 

pack(); 


} 

new Hello().setVisible(true); 

The first import includes all of the public classes and interfaces from the javax.swing package. 

The Hello class extends the JFrame class; the JFrame class implements a window with a title bar and a close 

control. 

The Hello() constructor initializes the frame by first calling the superclass constructor, passing the parameter "hello", 

which is used as the window's title. It then calls the setDefaultCloseOperation(int) method inherited from JFrame


to set the default operation when the close control on the title bar is selected to 

WindowConstants.EXIT_ON_CLOSE — this causes the JFrame to be disposed of when the frame is closed (as 

opposed to merely hidden), which allows the JVM to exit and the program to terminate. Next, a JLabel is created for 

the string "Hello, world!" and the add(Component) method inherited from the Container superclass is called to add 

the label to the frame. The pack() method inherited from the Window superclass is called to size the window and lay 

out its contents. 

The main() method is called by the JVM when the program starts. It instantiates a new Hello frame and causes it to 

be displayed by calling the setVisible(boolean) method inherited from the Component superclass with the boolean 

parameter true. Once the frame is displayed, exiting the main method does not cause the program to terminate 

because the AWT event dispatching thread remains active until all of the Swing top-level windows have been 

disposed. 

Generics 

In 2004 generics were added to the Java language, as part of J2SE 5.0. Prior to the introduction of generics, each 

variable declaration had to be of a specific type. For container classes, for example, this is a problem because there is 

no easy way to create a container that accepts only specific types of objects. Either the container operates on all 

subtypes of a class or interface, usually Object, or a different container class has to be created for each contained 

class. Generics allow compile-time type checking without having to create a large number of container classes, each 

containing almost identical code. 

Class libraries 

• Java libraries are the compiled 

bytecodes of source code developed 

by the JRE implementor to support 

application development in Java. 

Examples of these libraries are: 

• The core libraries, which 

include: 

• Collection libraries that 

implement data structures 

such as lists, dictionaries, 

trees and sets 

• XML Processing (Parsing, 

Transforming, Validating) libraries 

• Security 

• Internationalization and localization libraries 

Java Platform and Class libraries diagram 

• The integration libraries, which allow the application writer to communicate with external systems. These 

libraries include: 

• The Java Database Connectivity (JDBC) API for database access 

• Java Naming and Directory Interface (JNDI) for lookup and discovery 

• RMI and CORBA for distributed application development 

• JMX for managing and monitoring applications 

• User interface libraries, which include: 

• The (heavyweight, or native) Abstract Window Toolkit (AWT), which provides GUI components, the 

means for laying out those components and the means for handling events from those components


• The (lightweight) Swing libraries, which are built on AWT but provide (non-native) implementations of the 

AWT widgetry 

• APIs for audio capture, processing, and playback 

• A platform dependent implementation of Java Virtual Machine (JVM) that is the means by which the byte codes 

of the Java libraries and third party applications are executed 

• Plugins, which enable applets to be run in Web browsers 

• Java Web Start, which allows Java applications to be efficiently distributed to end-users across the Internet 

• Licensing and documentation. 

Documentation 

Javadoc is a comprehensive documentation system, created by Sun Microsystems, used by many Java developers. It 

provides developers with an organized system for documenting their code. Whereas normal comments in Java and C 

are set off with /* and */, the multi-line comment tags, Javadoc comments have an extra asterisk at the beginning, so 

that the tags are /** and */. 

Editions 

Java Card 

Micro Edition (ME) 

Standard Edition (SE) 

Enterprise Edition (EE) 

PersonalJava (discontinued) 

Sun has defined and supports four editions of Java targeting different application environments and segmented many 

of its APIs so that they belong to one of the platforms. The platforms are: 

• Java Card for smartcards. 

• Java Platform, Micro Edition (Java ME) — targeting environments with limited resources. 

• Java Platform, Standard Edition (Java SE) — targeting workstation environments. 

• Java Platform, Enterprise Edition (Java EE) — targeting large distributed enterprise or Internet environments. 

The classes in the Java APIs are organized into separate groups called packages. Each package contains a set of 

related interfaces, classes and exceptions. Refer to the separate platforms for a description of the packages available. 

The set of APIs is controlled by Sun Microsystems in cooperation with others through the Java Community Process 

program. Companies or individuals participating in this process can influence the design and development of the 

APIs. This process has been a subject of controversy. 

Sun also provided an edition called PersonalJava that has been superseded by later, standards-based Java ME 

configuration-profile pairings.


See also 

• Comparison of programming languages 

• Comparison of Java and C++ 

• Comparison of Java and C# 

• JavaOne 

• Javapedia 

• List of Java virtual machines 

References 

• List of Java APIs 

• List of JVM languages 

• C# 

• Java version history 

• Oak 

• Jon Byous, Java technology: The early years [45] . Sun Developer Network, no date [ca. 1998]. Retrieved April 

22, 2005. 

• James Gosling, A brief history of the Green project [46] . Java.net, no date [ca. Q1/1998]. Retrieved April 29, 2007. 

• James Gosling, Bill Joy, Guy Steele, and Gilad Bracha, The Java language specification, third edition. 

Addison-Wesley, 2005. ISBN 0-321-24678-0 (see also online edition of the specification [47] ). 

• Tim Lindholm and Frank Yellin. The Java Virtual Machine specification, second edition. Addison-Wesley, 1999. 

ISBN 0-201-43294-3 (see also online edition of the specification [48] ). 

External links 

• Sun Microsystems: Java home page [49] 

• Sun Microsystems: Developer Resources for Java Technology [50] . 

• Chamber of Chartered Java Professionals International: Professionalism for Java Technology [51] . 

• Sun Microsystems: Java Language Specification 3rd Edition [52] . 

• Java SE 6 API Javadocs 

• A Brief History of the Green Project [46] 

• Michael O'Connell: Java: The Inside Story [53] , SunWord, July 1995. 

• Patrick Naughton: Java Was Strongly Influenced by Objective-C [54] (no date). 

• David Bank: The Java Saga [55] , Wired Issue 3.12 (December 1995). 

• Shahrooz Feizabadi: A history of Java [56] in: Marc Abrams, ed., World Wide Web – Beyond the Basics, Prentice 

Hall, 1998. 

• Patrick Naughton: The Long Strange Trip to Java [57] , March 18, 1996. 

• Open University (UK): M254 Java Everywhere [58] (free open content documents). 

• is-research GmbH: List of programming languages for a Java Virtual Machine [59] . 

• How Java's Floating-Point Hurts Everyone Everywhere [60] , by W. Kahan and Joseph D. Darcy, University of 

California, Berkeley. 

References 

[1] Java 5.0 added several new language features (the enhanced for loop, autoboxing, varargs and annotations), after they were introduced in the 

similar (and competing) C# language (http:/ / www. barrycornelius. com/ papers/ java5/ ) (http:/ / www. levenez. com/ lang/ ) 

[2] "About Microsoft's "Delegates"" (http:/ / java. sun. com/ docs/ white/ delegates. html). . Retrieved 2010-01-11. "We looked very carefully at 

Delphi Object Pascal and built a working prototype of bound method references in order to understand their interaction with the Java 

programming language and its APIs. [...] Our conclusion was that bound method references are unnecessary and detrimental to the language. 

This decision was made in consultation with Borland International, who had previous experience with bound method references in Delphi 

Object Pascal." 

[3] "The Java Language Environment" (http:/ / java. sun. com/ docs/ white/ langenv/ Intro. doc1. html#943). May 1996. . 

[4] "The Java Language Specification, 2nd Edition" (http:/ / java. sun. com/ docs/ books/ jls/ second_edition/ html/ intro. doc. html#237601). . 

[5] "The A-Z of Programming Languages: Modula-3" (http:/ / www. computerworld. com. au/ index. php/ 

id;1422447371;pp;3;fp;4194304;fpid;1). Computerworld.com.au. . Retrieved 2010-06-09.


[6] Patrick Naughton cites Objective-C as a strong influence on the design of the Java programming language, stating that notable direct 

derivatives include Java interfaces (derived from Objective-C's protocol) and primitive wrapper classes. (http:/ / cs. gmu. edu/ ~sean/ stuff/ 

java-objc. html) 

[7] TechMetrix Research (1999). "History of Java" (http:/ / www. fscript. org/ prof/ javapassport. pdf). Java Application Servers Report. . "The 

project went ahead under the name "green" and the language was based on an old model of UCSD Pascal, which makes it possible to generate 

interpretive code" 

[8] "A Conversation with James Gosling – ACM Queue" (http:/ / queue. acm. org/ detail. cfm?id=1017013). Queue.acm.org. 2004-08-31. . 

Retrieved 2010-06-09. 

[9] http:/ / www. oracle. com/ technetwork/ java/ 

[10] "Programming Language Popularity" (http:/ / www. langpop. com/ ). 2009. . Retrieved 2009-01-16. 

[11] "TIOBE Programming Community Index" (http:/ / www. tiobe. com/ index. php/ content/ paperinfo/ tpci/ index. html). 2009. . Retrieved 

2009-05-06. 

[12] Byous, Jon (ca. 1998). "Java technology: The early years" (http:/ / java. sun. com/ features/ 1998/ 05/ birthday. html). Sun Developer 

Network. Sun Microsystems. . Retrieved 2005-04-22. 

[13] "The History of Java Technology" (http:/ / www. java. com/ en/ javahistory/ ). Sun Developer Network. ca. 1995. . Retrieved 2010-04-30. 

[14] "Jonathan Schwartz's Blog: Different Isn't Always Better, But Better's Always Different" (http:/ / blogs. sun. com/ jonathan/ entry/ 

better_is_always_different). Blogs.sun.com. . Retrieved 2010-06-09. 

[15] Heinz Kabutz, Once Upon an Oak (http:/ / www. artima. com/ weblogs/ viewpost. jsp?thread=7555). Artima. Retrieved April 29, 2007. 

[16] Java Study Group (http:/ / www. open-std. org/ JTC1/ SC22/ JSG/ ); Why Java Was – Not – Standardized Twice (http:/ / csdl2. computer. 

org/ comp/ proceedings/ hicss/ 2001/ 0981/ 05/ 09815015. pdf); What is ECMA—and why Microsoft cares (http:/ / techupdate. zdnet. com/ 

techupdate/ stories/ main/ 0,14179,2832719,00. html) 

[17] "Java Community Process website" (http:/ / www. jcp. org/ en/ home/ index). Jcp.org. 2010-05-24. . Retrieved 2010-06-09. 

[18] "JAVAONE: Sun – The bulk of Java is open sourced" (http:/ / open. itworld. com/ 4915/ 070508opsjava/ page_1. html). open.itworld.com. . 


[19] "Sun’s Evolving Role as Java Evangelist" (http:/ / onjava. com/ pub/ a/ onjava/ 2002/ 04/ 17/ evangelism. html). O'Reilly Media. . 

[20] "1.2 Design Goals of the JavaTM Programming Language" (http:/ / java. sun. com/ docs/ white/ langenv/ Intro. doc2. html). Java.sun.com. 

1999-01-01. . Retrieved 2010-06-09. 

[21] Andy Patrizio (2006). "Sun Embraces Linux With New Java License" (http:/ / www. internetnews. com/ dev-news/ article. php/ 3606656). 

Internet News. Web Media Brands. . Retrieved 2009-09-29. 

[22] "Java for Mac OS X" (http:/ / developer. apple. com/ java/ ). Apple Developer Connection. Apple. . Retrieved 2009-09-29. 

[23] "Microsoft Java Virtual Machine Support" (http:/ / www. microsoft. com/ mscorp/ java/ default. mspx). Microsoft.com. . Retrieved 

2010-06-09. 

[24] "Java SE – Licensees" (http:/ / java. sun. com/ javase/ licensees. jsp). Java.sun.com. 2008-08-12. . Retrieved 2010-06-09. 

[25] James Niccolai (January 23, 2001). "Sun, Microsoft settle Java lawsuit" (http:/ / www. javaworld. com/ javaworld/ jw-01-2001/ 

jw-0124-iw-mssuncourt. html). JavaWorld (IDG). . Retrieved 2008-07-09. 

[26] Jelovic, Dejan. "Why Java Will Always Be Slower than C++" (http:/ / www. jelovic. com/ articles/ why_java_is_slow. htm). . Retrieved 

2008-02-15. 

[27] "Symantec's Just-In-Time Java Compiler To Be Integrated Into Sun JDK 1.1" (http:/ / www. symantec. com/ about/ news/ release/ article. 

jsp?prid=19970407_03). . 

[28] "Apple Licenses Symantec's Just In Time (JIT) Compiler To Accelerate Mac OS Runtime For Java" (http:/ / findarticles. com/ p/ articles/ 

mi_hb6676/ is_/ ai_n26150624). . 

[29] "Java gets four times faster with new Symantec just-in-time compiler" (http:/ / www. infoworld. com/ cgi-bin/ displayStory. pl?980416. 

ehjdk. htm). . 

[30] "Official JStik Website" (http:/ / www. jstik. com/ ). Jstik.com. . Retrieved 2010-06-09. 

[31] "aJile Systems Inc" (http:/ / www. ajile. com/ index. php?option=com_content& task=view& id=21& Itemid=28). Ajile.com. . Retrieved 

2010-06-09. 

[32] "NullPointerException" (http:/ / java. sun. com/ j2se/ 1. 4. 2/ docs/ api/ java/ lang/ NullPointerException. html). Java.sun.com. . Retrieved 

2010-06-09. 

[33] "Exceptions in Java" (http:/ / www. artima. com/ designtechniques/ exceptions. html). Artima.com. . Retrieved 2010-08-10. 

[34] "Using the applet Tag (The Java Tutorials > Deployment > Applets)" (http:/ / java. sun. com/ docs/ books/ tutorial/ deployment/ applet/ 

applettag. html). Java.sun.com. . Retrieved 2010-06-09. 

[35] "Deploying Applets in a Mixed-Browser Environment (The Java Tutorials > Deployment > Applets)" (http:/ / java. sun. com/ docs/ books/ 

tutorial/ deployment/ applet/ mixedbrowser. html). Java.sun.com. . Retrieved 2010-06-09. 

[36] http:/ / java. sun. com/ javaee/ 6/ docs/ api/ javax/ servlet/ package-summary. html 

[37] http:/ / java. sun. com/ javaee/ 6/ docs/ api/ javax/ servlet/ GenericServlet. html 

[38] http:/ / java. sun. com/ javaee/ 6/ docs/ api/ javax/ servlet/ Servlet. html#service(javax. servlet. ServletRequest,javax. servlet. 

ServletResponse) 

[39] http:/ / java. sun. com/ javaee/ 6/ docs/ api/ javax/ servlet/ Servlet. html 

[40] http:/ / java. sun. com/ javaee/ 6/ docs/ api/ javax/ servlet/ ServletRequest. html


[41] http:/ / java. sun. com/ javaee/ 6/ docs/ api/ javax/ servlet/ ServletResponse. html 

[42] http:/ / java. sun. com/ javaee/ 6/ docs/ api/ javax/ servlet/ ServletException. html 

[43] http:/ / java. sun. com/ javaee/ 6/ docs/ api/ javax/ servlet/ ServletResponse. html#setContentType(java. lang. String) 

[44] http:/ / java. sun. com/ javaee/ 6/ docs/ api/ javax/ servlet/ ServletResponse. html#getWriter() 

[45] http:/ / java. sun. com/ features/ 1998/ 05/ birthday. html 

[46] https:/ / duke. dev. java. net/ green/ 

[47] http:/ / java. sun. com/ docs/ books/ jls/ index. html 

[48] http:/ / java. sun. com/ docs/ books/ vmspec/ 2nd-edition/ html/ VMSpecTOC. doc. html 

[49] http:/ / www. java. com/ 

[50] http:/ / java. sun. com/ 

[51] http:/ / www. ccjpint. org/ 

[52] http:/ / java. sun. com/ docs/ books/ jls/ third_edition/ html/ j3TOC. html 

[53] http:/ / sunsite. uakom. sk/ sunworldonline/ swol-07-1995/ swol-07-java. html 

[54] http:/ / cs. gmu. edu/ ~sean/ stuff/ java-objc. html 

[55] http:/ / www. wired. com/ wired/ archive/ 3. 12/ java. saga. html 

[56] http:/ / ei. cs. vt. edu/ ~wwwbtb/ book/ chap1/ java_hist. html 

[57] http:/ / www. blinkenlights. com/ classiccmp/ javaorigin. html 

[58] http:/ / computing. open. ac. uk/ m254/ 

[59] http:/ / www. is-research. de/ info/ vmlanguages/ 

[60] http:/ / www. eecs. berkeley. edu/ ~wkahan/ JAVAhurt. pdf 

Web Language 

HP's Web Language (formerly known as WebL and renamed to avoid a possible trademark conflict [1] ) is a 

scripting language for automating tasks on the World-Wide Web. It is an imperative, interpreted programming 

language implemented in Java and running on the Java Platform that has built-in support for common web protocols 

like HTTP and FTP, and popular data types like HTML and XML. 


• Archived Web site [2] 

References 

[1] "FAQ - Why the name change?" (http:/ / web. archive. org/ web/ 20070428123803/ http:/ / www. hpl. hp. com/ downloads/ crl/ webl/ faq. 

html#name). . Retrieved 2009-03-20. 

[2] http:/ / web. archive. org/ web/ 20070507043202/ http:/ / www. hpl. hp. com/ downloads/ crl/ webl/ index. html


AgentSheets 

rule based visual programming 

Paradigm object-oriented, educational, Conversational Programming 


Designed by Alexander Repenning 

Stable 

release 

3.0 (February 7, 2010) 

Influenced by Lisp, Logo, Smalltalk 

Influenced Etoys, Scratch 

OS OS X, Windows, Linux 

Website http:/ / www. agentsheets. com 

AgentSheets is an educational Cyberlearning [1] tool to create Web-based simulation games. AgentSheets is used 

worldwide to teach students programming and related information technology skills through game design. The 

built-in drag-and-drop language is accessible enough that students without programming background can make their 

own simple Frogger-like game, and publish it on the Web, in their first session. At the same time, AgentSheets is 

powerful enough to make sophisticated The Sims-like games with artificial intelligence. To transition from visual 

programming to more traditional programming students can render their games into Java source code. 

AgentSheets is supported by a middle and high school curriculum called Scalabable Game Design aligned with the 

ISTE National Educational Technology Standards (NETS). The mission of this project is to reinvent computer 

science in public schools by motivating & educating all students including women and underrepresented 

communities to learn about computer science through game design starting at the middle school level. Through this 

curriculum students build increasingly sophisticated games and, as part of this process, learn about computational 

concepts at the level of computational thinking that are relevant to game design as well as to computational science. 

The curriculum is made available through the Scalable Game Design Wiki [2] . Research investigating motivational 

aspects of computer science education in public schools is currently exploring the introduction of game design in 

representative regions of the USA including technology hubs, inner city, rural and remote/tribal areas. Previous 

research has already found that game design with AgentSheets is universally accessible across gender as well as 

ethnicity and is not limited to students interested in playing video games [3] . 

The results [4] of the NSF ITEST program supported research investigating motivational and educational aspects of 

introducing computer science at the middle school level are extremely positive in terms of motivational levels, 

number of participants and participation of women and underrepresented communities. The participation is 

extremely high because most middle schools participating in the study have made Scalable Game Design a module 

that is part of existing required courses (e.g., computer power with keyboarding and power point). Many of the 

middle schools instruct all of their students in scalable game design reaching in some schools over 900 students per


year, per school. Of the well over 1000 students participating in the project in the first semester over 52% were girls. 

Of the girls 85% enjoyed the scalable game design course and 78% would like to take another game design course. 

Similar to a spreadsheet, an agentsheet is a computational grid. Unlike spreadsheets, this grid does not just contain 

numbers and strings but so called agents. These agents are represented by pictures, can be animated, make sounds, 

react to mouse/keyboard interactions, can read web pages, can speak and even recognize speech commands (Mac). 

This grid is well suited to build computational science applications modeling complex scientific phenomena with up 

to tens of thousands of agents. The grid is useful to build agent-based simulations including cellular automata or 

diffusion-based models. These models are used in a wide variety of applications. How does a mudslide work? When 

does a bridge collapse? How fragile are ecosystems? This ability to support game as well as computational science 

applications with the inclusion of scientific visualizations makes AgentSheets a unique computational thinking tool 

that is used computer science and STEM education. 

This work including research, development and commercialization is supported by the National Science Foundation. 

Any opinions, findings, and conclusions or recommendations expressed in this material are those of the authors and 

do not necessarily reflect the views of the National Science Foundation. 

How AgentSheets is used 

AgentSheets is used in a number of contexts worldwide: 

• Middle school students create food web simulations to explore the 

complexity of ecological systems 

• Middle school computer clubs students build computer games 

ranging from simple arcade classic such as Frogger to sophisticated 

AI-based games such as The Sims. 

• High school students use AgentSheets as story telling and 

simulation tool of historical events such as the César Chávez grape 

boycott [5] 

• High school students simulate predator prey worlds and analyzed 

data created with spreadsheets and plots 

• After school science programs show students how to build their own 

science simulations ranging from forest fire simulations to the spreading of viruses. 

• High school students use AgentSheets as introduction to programming tool [6] 

• Graduate and undergraduate courses on educational game design use AgentSheets to prototype, playtest, refine, 

and publish simple educational games [7] 

• Research exploring Artificial intelligence and collaborative agents, e.g., Antiobjects 

History 

The original goal of this research was to explore new models of computational thinking. The first prototype of 

AgentSheets ran in 1989 at the University of Colorado, NCAR, Connection Machine 2. The Connection Machine is 

a highly parallel computer with up to 64,000 CPUs. Realizing how hard it was to program the Connection Machine 

the insight that "CPU cycles will always be ultimately cheaper than cognitive cycles" led to the exploration of 

several new programming paradigms: 

• Agent-Based Graphical Rewrite Rules: (1991) Behavior such as a train following train tracks can be specified 

through before/after rules. These rules can be created by programming by example. The user would tell the 

system to watch the train; the user would move the train on train track one step and stop recording; the system 

would create the rule allowing trains to follow train tracks. Agent-Based Graphical Rewrite Rules were later also 

used in the KidSim/Cocoa/Creator kid programming tool.


• Semantical Rewrite Rules: (1994) It became clear that Agent-Based Graphical Rewrite Rules used in 

AgentSheets91 and KidSim/Cocoa/Creator were not powerful enough for a number of applications that required 

more general pattern. For instance, it was simple to create a rule to make a train follow a straight segment of train 

track but the number of rules quickly exploded when trying to have trains follow all combinations of turns and 

intersections. Semantic rewrite rules could interpret rules topologically. With a single rule a user could create a 

complete train that follows train track behavior. 

• Programming by Analogous Examples: (1995) New behavior can be created through analogies. For instance 

the behavior of a car can be described as analogy to trains. A car moves on a road like a train on a train track. A 

challenge to this approach is conceptual exception handling. Analogies are often either incomplete or too general. 

This requires that users can refine programs produced by Programming by Analogous Examples. 

• Tactile Programming: (1996) AgentSheets becomes the world's first drag and drop educational programming 

environment. Drag and drop interfaces can be used to compose syntactically correct programs. In Visual 

AgenTalk (VAT), a rule-based visual programming language, users create rules by dragging and dropping 

conditions and actions from palettes. The tactile aspect of Visual AgenTalk allows users to perceive through drag 

and drop what programs do. By dragging and dropping conditions, actions, rules and even methods onto agents 

they see the consequence of invoking program fragment without having to write a test program. Similar drag and 

drop programming can later be found in the Etoys language (part of Squeak), in Alice and in Scratch. 

• AgentSheets Inc.: (1996) With the support of the National Science Foundation AgentSheets has become a 

commercial product. The programming model has been extended, more interaction modalities have been added 

(e.g., speech recognition (Mac)), scientific visualization has been refined (e.g., 3D real time plotting (Mac)), and 

AgentSheets has been localized (e.g., Japanese and Greek). 

• Scalable Game Design: (2008) A game design based free curriculum covering computational thinking ideas from 

elementary to graduate school based on AgentSheets. The mission of Scalable Game Design is to: Reinventing 

computer science in public schools by motivating & educating all students including women and 

underrepresented communities to learn about computer science through game design starting at the middle school 

level. The project is funded by the National Science Foundation. 

• Conversational Programming: (2010) AgentSheets 3 is the world first programming environment supporting 

computational thinking by providing information about the meaning of the program. Unlike visual programming 

approaches, which only help with syntactic challenges, such as avoiding missing semicolons, Conversational 

Programming helps with the semantics, that is the meaning of your program. Is this condition true right now? 

Would this rule fire? Why does that rule fail? A conversational programming agent will tell all this and more in a 

non intrusive kind of way. 

See also 

• Web based simulation (WBS) 


• Middle school students making games after 2 hours (YouTube HD movie) [8] 

• AgentSheets papers [9] 

• Educational use of AgentSheets in the Edutech Wiki [10] 

• AgentSheets Inc [11] 

• AgentSheets European Union Project (Greek) [12]


References 

[1] Cyberlearning defined by the National Science Foundation (http:/ / www. nsf. gov/ pubs/ 2008/ nsf08204/ nsf08204. pdf) 

[2] Scalable Game Design Wiki (http:/ / scalablegamedesign. cs. colorado. edu/ wiki/ ) 

[3] publications related to the Scalable Game Design project (http:/ / scalablegamedesign. cs. colorado. edu/ wiki/ Publications) 

[4] http:/ / scalablegamedesign. cs. colorado. edu/ gamewiki/ images/ 2/ 27/ Scalable_Game_Design_Results. pdf 

[5] grape boycott project with simulation (http:/ / l3d. cs. colorado. edu/ systems/ agentsheets/ New-Vista/ grape-boycott/ ) 

[6] An example GK-12 NSF program using AgentSheets: the Memphis Tri-P-LETS project (http:/ / triplets. cs. memphis. edu/ index. 

php?page=project) 

[7] sample games called gamelets (http:/ / www. cs. colorado. edu/ ~ralex/ courses/ gamelet2006/ gamelets/ Space Invaders/ index. html) 

[8] http:/ / www. youtube. com/ watch?v=hcS2CPrYUdY 

[9] http:/ / www. cs. colorado. edu/ ~ralex/ papers/ 

[10] http:/ / edutechwiki. unige. ch/ en/ AgentSheets 

[11] http:/ / www. agentsheets. com 

[12] http:/ / www. agentsheets. gr 

Oak (programming language) 

Oak was a programming language created by James Gosling in 1991, initially for Sun Microsystems set-top box 

project. The language later evolved to become Java. 

The name Oak was used by Gosling after an oak tree that stood outside his office. 

History 

In 1991, Sun Microsystems was attempting to develop a new technology for programming next generation smart 

appliances, which Sun expected to be a major new opportunity. 

The team originally considered using C++, but rejected the idea for several reasons (see Java history). 

Initially, Gosling attempted to modify and extend C++ but soon abandoned that in favor of creating a new platform 

called Green and an entirely new language, which he called Oak, after the tree that stood just outside his office [1] . 

By the summer of 1992, they were able to demonstrate portions of the new platform including the Green OS, the 

Oak language, the libraries, and the hardware. Their first attempt, demonstrated on September 3, 1992, focused on 

building a PDA device named Star7 star7 which had a graphical interface and a smart agent called "Duke" to assist the 

user. 

Oak was renamed Java in 1994 after a trademark search revealed that Oak was used by Oak Technology [2] . Java 1.0 

was finally shipped in 1996 [3] . 

Differences with Java 

Oak was the basis for what Java 1.0 became later, but there were also some differences [4] [5] : Several concepts were 

planned in the Oak specification but remained not implemented in the original language because of time constraints: 

• unsigned primitive types turned out never to be implemented in Java [6] . 

• The enum keyword for enumerated types was implemented in Java for Java 5.0. 

• The assert keyword was implemented in Java for Java 1.4 [7] 

Other concepts were different than, or improved later, for Java: 

• abstract methods were defined as in C++. 

• The package private access level did not exist in Oak. Classes with no access modifier were considered private. 

And finally some concepts were later scraped out: 

• All exceptions were unchecked.

Oak (programming language) 20 

• It was possible by the unprotect keyword to write code that would not signal asynchronous exceptions. 

See also 

• Java (programming language) 



• Oak language specification [8] 

• Alternative site for Oak language specification [9] 

• Java early history [46] 

References 

[1] Jon Byous (April 2003). "Java Technology: The Early Years" (http:/ / java. sun. com/ features/ 1998/ 05/ birthday. html). Sun Microsystems. . 


[2] Kieron Murphy (1996-04-10). "So why did they decide to call it Java?" (http:/ / www. javaworld. com/ javaworld/ jw-10-1996/ 

jw-10-javaname. html). javaworld.com. . Retrieved 2009-08-03. "The lawyers had told us that we couldn't use the name 'OAK' because [it was 

already trademarked by] Oak Technologies," said Frank Yellin, a senior engineer at Sun. "So a brainstorming session was held to come up 

with ideas for a new name" 

[3] Jonathan I. Schwartz (2007-08-30). "Different Isn't Always Better, But Better's Always Different" (http:/ / blogs. sun. com/ jonathan/ entry/ 

better_is_always_different). . Retrieved 2009-08-02. 

[4] Heinz Kabutz (2003-07-15). "Once Upon an Oak ..." (http:/ / www. artima. com/ weblogs/ viewpost. jsp?thread=7555). artima.com. . 


[5] "Oak language specification" (https:/ / duke. dev. java. net/ green/ OakSpec0. 2. ps). Sun Microsystems. . Retrieved 2009-08-02. 

[6] "Java and unsigned int, unsigned short, unsigned byte, unsigned long, etc. (Or rather, the lack thereof)" (http:/ / www. darksleep. com/ player/ 

JavaAndUnsignedTypes. html). . Retrieved 2009-08-02. 

[7] "A Simple Assertion Facility For the Java Programming Language" (http:/ / java. sun. com/ docs/ books/ jls/ assert-spec. html). Sun 

Microsystems. . Retrieved 2009-08-02. 

[8] https:/ / duke. dev. java. net/ green/ OakSpec0. 2. ps 

[9] http:/ / www. me. umn. edu/ ~shivane/ blogs/ cafefeed/ resources/ 14-jun-2007/ OakSpec0. 2. zip

Lightweight Java 21 

Lightweight Java 

Lightweight Java (LJ) is a fully-formalized and extensible minimal imperative fragment of Java. [1] [2] The language 

was designed for academic purposes within the Computer Laboratory, University of Cambridge. The definition of LJ 

was proven type-sound in Isabelle/HOL. 

References 

[1] http:/ / portal. acm. org/ citation. cfm?doid=1297027. 1297064 

[2] http:/ / www. cl. cam. ac. uk/ research/ pls/ javasem/ lj/


.properties 

Filename 

extension 

Type of format ASCII 

.properties 

.properties is a file extension for files mainly used in Java related technologies to store the configurable parameters 

of an application. They can also be used for storing strings for Internationalization and localization; these are known 

as Property Resource Bundles. 

Each parameter is stored as a pair of strings, one storing the name of the parameter (called the key), and the other 

storing the value. 

Format 

Each line in a .properties file normally stores a single property. Several formats are possible for each line, including 

key=value, key = value, key:value, and key value. 

.properties files can use the number sign (#) or the exclamation mark (!) as the first non blank character in a line to 

denote that all text following it is a comment. The backwards slash is used to escape a character. An example of a 

properties file is provided below. 

# You are reading the ".properties" entry. 

! The exclamation mark can also mark text as comments. 

website = http://en.wikipedia.org/ 

language = English 

# The backslash below tells the application to continue reading 

# the value onto the next line. 

message = Welcome to \ 

Wikipedia! 

# Add spaces to the key 

key\ with\ spaces = This is the value that could be looked up with the key "key with spaces". 

# Unicode 

tab : \u0009 

In the example above, website would be a key, and its corresponding value would be 

http://en.wikipedia.org/. While the number sign and the exclamation mark marks text as comments, it 

has no effect when it is part of a property. Thus, the key message has the value Welcome to Wikipedia! 

and not Welcome to Wikipedia. Note also that all of the whitespace in front of Wikipedia! is excluded 

completely. 

The encoding of a .properties file is ISO-8859-1, also known as Latin-1. All non-Latin-1 characters must be entered 

by using Unicode escape characters, e. g. \uHHHH where HHHH is a hexadecimal index of the character in the 

Unicode character set. This allows for using .properties files as resource bundles for localization. A non-Latin-1 text 

file can be converted to a correct .properties file by using the native2ascii tool that is shipped with the JDK or by 

using a tool, such as po2prop [1] , that manages the transformation from a bilingual localization format into .properties 

escaping.


See also 

• java.util.Properties.load(java.io.Reader) - gives the precise semantics of well-formed Java property files 

• java.util.PropertyResourceBundle - describes property resource bundles 

• YAML is used by some for more complex configuration formats. 

References 

[1] Translate Toolkit's po2prop (http:/ / translate. sourceforge. net/ wiki/ toolkit/ po2prop) converts native character encodings in a Gettext PO 

file into correctly escaped ascii without the need for native2ascii


Apache Harmony 

Developer(s) Apache Software Foundation 

Stable release 5.0M14 

6.0M2 / June 7, 2010 

Development status Active 

Written in C++ and Java 

Operating system Windows and Linux 

Type Java Virtual Machine and Java Library 

License Apache License 2.0 

Website http:/ / harmony. apache. org 

Apache Harmony is an open source / free Java implementation from the Apache Software Foundation, starting with 

Java SE 5 and 6. It will be licensed under the Apache License, Version 2. It was announced in early May 2005 and 

on October 25, 2006, the Board of Directors voted to make Apache Harmony a top-level project. 

History 

Initiation 

The Harmony project was initially conceived as an effort to unite all developers of the Free Java implementations. 

Many developers expected that it would be the project above the GNU, Apache and other communities. GNU 

developers were invited into and participated during the initial, preparatory planning. Later it was decided not to use 

the code from GNU Classpath, and that Harmony would use an incompatible license; therefore blocking the sharing 

of code between Harmony and existing free Java projects. Apache developers would then write the needed classes 

from scratch and expect necessary large code donations from software companies. 

Reasons for rewriting from scratch 

The main reason for disagreements between the GNU Classpath and Apache projects is due to differences between 

the GNU General Public License (GNU Classpath's license also contains the linking exception) and Apache License. 

These disagreements are inspired by various organizations and individuals [1] that prefer the Apache License, which 

allows for closed source derived works. GNU Classpath can also be linked [2] with proprietary code, but it is legally 

difficult to make a closed source derivative of GNU Classpath itself. However, many free software developers think 

that the licenses and philosophy of these communities are not different enough to split the efforts, and the inability to 

find compromises is frequently estimated negatively. The occasionally appearing suggestion to view these projects 

as opposing forces does not find wide support. Enthusiasts of the free software tend to break the discussion with the 

simple words that "more free software is not a problem". [3] 

Difficulties to obtain a TCK license from Sun 

The Apache Software Foundation sent a letter to Sun Microsystems CEO, Jonathan Schwartz, on April 10, 2007, 

regarding their inability to acquire an acceptable license for the Java SE 5 Technology Compatibility Kit (TCK), a 

test kit needed by the project to demonstrate compatibility with the Java SE 5 specification, as required by the Sun 

specification license for Java SE 5. [4] What makes the license unacceptable for ASF is the fact that it imposes rights 

restrictions through limits on the "field of use" available to users of Harmony, not compliant with the Java 

Community Process rules. [5]


Sun answered on a company blog [6][7] that it intended to create an open source implementation of the Java 

platform under GPL, including the TCK, but that their current priority was to make the Java Platform accessible to 

the GNU/Linux community under GPL as quickly as possible. 

This answer triggered some reactions, either criticizing Sun for not responding "in a sufficiently open manner" to an 

open letter [8], or rather Apache Software Foundation; some think that ASF acted unwisely to aggressively demand 

something they could have obtained with more diplomacy from Sun, especially considering the timescale of the 

opening class library [9] [10] . 

Since Sun's release of OpenJDK, Sun has released a specific license to allow to run the TCK in the OpenJDK context 

for any GPL implementation deriving substantially from OpenJDK [11] . 

Use in Android SDK 

Dalvik, the Virtual Machine used in Google's Android platform, use a subset of Harmony for the core of its Class 

Library [12] . However, Dalvik does not align to Java SE nor Java ME Class Library profiles (for example J2ME 

classes, AWT and Swing are not supported). Instead it uses its own library [13] , built on top of a subset of Harmony. 

Development team 

Apache Harmony started from being mostly developed by several companies, receiving large code contributions at 

once. However, the general discussions on the mailing lists were always opened for everyone, and later the Apache 

Software foundation mentors put a lot of effort [14] to bring the development process more in line with the Apache 

way, [15] and it seems that their efforts were highly successful. In November 1, 2006, the current team of committers 

consisted of 16 developers, 12 of them from IBM and Intel. [16] 

Recent development status 

Apache Harmony was accepted among the official Apache projects on 29 October 2006. 

Architecture 

The Dynamic Runtime Layer virtual machine consists of the following components: 

1. The VM core: with its subcomponents concentrates most of the JVM control functions. 

2. The porting layer: hides platform-specific details from other VM components behind a single interface and is 

based on the Apache Portable Runtime layer. 

3. The Garbage Collector: allocates Java objects in the heap memory and reclaims unreachable objects using 

various algorithms 

4. Execution Manager: selects the execution engine for compiling a method, handles profiles and the dynamic 

recompilation logic. 

5. Class Library: is a Java standard library. 

6. The thread manager that handle Operating system threading 

7. The execution engine: consists of the following: 

1. The just-in-time compiler for compilation and execution of method code. 

2. The interpreter for easier debugging.


Support Platform and Operating System 

The project provide a portable implementation that ease development on many platforms and operating systems. The 

main focus is on Windows and Linux operating systems on x86 and x86-64 architectures. [17] 

IA32 (Pentium III or 

better) 

x86-64 (Intel 64, 

AMD64) 

Windows 

2000 

In progress 

Windows XP, Server 2003, 

Vista 

Linux RHEL, SLES, Debian, 

Gentoo, Fedora 

Yes Yes 

FreeBSD AIX Mac OS 

In 

progress 

X 

N/A N/A 

N/A Yes Yes N/A N/A N/A 

Itanium (IA64, IPF) N/A In progress Yes N/A N/A N/A 

PPC32 N/A N/A In progress N/A N/A N/A 

PPC64 

N/A N/A 

In progress 

N/A 

In 

progress 

zSeries (31 bit) N/A N/A In progress N/A N/A N/A 

Class Library Coverage 

The expected donations from software companies were 

actually received. The Apache Harmony now contains the 

working code, including the Swing, AWT and Java 2D 

code which were contributed by Intel. 

The part of the implemented classes is still smaller than in 

GNU Classpath (97.7% in the trunk versus almost 100% 

as of July 2007 [18] ), despite some non-trivial applications 

were shown being running in 2006 JavaOne international 

conference. 

Also Harmony's test suite is less extensive than GNU 

Classpath's for now (20000 tests [19] versus 50000 [20] as of October 2006). 

Java Platform diagram showing Class Library 

The progress of the Apache Harmony project can be tracked against J2SE 1.4 and Java SE 5.0. [21] Also, there is a 

branch for Harmony v6.0 in development for Java SE 6.0. 

Apache Harmony developers integrate several existing, field-tested open-source projects to meet their goal (not 

reinventing the wheel). Many of these projects are mature and well known and other part of the library need be 

writing from scratch. 

This is a list of existing open source components that are used in the Apache Harmony project; some of them were in 

use before the project started. 

N/A


Component Description 

ICU Mature C/C++ and Java libraries for Unicode support, software internationalization and software globalization. 

Apache Xalan An XSLT stylesheet processor for Java and C++ which implements the XPath language. 

Apache Xerces An XML parser library for Java, C++ and Perl 

Apache Portable 

Runtime 

Cross-platform abstraction library provides platform independence. 

Apache CXF Robust and high performance Web Services framework work over protocols such as SOAP, XML/HTTP, RESTful HTTP, 

and CORBA. 

BCEL Libraries for decomposing, modifying, and recomposing binary Java classes (i.e., bytecode) 

MX4J Java Management Extensions (JMX) tools for managing and monitoring applications, system objects, devices and service 

oriented networks. 

vmmagic Set of extensions to the Java language to facilitate systems programming in Java by adding direct memory operations etc. 

Bouncy Castle Libraries collection of lightweight cryptography for Java and C#. 

ANTLR language tool that provides a framework for constructing recognizers, interpreters, compilers, and translators from 

Documentation 

grammatical descriptions containing actions in a variety of target languages. 

Harmony is currently less documented than the alternative free Java implementations. For instance, in GNU 

Classpath every method of the central CORBA class (ORB) has the explaining comment both in the standard 

abstract API class [22] and implementation [23]. In the Yoko [24] project, used by Harmony [25], the majority of 

methods both in the standard declaration [26] and implementing class [27] were not documented (at the end of 

October, 2006). Also, GNU Classpath supported both older and current CORBA features (same as Sun's 

implementation). Harmony, differently, left the central method of the older standard (ORB.connect(Object)) fully 

unimplemented. 

Tools 

A complete implementation of the Java platform also requires a compiler that translates Java source code into 

bytecodes, a program that manages JAR files, a debugger, and an applet viewer and web browser plugin, to name a 

few. Harmony currently has the compiler, appletviewer, jarsigner, javah, javap, keytool, policytool, and unpack200 

[28]. 

Virtual machine support 

Harmony currently has seven virtual machine implementations that run Harmony Class Library, all of which were 

donations by external groups: 

• JC Harmony Edition VM, "JCHEVM," based on the JCVM's interpreter, contributed by the author, Archie Cobbs. 

• BootJVM, a simple bootstrapping virtual machine, contributed by Daniel Lydick. 

• SableVM, an advanced, portable interpreter, contributed by authors from the Sable Research Group; and the 

Dynamic Runtime Layer Virtual Machine. 

• DRLVM, a just-in-time compiler contributed by Intel. 

• BEA announced the availability of an evaluation version of JRockit VM running Apache Harmony Class 

Library [29] . 

• JikesRVM, an open-source meta-circular JVM that use the Apache Harmony Class Library [30] . 

• Ja.NET SE - the open source project is providing a Java 5 JDK (class libraries, tools, etc.) that run on the .NET 

CLR. Ja.NET SE is based on the Apache Harmony Class Libraries [31] .


In the end of November, 2006, the language support provided by these virtual machine was still incomplete, and the 

build instructions recommended to use IBM's proprietary J9 instead to run the class library test suite. However, this 

is not necessary anymore (as of July 2007). The DRLVM virtual machine is currently (as of July 2006) under heavy 

development, so a fast improvement of its features can be expected. 

Applications status 

Since its conception, Harmony has steadily grown in its ability to execute non-trivial Java applications (see here 

[32] ). As of July 2007, supported applications include: 

• Eclipse : 99.3% of the 36000 RI test pass on Harmony's DRLVM + class library. [33]. 

• Apache Tomcat : 100% of the RI tests pass [34]. 

• JUnit : 100% of the RI tests pass [35]. 

• Apache Ant : 97% of the RI tests pass. [36]. 

• other applications pass with a high success rate, such as Apache Derby, Apache Axis, Log4j, Apache Velocity, 

Apache Cocoon, jEdit, and Apache Commons. 

However, Harmony's incomplete library prevents it from launching some other applications: 

• ArgoUML: because it requires a Java applet implementation, which is still not available in Harmony. 

• Apache Geronimo runs on Apache Harmony with some issues and workarounds [37] . 

• Vuze, formerly Azureus, because of unimplemented security classes. 

See also 

• GNU Classpath 


• Free Java implementations 

• Java Class Library 


• Official website [38] 

• Apache Harmony FAQ [39] 

• Apache Harmony source code repository [40] 

• JavaOne 2006 Online Harmony Session [41] 

• JavaOne 2007 Online Harmony Session [42] 

• Apache Harmony [43] by Geir Magnusson Jr at JavaPolis 2006 

• The Java open source debate [44] - a good summary of the debate 

References 

[1] Mark Wielaard (2006-05-24). "Toward a free Java" (http:/ / lwn. net/ Articles/ 184967/ ). LWN.net. . 

[2] "GNU Classpath License" (http:/ / www. gnu. org/ software/ classpath/ license. html). . 

[3] Dalibor Topic (2006-06-01). "Harmony, JavaONE 2007 and other thoughts" (http:/ / developer. classpath. org/ pipermail/ classpath/ 

2006-June/ 000965. html). . 

[4] Open Letter to Sun Microsystems (http:/ / www. apache. org/ jcp/ sunopenletter. html) 

[5] According to ASF, 1) a specification lead cannot impose any contractual condition or covenant that would limit or restrict the right of any 

licensee to create or distribute such Independent Implementations (section 5.C.III), and 2) a specification lead must license all necessary IP 

royalty-free to any compatible implementation of a specification (section 5.B). 

[6] http:/ / blogs. sun. com/ ontherecord/ 

[7] http:/ / java. sys-con. com/ read/ 360602. htm 

[8] http:/ / ianskerrett. wordpress. com/ 2007/ 04/ 16/ the-silence-from-an-open-sun/ 

[9] http:/ / gnu. wildebeest. org/ diary/ 2007/ 04/ 21/ openjck/


[10] Gilbert, Dave (2007-04-16). "Five Reasons Why Apache Will Regret That Open Letter" (http:/ / jroller. com/ page/ 

dgilbert?entry=five_reasons_why_apache_will). . Retrieved 2008-03-08. 

[11] "OPENJDK COMMUNITY TCK LICENSE AGREEMENT V 1.1" (http:/ / openjdk. java. net/ legal/ openjdk-tck-license. pdf) (PDF). Sun 

Microsystems. . Retrieved 2008-03-08. "Subject to and conditioned upon its Licensee Implementation being substantially derived from 

OpenJDK Code and, if such Implementation has or is to be distributed to a third party, its being distributed under the GPL License, Sun 

hereby grants to Licensee, to the extent of Sun's Intellectual Property Rights in the TCK, a worldwide, personal, non-exclusive, 

non-transferable, limited license to use the TCK internally and solely for the purpose of developing and testing Licensee Implementation." 

[12] "Google's Android SDK Bypasses Java ME in Favor of Java Lite and Apache Harmon" (http:/ / www. infoq. com/ news/ 2007/ 11/ 

android-java). infoq.com. 2007-11-12. . Retrieved 2009-05-31. "Instead of providing a full version of the Java SE or Java ME Google has 

diverged on two fronts. First, a limited subset of the core Java packages is provided. (...) By going this route Android is following in the 

footsteps of another Google project GWT which uses Java as its development language but does not support the full JDK." 

[13] "Package Index" (http:/ / developer. android. com/ reference/ packages. html). Open Handset Alliance. . Retrieved 2009-05-31. 

[14] Leo Simons (2006-07-24). ""We would like all the development to happen right here"" (http:/ / article. gmane. org/ gmane. comp. java. 

harmony. devel/ 10742). . 

[15] "The Apache Way" (http:/ / incubator. apache. org/ learn/ theapacheway. html). . 

[16] "List of Apache Harmony Committers" (http:/ / incubator. apache. org/ harmony/ contributors. html). . 

[17] Apache Harmony supported platforms and operating systems (http:/ / harmony. apache. org/ supported_platforms. html) 

[18] that a class is implemented does not imply that this class behaves as requested in the RI but the empty declaration is not an implemented 

method - some core functionality must be present. GNU Classpath uses special class of exception to mark stubs and do not count them as 

implemented methods 

[19] http:/ / wiki. apache. org/ harmony/ Unit_Tests_Pass_on_DRLVM 

[20] http:/ / www. object-refinery. com/ classpath/ mauve/ report/ 

[21] Apache Harmony Library Coverage against Java SE 5.0 (http:/ / people. apache. org/ ~chunrong/ latest-harmony-japi. html) 

[22] http:/ / cvs. savannah. gnu. org/ viewcvs/ *checkout*/ classpath/ org/ omg/ CORBA/ ORB. java?rev=1. 2. 2. 12& root=classpath 

[23] http:/ / cvs. savannah. gnu. org/ viewcvs/ *checkout*/ classpath/ gnu/ CORBA/ OrbFunctional. java?rev=1. 6& root=classpath 

[24] http:/ / incubator. apache. org/ yoko/ 

[25] http:/ / www. mail-archive. com/ yoko-dev@incubator. apache. org/ msg01428. html 

[26] http:/ / svn. apache. org/ repos/ asf/ incubator/ yoko/ trunk/ yoko-spec-corba/ src/ main/ java/ org/ omg/ CORBA/ ORB. java 

[27] http:/ / svn. apache. org/ repos/ asf/ incubator/ yoko/ trunk/ core/ src/ main/ java/ org/ apache/ yoko/ orb/ OBCORBA/ ORB_impl. java 

[28] http:/ / incubator. apache. org/ harmony/ roadmap. html#General 

[29] BEA JRockit VM under a binary, evaluation-only license (http:/ / mail-archives. apache. org/ mod_mbox/ harmony-dev/ 200701. mbox/ 

) 

[30] Announcing Jikes RVM 3.0 + Apache Harmony (http:/ / mail-archives. apache. org/ mod_mbox/ harmony-dev/ 200808. mbox/ 

) 

[31] Ja.NET SE an open source project is providing a Java 5 JDK running on the .NET CLR (http:/ / www. janetdev. org/ ) 

[32] http:/ / wiki. apache. org/ harmony/ Application_Status 

[33] http:/ / wiki. apache. org/ harmony/ Eclipse_Unit_Tests_Pass_on_DRLVM#PassRate_2007 

[34] http:/ / wiki. apache. org/ harmony/ Apache_Tomcat 

[35] http:/ / wiki. apache. org/ harmony/ JUnit 

[36] http:/ / wiki. apache. org/ harmony/ Apache_Ant 

[37] Running Geronimo on Harmony (http:/ / cwiki. apache. org/ confluence/ display/ GMOxDOC20/ Apache+ Harmony) 

[38] http:/ / harmony. apache. org/ 

[39] http:/ / mail-archives. apache. org/ mod_mbox/ incubator-general/ 200505. mbox/ 

%3CE3603144-2C26-4C31-896D-6CC7445A63EB@apache. org%3E 

[40] http:/ / svn. apache. org/ viewcvs. cgi/ incubator/ harmony/ enhanced/ classlib/ trunk/ modules/ 

[41] http:/ / developers. sun. com/ learning/ javaoneonline/ 2006/ coreplatform/ TS-3752. html 

[42] http:/ / developers. sun. com/ learning/ javaoneonline/ j1sessn. jsp?sessn=TS-7820& yr=2007& track=6 

[43] http:/ / parleys. com/ display/ PARLEYS/ Apache+ Harmony?showComments=true 

[44] http:/ / www. osnews. com/ story. php?news_id=10806

Apache Muse 30 

Apache Muse 

The Apache Muse Project is a Java-based implementation of the Web Services Resource Framework (WSRF), 

WS-BaseNotification (WSN), and Web Services Distributed Management (WSDM) specifications. 

See also 

• Service-oriented architecture (SOA) 

• Apache Tomcat (Servlet Container) 

• SOAP (Simple Object Access Protocol) 

• WSDL (Web Service Description Language) 


• Homepage of Apache Muse [1] 

• Homepage of the Web Services Project @ Apache [2] 

• Homepage of Apache Axis [3] 

• Homepage of Apache Axis2 [4] 

• SAAJ from Sun [5] 

• Lomboz-Plugin for Eclipse [6] 

References 

[1] http:/ / ws. apache. org/ muse/ 

[2] http:/ / ws. apache. org/ 

[3] http:/ / ws. apache. org/ axis 

[4] http:/ / ws. apache. org/ axis2/ 

[5] http:/ / java. sun. com/ webservices/ saaj/ index. jsp 

[6] http:/ / lomboz. objectweb. org/


Apache Shiro 


Stable release incubation / March 4, 2009 

Written in Java 

Operating 

system 

Cross-platform 

Type java security framework 


Website [1] 

Apache Shiro (formerly known as jSecurity and Apache KI) is a java security framework designed to have a clean 

object model, and easy to plugin. Apache Ki has been renamed to Apache Shiro . [2] 

Overview 

Shiro is designed to be easier to use than JAAS and to be accessible to non-java applications. Shiro supports Role 

and User permissions, and has bindings for web applications (JSecurityFilter). The permissions can be stored on a 

LDAP or on a database (via JDBC). It also integrates with Spring framework 

Example 

//Permissions can be checked using object-based permissions 

PrinterPermission perm = new PrinterPermission("hplaserjet"); 

if(perm.isPermitted()) { 

//show print button 

} else { 

} 

See also 

//grey out button 

• Java Authentication and Authorization Service (JAAS) 

• Enterprise_JavaBean#Security EJB Container-Managed Security 

• JGuard [3] , an LGPL-licensed security framework 

• Spring Security, an Apache-licensed Java security framework 


• Apache Shiro homepage [1] 

• Apache Shiro Presentation [4] 

• JSecurity Tutorial by Bruce Philips [5]


References 

[1] http:/ / incubator. apache. org/ shiro/ 

[2] "Ki to Shiro renaming vote" (http:/ / n2. nabble. com/ Apache-JSecurity-Ki-Project-Rename---VOTE-RESULT-td3057020. html#a3057020). 

. 

[3] http:/ / jguard. xwiki. com/ xwiki/ bin/ view/ Main/ WebHome 

[4] http:/ / www. jsecurity. org/ files/ JSecurity. pdf 

[5] http:/ / www. brucephillips. name/ blog/ index. cfm/ 2009/ 4/ 5/ An-Introduction-to-Ki-formerly-JSecurity--A-Beginners--Tutorial-Part-1 

Java applet 

A Java applet is an applet delivered to the users in the form of Java 

bytecode. Java applets can run in a Web browser using a Java Virtual 

Machine (JVM), or in Sun's AppletViewer, a stand-alone tool for 

testing applets. Java applets were introduced in the first version of the 

Java language in 1995. Java applets are usually written in the Java 

programming language but they can also be written in other languages 

that compile to Java bytecode such as Jython, [7] Ruby, [8] or Eiffel. [9] 

Applets are used to provide interactive features to web applications 

that cannot be provided by HTML alone. They can capture mouse 

input (like rotating 3D object) and also have controls like buttons or 

check boxes. In response to the user action an applet can change the 

provided graphic content. This makes applets well suitable for 

demonstration, visualization and teaching. There are online applet 

collections for studying various subjects, from physics [10] to heart 

physiology. [3] Applets are also used to create online game collections 

that allow players to compete against live opponents in real-time. 

An applet can also be a text area only, providing, for instance, a cross 

platform command-line interface to some remote system. [11] If needed, 

an applet can leave the dedicated area and run as a separate window. 

However, applets have very little control over web page content 

outside the applet dedicated area, so they are less useful for improving 

the site appearance in general (while applets like news tickers [12] or 

WYSIWYG editors [13] are also known). Applets can also play media in 

formats that are not natively supported by the browser [14] 

Java applets run at a speed that is comparable to (but generally slower 

than) other compiled languages such as C++, but many times faster 

than JavaScript. [15] In addition they can use 3D hardware acceleration 

that is available from Java. This makes applets well suited for non 

trivial, computation intensive visualizations. 

HTML pages may embed parameters that are passed to the applet. 

Hence the same applet may appear differently depending on the 

parameters that were passed. The first implementations involved 

downloading an applet class by class. While classes are small files, 

Java applet that was created as a supplementary 

demonstration material of the scientific 

publication. [1] and is available from the 

university site 

Java applet that uses 3D hardware acceleration, 

downloading from the server 3D files in .pdb 

format to visualize [2]


there are frequently a lot of them, so applets got a reputation as slow 

loading components. However, since jars were introduced, an applet is 

usually delivered as a single file that has a size of the bigger image 

(hundreds of kilobytes to several megabytes). 

Since Java's bytecode is platform independent, Java applets can be 

executed by browsers for many platforms, including Microsoft 

Windows, Unix, Mac OS and Linux. It is also trivial to run a Java 

applet as an application with very little extra code. This has the 

advantage of running a Java applet in offline mode without the need 

for any Internet browser software and also directly from the 

development IDE. 

Many Java developers, blogs and magazines are recommending that 

[16] [17] 

the Java Web Start technology be used in place of Applets. 

A Java Servlet is sometimes informally compared to be "like" a 

server-side applet, but it is different in its language, functions, and in 

each of the characteristics described here about applets. 

Technical information 

Java applets are executed in a sandbox by most web browsers, 

preventing them from accessing local data like clipboard or file system. 

The code of the applet is downloaded from a web server and the 

browser either embeds the applet into a web page or opens a new 

window showing the applet's user interface. 

A Java applet extends the class java.applet.Applet, or in the case of a 

Swing applet, javax.swing.JApplet. The class must override methods 

from the applet class to set up a user interface inside itself (Applet is a 

descendant of Panel which is a descendant of Container. As applet 

inherits from container, it has largely the same user interface 

possibilities as an ordinary Java application, including regions with 

user specific visualization. 

The domain from where the applet executable has been downloaded is 

the only domain to which the usual (unsigned) applet is allowed to 

communicate. This domain can be different from the domain where the 

surrounding HTML document is hosted. 

Using applet for non trivial 

animation illustrating 

biophysical topic (randomly 

moving ions pass through 

voltage gates) [3] 

Using Java applet for computation - intensive 

visualization of the Mandelbrot set [4] 

Java system libraries and runtimes are backwards compatible, allowing to write code that runs both on current and on 

future versions of the Java virtual machine. 

Embedding into web page 

The applet can be displayed on the web page by making use of the deprecated applet HTML element, [18] or the 

recommended object


element. [19] A non standard embed element can be used [20] with 

Mozilla family browsers. This specifies the applet's source and 

location. Object and embed tags can also download and install Java 

virtual machine (if required) or at least lead to the plugin page. Applet 

and object tags also support loading of the serialized applets that start 

in some particular (rather than initial) state. Tags also specify the 

message that shows up in place of the applet if the browser cannot run 

it due any reason. 

However, despite object being officially a recommended tag, as of 

2010, the support of the object tag was not yet consistent among 

browsers and Sun kept recommending the older applet tag for 

deploying in multibrowser environments, [20] as it remained the only 

tag consistently supported by the most popular browsers. To support 

multiple browsers, the object tag currently requires JavaScript (that 

recognizes the browser and adjusts the tag), usage of additional 

browser-specific tags or delivering adapted output from the server side. 

Deprecating applet tag has been criticised. [21] Oracle now provides a 

maintained JavaScript code [22] to launch applets with cross platform 

workarounds. 

Simple examples 

A basic example using the java.applet package 

The following example is made simple enough to illustrate the 

essential use of Java applets through its java.applet package. It also 

uses classes from the Java Abstract Window Toolkit (AWT) for 

producing actual output (in this case, the "Hello, world!" message). 

import java.applet.Applet; 

import java.awt.*; 

// Applet code for the "Hello, world!" example. 

// This should be saved in a file named as "HelloWorld.java". 

public class HelloWorld extends Applet { 

Sufficient running speed is also utilized in applets 

for playing non trivial computer games like 

chess [5] 

NASA World Wind (open source) is a second 

generation applet [6] that makes heavy use of 

OpenGL and on-demand data downloading to 

provide a detailed 3D map of the world. 

// This method is mandatory, but can be empty (i.e., have no actual 

Web access to the server console at the hardware 

code). 

level with the help of a Java applet 

public void init() { } 

// This method is mandatory, but can be empty. 

public void stop() { } 

// Print a message on the screen (x=20, y=10). 

public void paint(Graphics g) {


} 

} 

g.drawString("Hello, world!", 20,10); 

More simple applets are available at Wikiversity [23] . 

For compilation, this code is saved on a plain-ASCII file with the same name as the class and .java extension, i.e. 

HelloWorld.java. The resulting HelloWorld.class applet should be installed on the web server and is 

invoked within an HTML page by using an or an tag. For example: 

 

 

 

HelloWorld_example.html 

 

 

A Java applet example 

Here it is: 

This is where HelloWorld.class runs. 

 

 

Displaying the HelloWorld_example.html page from a Web server, the result should look as this: 

A Java applet example 

Here it is: Hello, world! 

To minimize download time, applets are usually delivered in a form of compressed zip archive (having jar 

extension). If all needed classes (only one in our case) are placed in compressed archive example.jar, the embedding 

code would look differently: 

Here it is: 

This is where HelloWorld.class runs. 

Applet inclusion is described in detail in Sun's official page about the APPLET tag. [24] 

Advantages 

A Java applet can have any or all of the following advantages: 

• It is simple to make it work on Linux, Microsoft Windows and Mac OS X i.e. to make it cross platform. Applets 

are supported by most web browsers. 

• The same applet can work on "all" installed versions of Java at the same time, rather than just the latest plug-in 

version only. However, if an applet requires a later version of the Java Runtime Environment (JRE) the client will 

be forced to wait during the large download. 

• Most web browsers cache applets, so will be quick to load when returning to a web page. Applets also improve 

with use: after a first applet is run, the JVM is already running and starts quickly (the JVM will need to restart 

each time the browser starts afresh). 

• It can move the work from the server to the client, making a web solution more scalable with the number of 

users/clients.


• If a standalone program (like Google Earth) talks to a web server, that server normally needs to support all 

previous versions in case a user has not kept his or her client software up to date. In contrast, a properly 

configured browser loads (and caches) the latest applet version, so there is no need to support legacy versions. 

• The applet naturally supports the changing user state, such as figure positions on the chessboard. 

• Developers can develop and debug an applet direct simply by creating a main routine (either in the applet's class 

or in a separate class) and calling init() and start() on the applet, thus allowing for development in their favorite 

Java SE development environment. All one has to do after that is re-test the applet in the AppletViewer program 

or a web browser to ensure it conforms to security restrictions. 

• An untrusted applet has no access to the local machine and can only access the server it came from. This makes 

such an applet much safer to run than a standalone executable that it could replace. However, a signed applet can 

have full access to the machine it is running on if the user agrees. 

• Java applets are fast - and can even have similar performance to native installed software. 

Disadvantages 

A Java applet may have any of the following disadvantages: 

• It requires the Java plug-in. 

• Some organizations only allow software installed by the administrators. As a result, some users can only view 

applets that are important enough to justify contacting the administrator to request installation of the Java plug-in. 

• As with any client-side scripting, security restrictions may make it difficult or even impossible for an untrusted 

applet to achieve the desired goals. 

• Some applets require a specific JRE. This is discouraged. [25] 

• If an applet requires a newer JRE than available on the system, or a specific JRE, the user running it the first time 

will need to wait for the large JRE download to complete. 

• Java automatic installation or update may fail if a proxy server is used to access the web. This makes applets with 

specific requirements impossible to run unless Java is manually updated. The Java automatic updater that is part 

of a Java installation also may be complex to configure if it must work through a proxy. 

• Unlike the older applet tag, the object tag needs workarounds to write a cross-browser HTML document. 

Compatibility related lawsuits 

Sun has made a considerable effort to ensure compatibility is maintained between Java versions as they evolve, 

enforcing Java portability by law if required. Oracle seems to be continuing the same strategy. 

The 1997 Sun - Microsoft lawsuit 

The 1997 lawsuit [26] was filed after Microsoft modified its own Java Virtual Machine which shipped with Internet 

Explorer. Microsoft added about 50 methods and 50 fields [26] into the classes within the java.awt, java.lang, and 

java.io packages. Other modifications included removal of RMI capability and replacement of Java native interface 

from JNI to RNI, a different standard. RMI was removed because it only easily supports Java to Java 

communications and competes with Microsoft DCOM technology. Applets that relied on these changes or just 

inadvertently used them worked only within Microsoft's Java system. Sun sued for breach of trademark, as the point 

of Java was that there should be no proprietary extensions and that code should work everywhere. Microsoft agreed 

to pay Sun $20 million, and Sun agreed to grant Microsoft limited license to use Java without modifications only and 

for a limited time. [27]


The 2002 Sun - Microsoft lawsuit 

Microsoft continued to ship its own unmodified Java virtual machine. Over years it has become extremely outdated 

yet still default for Internet Explorer. In 2002 Sun filed an antitrust lawsuit, claiming that Microsoft's attempts at 

illegal monopolization have harmed the Java platform. Sun demanded Microsoft distribute Sun's current, binary 

implementation of Java technology as part of Windows, distribute it as a recommended update for older Microsoft 

desktop operating systems and stop the distribution of Microsoft's Virtual Machine (as its licensing time, agreed in 

the previous lawsuit, had expired). [27] Microsoft paid $700 million for pending antitrust issues, another $900 million 

[28] [29] 

for patent issues and a $350 million royalty fee to use Sun's software in the future. 

The 2010 Oracle - Google lawsuit 

Google has developed their own Android platform that uses Java features and concepts yet is not compatible with 

standard libraries. This has been a violation of conditions under that Sun granted OpenJDK patents to use open 

source Java for all [30] . 2010 Oracle sued Google [31] for using Java "in a wrong way", claiming that "Google’s 

Android competes with Oracle America’s Java" and that "Google has been aware of Sun’s patent portfolio .. since 

Google hired certain former Sun Java engineers". Oracle currently seems claiming as much as to stop the further 

Android development, trying to replace it by standard Java version [32] . This lawsuit is currently ongoing. 

Applet security 

There are two applet types with very different security models: signed applets and unsigned applets. [33] 

Unsigned applet 

Limitations for the unsigned applets are understood as "draconian": [34] they have no access to the local filesystem 

and web access limited to the applet download site; there are also many other important restrictions. For instance, 

they cannot access system properties, use their own class loader, call native code, execute external commands on a 

local system or redefine classes belonging to certain packages. While they can run in a standalone frame, such frame 

contains a header, indicating that this is an untrusted applet. Successful initial call of the forbidden method does not 

automatically create a security hole as an access controller checks the entire stack of the calling code to be sure the 

call is not coming from an improper location. Several specific security problems have been discovered and fixed 

since Java was first released, and some, like the Calendar serialization security bug [35] , even persisted as late as 

2008 without anybody being aware. Some studies mention applets crashing the browser or overusing CPU resources 

but these are classified as nuisances [36] and not as true security flaws. However, unsigned applets may be involved in 

combined attacks that exploit a combination of multiple severe configuration errors in other parts of the system. [37] 

An unsigned applet can also be more dangerous to run directly on the server where it is hosted because while code 

base allows it to talk with the server, running inside it can bypass the firewall. An applet may also try DOS attack on 

the server where it is hosted but usually people who manage the web site also manage the applet, making this 

unreasonable. Communities may solve this problem via source code review or running applets on a dedicated 

domain. [38] [39] . 

[36] [40] 

As of 1999 no real security breaches involving unsigned applets have ever been publicly reported. 

Signed applet 

A signed applet [41] contains a signature that the browser should verify through a remotely running, independent 

certificate authority server. Producing this signature involves specialized tools and interaction with the authority 

server maintainers. Once the signature is verified, and the user of the current machine also approves, a signed applet 

can get more rights, becoming equivalent to an ordinary standalone program. The rationale is that the author of the 

applet is now known and will be responsible for any deliberate damage. This approach allows applets to be used for


many tasks that are otherwise not possible by client-side scripting. However, this approach requires more 

responsibility from the user, deciding whom he or she trusts. The related concerns include a non-responsive authority 

server, wrong evaluation of the signer identity when issuing certificates, and known applet publishers still doing 

something that the user would not approve of. Hence signed applets that appeared from Java 1.1 may actually have 

more security concerns [42] . 

Java security problems are not fundamentally different from similar problems of any client-side scripting platform. 

In particular, all issues related to signed applets also apply to Microsoft ActiveX components. 

Alternatives 

Alternative technologies exist (for example, JavaScript, Curl, Flash, and Microsoft Silverlight) that satisfy some of 

the scope of what is possible with an applet. Of these, JavaScript is not always viewed as a competing replacement; 

JavaScript can coexist with applets in the same page, assist in launching applets (for instance, in a separate frame or 

providing platform workarounds) and later be called from the applet code. [43] 

See also 

• ActiveX control 

• Curl 

• Java programming language 

• Java Servlet 

• Java Web Start 

• JavaFX 


• Latest version of Sun Microsystems Java Virtual Machine [44] (includes browser plug-ins for running Java applets 

in most web browsers). 

• Information about writing applets from Sun Microsystems [45] 

• Demonstration applets from Sun Microsystems [46] (JDK 1.4 - include source code) 

• JavaRanch Applet FAQ [47] 

• Pulpcore: Open-source 2D rendering and animation framework for the Java plug-in [48] 

References 

[1] World of Fungi (http:/ / www. world-of-fungi. org/ Models/ tropisms/ java_a. htm) - page of the scientific project, serving an applet that is 

used as an illustration figure 

[2] The home site of the 3D protein viewer (Openastexviewer) under LGPL (http:/ / openastexviewer. net/ web/ ) 

[3] The virtual hearth (http:/ / thevirtualheart. org/ CAPindex. html) 

[4] The home site of the Mandelbrot set applet under GPL (http:/ / www. its. caltech. edu/ ~dannyc/ fractals/ simple. html) 

[5] The home site of the chess applet under BSD (http:/ / english. op. org/ ~peter/ ChessApp/ ) 

[6] Java.Sun.com (http:/ / java. sun. com/ developer/ technicalArticles/ javase/ newapplets/ ) 

[7] Jython applet page (http:/ / www. jython. org/ archive/ 21/ applets/ index. html) 

[8] About Java applets in Ruby (http:/ / michal. hantl. cz/ ruby-in-browser-jruby-inside-an-applet/ ) 

[9] At tool to produce Java applets with SmartEiffel (http:/ / eiffelzone. com/ esd/ wrapj/ index. html) 

[10] Paul Falstad online applet portal (http:/ / www. falstad. com/ mathphysics. html) 

[11] Jraft.com (http:/ / www. jcraft. com/ jcterm/ ) 

[12] ObjectPlanet.com (http:/ / www. objectplanet. com/ newsticker/ ), an applet that works as news ticker 

[13] Sferyx.com (http:/ / www. sferyx. com/ ), a company that produces applets acting as WYSWYG editor. 

[14] Cortado applet to play ogg format 

[15] An example of the 2005 year performance benchmarking (http:/ / www. timestretch. com/ FractalBenchmark. html) 

[16] JavaWorld.com (http:/ / www. javaworld. com/ javaworld/ jw-07-2001/ jw-0706-webstart. html) 

[17] JavaChannel.net (http:/ / javachannel. net/ wiki/ pmwiki. php/ FAQ/ Applets)


[18] W3.org (http:/ / www. w3. org/ TR/ html401/ struct/ objects. html#edef-APPLET) 

[19] W3.org (http:/ / www. w3. org/ TR/ html401/ struct/ objects. html#edef-OBJECT) 

[20] Sun's position on applet and object tags (http:/ / download. java. net/ jdk7/ docs/ technotes/ guides/ plugin/ developer_guide/ using_tags. 

html#object) 

[21] Criticism (http:/ / mindprod. com/ jgloss/ applet. html#OBJECT) of APPLET tag deprecation 

[22] Java applet launcher from Oracle (http:/ / www. java. com/ js/ deployJava. txt) 

[23] Java applet section in Wikiversity (http:/ / en. wikiversity. org/ wiki/ Java_applets) 

[24] Java.Sun.com (http:/ / java. sun. com/ j2se/ 1. 4. 2/ docs/ guide/ misc/ applet. html) Sun's APPLET tag page 

[25] Oracle notes on Java versioning (http:/ / java. sun. com/ javase/ 6/ webnotes/ family-clsid. html) 

[26] 1997 year Sun-Microsoft lawsuit in JavaWorld (http:/ / www. javaworld. com/ jw-10-1997/ jw-10-lawsuit. html) 

[27] Sun's page, devoted for the lawsuits against Microsoft (http:/ / www. sun. com/ lawsuit/ summary. html) 

[28] Sun - Microsoft 2002 lawsuit (http:/ / my. advisor. com/ doc/ 13947) 

[29] Microsoft page devoted to the Sun - Microsoft 2002 lawsuit (http:/ / www. microsoft. com/ presspass/ press/ 2004/ apr04/ 

04-02SunAgreementPR. mspx) 

[30] (http:/ / tirania. org/ blog/ archive/ 2010/ Aug-13. html) 

[31] Oracle sues Google over Android (http:/ / mobile. venturebeat. com/ 2010/ 08/ 12/ oracle-sues-google-over-android/ ) 

[32] Discussions on Oracle plans (http:/ / mashable. com/ 2010/ 08/ 12/ oracle-google-android-lawsuit/ ) in mashable.com 

[33] Sun's explanation about applet security (http:/ / java. sun. com/ docs/ books/ tutorial/ deployment/ applet/ security. html) 

[34] Java Security FAQ Applet Security Restrictions (http:/ / www. wutka. com/ hackingjava/ ch3. htm) by Mark Wutka 

[35] Description of Calendar serialization security bug (http:/ / slightlyrandombrokenthoughts. blogspot. com/ 2008/ 12/ calendar-bug. html) 

[36] Java Security FAQ (http:/ / www. cs. princeton. edu/ sip/ faq/ java-faq. php3) 

[37] Avirubin.com (http:/ / avirubin. com/ block. java. pdf) 

[38] Strategy.Wikimedia.org (http:/ / strategy. wikimedia. org/ wiki/ Proposal:Java_applet_support), proposal with discussion about Java applets 

in community sites 

[39] Ultrastudio.org (http:/ / Ultrastudio. org), user editable educational site with full applet support 

[40] ~ G.McGraw, E.W. Felten. Securing Java. ISBN 047131952X (http:/ / www. securingjava. com/ chapter-four/ ) 

[41] Informit.com (http:/ / www. informit. com/ articles/ article. aspx?p=433382& seqNum=2) 

[42] Sid Stamm, Markus Jakobsson, Mona Gandhi (2006). A study in socially transmitted malware (http:/ / www. indiana. edu/ ~phishing/ 

verybigad/ ) 

[43] Rgagnon.com (http:/ / www. rgagnon. com/ javadetails/ java-0170. html), calling a Java applet from JavaScript 

[44] http:/ / www. java. com/ download/ 

[45] http:/ / java. sun. com/ docs/ books/ tutorial/ applet/ index. html 

[46] http:/ / java. sun. com/ applets/ jdk/ 1. 4/ index. html 

[47] http:/ / faq. javaranch. com/ java/ AppletsFaq 

[48] http:/ / www. interactivepulp. com/ pulpcore/


Associació d'Usuaris de Java de Catalunya 

Aujac is the acronym of "Associació d'Usuaris de JAva de Catalunya", non-profit association that intended to 

group all users of the Java language created by James Gosling at Sun MicroSystems. 

Born 

Official logo of Aujac 

Aujac (Associació d'Usuaris de Java de Catalunya) 

born with the initial proposal to bring near the new 

information technologies to the people. An effort made 

through one of the most active Java Users Groups in 

Europe. 

AUJAC starts to forge as an idea during the celebration 

of a Java course and after the initial creation of the JUG 

of Sabadell by Jordi Pujol Ulied, founder and president of the Aujac, in April of year 2000. 

The interest was very high and soon summoned a first meeting for establishing the statutes and the first Board of 

Directors. 

The meetings occurs often and with an important collective effort that it is it could make patent in the several 

encounters that they were made in the current headquarters of the entity, in Sabadell. 

The members founding of AUJAC was: 

Jordi Pujol Ulied (president) 

Xavier Pi i Palomés (underpresident) 

Marc Munill i Bernandich (secretary) 

Josep Folch i Serra (treasurer) 

German Munuera Pubill (vowel) 

Mònica Rayo Moragon (vowel) 

Albert Soler i Crosas (vowel) 

Pere Brugue i Pujol 

At the end of year 2000, was constituted and recognized by the Generalitat de Catalunya, and being inscribed in the 

"Registre General d'Entitats Juridiques" with number of inscription: 23889 / B 

On the other hand the AUJAC was recognized by Sun MicroSystems as official JUG of Catalonia. 

And in year 2003 the AUJAC becomes the most important 16é JUG of the world: Top25 JUG Program. 

Targets 

According to the num article. 2 of its statutes: 

The purposes of the association: 

1. - To group all the users of the Java programming language in Catalonia as well as other aspects that have 

relation with this language. 

2. - The association is in itself an organic representation of the JUG (Java Users Group) in Catalonia, started 

by the company creative of the language, Sun MicroSystems, in the promotion of users associations ( JUGS 

[1] ) indicating that it declares as a non-profit association and therefore there is not commercial connection 

with the company and just sustains bonds of users associationism.


3. - To foster and to promote catalan information society, in all the possible areas. The Catalan was the 

expression and work language of the association. 

President and board of directors 

Along its existence, the Aujac is it composed of several boards of directors. 

The members who compose the Board of Directors, as they marked the statutes, were chosen every two years in the 

General Assembly of Members, and the former members can be presented to the charge without any harm again. 

During the first biennium of existence of the AUJAC (2000-2002) the Board of Directors has been composed by the 

following persons: 

President: Jordi Pujol Ulied 

SotsPresident: Xavier Pi Palomes 

Treasurer: Josep Folch i Serra 

Secretary: Marc Munill Bernándich 

Vowels: 

German Munuera Pubill 

Ignasi Pérez Valls 

Mònica Rayo Morajón 

Albert Soler Crosas 

In the 2002 elections, the Board of Directors for the period 2002-2004 was: 


SotsPresident: Josep Ros Navarro 

Treasurer: Josep Folch i Serra 

Secretary: Mònica Rodríguez Gili 

Vowels: 

Mònica Rayo Moragón 

David Villegas Terrín 

Aleix Torres Casas 

In the periode 2004-2006, the board of directors comes off composed in the following way: 


SotsPresident: Aleix Torres Casas 

Treasurer: Jordi Marques del Aguila 

Secretary: Maiol Xercavins i Simó 

Vowels: 

David Villegas Terrín 

Josep Folch Serra 

Inma Camacho Arellano


Main activities 

The main activities of the Aujac it is they centered in three main axes: formation, broadcast and collaboration 

projects. 

Formation 

In the program of formation it is intended to: 

Facilitate the technology access to all the persons concerned to the Java technologies. Establish a shared plan of 

formation in all the Catalan area, which they are governed by the same criterion of evaluation and formation, with a 

unitary program of courses. 

The plan had a remarkable success, and the Barceloba Football club, "Fundación Once" and the University 

Autonòma of Barcelona (UAB) was one of their customers. 

The plan of formation also allowed the creation of a Java Master Course at the "Fundació Indústries de la 

Informació", entity promoted by Mr. Antoni Farrés ca:Antoni Farrés i Sabater. 

Otherwise, it is also they imparted several courses in the EUIS, Escola Universitària d'Informàtica de Sabadell, 

ascribed to the UAB. 

Diffuse 

With respect to the diffusion of the Java technology, Aujac organized the "Sun Tech Day" in Sabadell 2004, and 

three editions of the "Jornades Java Catalanes", and became the first non-enterprise group to organize an event of 

this kind in Spain, copied afterwards by JavaHispano, which made two editions of a similar event, after having 

attended the first as a viewer. 

As explained in the definition of the "Jornades Java Catalanes" these were: 

The "Jornades Java Catalanes" are an event focused to diffuse the Java technology and other similar 

technologies to the Catalan community. It is an event open to everybody, focused to several sectors of the 

catalan community: university, enterprise, final users and general public. 

The goal of the "Jornades Java Catalanes" is to visit all Catalan universities along the several editions, 

located in Catalonia, Valencia, Balearic Islands and the North Catalonia, through the hand of technological 

companies in this area. 

An annual periodicity is established in the event. 

The language of expression and work of "Jornades Java Catalanes" is, by default, the Catalan. Excluding in 

those activities in which they have to be made, by non-catalan resident of the persons who develop them, in the 

languages of expression of the same ones. 

The area of performance and divulging of the "Java conference C0atalanes" they are all those regions of 

Catalan speech. 

The "Jornades Java Catalanes" base their diffusion area on three predominant areas: enterprise, university 

and society. 

Aujac was pioneer in the Spanish state, the year 2003, in being the first non-profit organization that achieved to 

gather in a same event about Java, the university world, the enterprise sector and the general society, acting as link of 

union among them. 

This joint position of initiative and leadership between Aujac and all the Catalan universities, makes the present 

model have been adopted by other similar entities all over the Spanish state when carrying out similar events 

certifying the success of the same ones.


First "Jornades Java Catalanes" 

Cartell oficial de les 1eres Jornades Java 

Catalanes 

Second "Jornades Java Catalanes" 

The first "Jornades Java Catalanes" was celebrated at the ETSE, "Escola 

Técnica Superior d'Enginyeria" from the "Universitat Autonòma de 

Barcelona", on 25 February 2003. 

The sponsors of this event were: 

Bea Systems 

Sun MicroSystems 

and the collaborator companies : 

Steria 

Cast-Info 

Borland 

We can find press releases in Vilaweb: [2] 

Opening meeting of the III Jornades Java Catalanes. From left to right: Fernando 

Suarez (IBM), Josep Figols (Sun MicroSystems), Jordi Pujol Ulied 

(AUJAC),Monte Kluemper (BEA),Juan Antoni Pastor (UNICA), ? (IBM),Miquel 

Boix Planes (Steria),Alvaro Rocabayera (MSS) 

The second "Jornades Java Catalanes" was 

celebrated at the Universitat Internacional 

de Catalunya, the 15th and 16th of April in 

2004. 


Bea Systems 

Caixa Penedès 

Cast-Info 

Data.ti 

IBM 

Oracle Corporation 

MSS 

Sun MicroSystems


Official logo of the II Jornades Java Catalanes 

Third "Jornades Java Catalanes" 

Quest Software 

They receive support from: 

Official Logo of III Jornades Java Catalanes 

CBA Computers, S.L. 

Filnet 

You can see several press notes on a different sources: 

The participant companies were:: 

da.vinci 

And the collaborator companies were: 

CBA Computers, S.L. 

Filnet 

They receive support from: 

Escola Tècnica Superior d'Enginyeria 

of UAB University 

ATI 

SOFTCATALÀ 

PuntBarra 

Some press notes can be consulted to 

several newspapers like : [3] 

The second "Jornades Java Catalanes" was 

celebrated at the "Sala de Congressos del 

Parc d’Innovació La Salle", located at the 

University Campus of the given university, 

in 14th and 15th of April in 2005. 


Bea Systems 

Borland 

Caixa Penedès 

Data.ti 

Oracle Corporation 

Steria 

Sun MicroSystems 

The participant companies were:: 

Ilog 

MSS


- Press note at COEIC: [4] 

- Press note at LaFarga.cat [5] 

Sun Tech Day in Sabadell 

From left to right:Angela Caicedo(Sun Evangelist),Reginald Hutcherson(Boss of 

the Java Technology Evangelist Team),Jordi Pujol (President of Aujac) 

and a T-shirt, and raffled books and other gifts. 

Almost 100 persons attended the act. 

Belong of the collaboration among the EUIS 

and AUJAC, a Sun Tech Day was organized 

by them. 

Angela Caicedo, Technology Evangelist of 

Sun Microsystems, was the speaker of the 

presentation of the Java2 Standard Edition 

5.0 (Tiger). 

That explained the new features and the 

technical aspects of this last version of the 

Java platform. 

Also it made demonstrations of how to 

develop applications helping for us of the 

new possibilities. 

The session took place on the 20th of 

December 2004 from 17.30 to 20.00 hours. 

The assistants received original CDs of Sun 

During the act, AUJAC gives a commemorative diploma of gratitude to Mr. Reginald Hutcherson (boss of the Java 

Technology Evangelist). 

You can you find references of this event in the web page of the EUIS: [6] 

Collaboration projects 

The Aujac promotes several collaboration projects with entities from all over the territory. Basicament spread on two 

main axes: those activities that offered a series of services to the community, and of another the impulse of the 

technology in educational areas. 

It is necessary to highlight that in the area of the teaching, the Aujac signs with the UAB University, several 

agreements of collaboration among those that highlight the teaching courses as well as the direction of career 

projects under the direction of Jordi Pujol Ulied, president of Aujac. 

It is necessary to highlight that was signed two final university projects: 

• "LABOR": Employment Exchange, by Anna Torres Ribas, that received the qualification of: 10 over 10. 

• "hosting.aujac.org", by Aleix Torres Casas, that received the qualification of: 9.75 over 10, with Honour mark.


Honour members 

Aujac gives every April, the Honour Member to a personality or Catalan entity. 

With this distinction they want to recognize those personalities or entities that with their disposition, implication, 

dedication and effort, have contributed to the growth and development of the technology society in our country. 

2001 Honour Member 

In 2001, Mr. [7] was elected as Honour Member of Aujac. 

Political icon of the democratic movement in the seventies in Sabadell, was the first democratic mayor of the quoted 

population, and one of the big social instigators of the post Franco's regime. 

Instigator on the other hand, of projects of the technology society, like the creation of the "Fundació Indústries de la 

Informació", with headquarters in Sabadell, or instigator of the projects of electronic administrations in Catalonia. 

It is necessary to highlight that the open speech of the Aujac social presentation was offered by him in the 

headquarters of the ancient F2I, "Fundació Indústries de la Informació", in Sabadell, that today is the Chamber of 

Commerce of Sabadell. 


Joan Daví i Ferrer, became Member of Honor Aujac the year 2002. 

Joan Daví i Ferrer, from Terrassa, director of projects in "Caixa Terrassa", led in the bank world an opening towards 

the non-proprietary systems that it led to conceiving unedited bank architectures until then it, and who broke 

outlines, and especially with the traditional systems established in the financial environments. 

Nowadays, its designs in computer architectures devoted to the bank services are a referent. 

For all of this reasons, Aujac considered to distinguish it with the Honour member. 


Dr. Jordi Roig de Zarate receiving the 2003 Honour Member 

Dr. Jordi Roig de Zarate was called "Honour Member" in year 2003. 


Dr. Jordi Roig de Zarate, professor of the IT 

Department of the UAB University. It was 

Director of the EUIS in Sabadell, during 

period 2000-2002. 

Constant fighter towards the own difficulties 

has always known how to win the battle of 

the adversities, demonstrating that many 

times, there are not barriers that can be 

through with effort, dedication and 

constancy. 

Their spirit of improvement, together with 

its professional profile, they act as him a 

person who has known how to transmit its 

pupils the illusion about the new 

technologies. 

Him for this qualities and many others, that


Mr. Eduard Elias (right) receiving the 2004 Honour Member 

The Mr. Eduard Elias (right), dean of the 

"Col.legi Official d'Enginyeria en 

Informàtica de Catalunya", was elected 

"2004 Honour Member". Promoter and 

instigator of the Catalan Association of 

Engineers in Computer Science (ACEI), he 

was some of the craftsmen of the creation of 

the Official School of Engineering in 

Computer Science of Catalonia. 

This Honour Member recognizes years of 

dedication of the technology association and 

the effort to attain a regularization of the 

profession. 

His forces and dedication has allowed the 

creation of the "Col.legi Official 

d'Enginyeria en Informàtica de Catalunya ". 

Arrange of this, Aujac want to give him this honour member, in 16 of April 2004, in the UNICA University. 


Associació per a Joves TEB, receives on 15 April 2005, during the closing ceremony of "III Jornades Java 

Catalanes", the "2005 Honour Member". 

With this distinction it is wants to recognize the effort and dedication carried out, for this entity, that have 

demonstrated its contribution to the growth and development of information society in zones where the youngsters 

live in situations of exclusion, and where the new technologies could not be another barrier. 

It is from this project, and other important project like Xarxa-Òmnia, RavalNet and a long list of projects that they 

have acted how authentic dynamic social agents and of bridges of cohesion there where bags of social exclusion 

could be produced. 

Dissolution 

According to the agreements taken in the last General Assembly of Members, on Tuesday, 24 October 2006 at 20:00 

hours, was approved by over ot the two third parts of the votes, the dissolution of the association. 

The reasons that brought to the dissolution were mainly two, as they were explained at the meeting: 

• The little support on the part of the implied companies, and especially of the matrix company, Sun 

MicroSystems, which finally cut the capital funding of the entity. 

• On the other hand, the problem of the technological voluntarism, in Catalonia, a concept that has just not been 

understood by the society. 

• The people associate the technology with affairs of materialist look, where always to take out a benefit and this 

entails that there are few people willing to collaborate if there is not an economic incentive a lot. 

• And on "collaborating", we understand in an active and constant contribution way. 

• The technological voluntarism must be to grow and to be something more than to participate in the 

development of a software or to participate in the net without going out from home. 

This close a cycle where AUJAC was the most important non-enterprise entity that promotes the diffusion of Java.


References 

[1] http:/ / community. java. net/ jugs/ 

[2] I Jornades Java Catalanes: Press notes in Vilaweb (http:/ / www. vilaweb. cat/ www/ noticia?p_idcmp=652475) 

[3] II Jornades Java Catalanes: Press note at Vilaweb (http:/ / www. vilaweb. cat/ www/ noticia?p_idcmp=838725) 

[4] 'III Jornades Java Catalanes, press note at COEIC' (http:/ / coeic. org/ descarrega/ Butlleti_n. 6_18. 03. 05. 

pdf?iwithSession=89ded563b805d53b6ea96a8c3ed7778a) 

[5] 'III Jornades Java Catalanes, Press note at LaFarga.cat' (http:/ / www. lafarga. org/ agenda/ iii-jornades-java-catalanes) 

[6] Sun Tech Day a l'Escola Universitaria de Sabadell (http:/ / www. uab. es/ servlet/ Satellite/ L-escola/ Miscel-lania/ 

Sun-Tech-Day-1183530620403. html) 

[7] Antoni Farrés i Sabater 

Automated exception handling 

Automated exception handling is a computing term referring to the computerized handling of errors. runtime 

engines such as those for the Java language or Microsoft .Net lend themselves to an automated mode of exception or 

error handling. In these environments software errors do not 'crash' the operating system or the runtime engine but 

rather generate exceptions. Recent advances in these runtime engines enables specialized runtime-engine add-on 

products to provide automated exception handling that is independent of the source code and provides root-cause 

information for every exception of interest. 

How it works 

Upon exception, the runtime engine calls an error interception tool that is attached to the runtime engine (e.g. JVM). 

Based on the nature of the exception such as its type and the class and method in which it occurred and based on user 

preferences, an exception can be either handled or ignored. 

If the preference is to handle the exception, then based on handling preferences such as memory search depth, the 

error interception utility extracts memory values from heap and stack memories. This snapshot then produces the 

equivalent of a debugger screen (as if there had been a debugger) at the precise moment of the exception. 

Advantages 

This mechanism enables the automated handling of software errors independent of the source code of the application 

and independent of its developers. It is a direct artifact of the runtime engine paradigm and it enables unique 

advantages to the software lifecycle that were not available before.


Bean Scripting Framework 


Stable release 2.4.0 / October 6, 2006 

Preview release 3.0 Beta3 / April 5, 2009 



Operating system Cross-platform 

Type Script Engine 


Website http:/ / jakarta. apache. org/ bsf 

The Bean Scripting Framework is a method of allowing the use of scripting in Java code. It provides a set of Java 

classes which provides support within Java applications for scripting languages, and also allows access to Java 

objects and methods. Some examples of languages that can be used in combination with BSF and Java include 

Python, Jython, Tcl, as well as JRuby, and Groovy using their own libraries. 

BSF was created by IBM, and then donated to the Apache Software Foundation, where work on BSF is part of the 

Apache Jakarta Project. 

A counterpart of BSF is the JSR223 ScriptEngine shipped with Java SE 6. Java SE 6 only includes a Script Engine 

based on Rhino JavaScript Engine for Java version 1.6R2, while JSR223 framework actually supports a number of 

scripting languages. JSR223 uses Script Engine to integrate scripts with Java source codes. So far, Script Engines 

included in the JSR223 include BeanShell, Jython, JRuby, JavaScript, Groovy and several others. 

Bibliography 

• Bosanac, Dejan (August 19, 2007), Scripting in Java: Languages, Frameworks, and Patterns [1] (1st ed.), 

Addison-Wesley Professional, pp. 552, ISBN 978-0321321930 

See also 

• JRuby - Java implementation of Ruby interpreter. 

• Jython - Java implementation of Python programming language. 

• BeanShell - Java interpreter for Java source codes 

• JSR223 - JSR223: Scripting for the JavaTM platform



• Apache Jakarta - Bean Scripting Framework [2] 

• IBM - Bean Scripting Framework [3] 

References 

[1] http:/ / www. scriptinginjava. net/ 

[2] http:/ / jakarta. apache. org/ bsf/ 

[3] http:/ / www. alphaworks. ibm. com/ tech/ bsf 

CJAN 

CJAN is an acronym standing for Comprehensive Java Archive Network. CJAN as a concept is an extension of 

CPAN, the Comprehensive Perl Archive Network. In 2004 the CJAN project has ceased development. 

Apache CJAN 

Apache CJAN was an attempt at a simple web service for serving Java Jar files. It was started some time prior to 

May 2001. It was abandoned in favour of the more promising Apache JJAR project. 

Apache JJAR 

Apache JJAR is an experimental distributed repository and toolset to navigate and fetch from the repository. While it 

met its initial goals and found a couple of niche uses, it never went mainstream due to lack of interest from fellow 

developers. Although the project is no longer featured on Apache.org's main pages and is essentially abandoned, this 

experimental project is still hosted on their servers. 

CJAN.org 

Started in November 2001 by Brian Tol [1] , CJAN.org set out to become for the Java community what CPAN 

represented to the Perl community - a comprehensive archive of reusable components for their respective 

programming languages. 

Two key differences between CPAN and CJAN were that Java uses modules known as Jar files and that CJAN was 

to use a distributed network topology (the later would ensure that CJAN would scale well with increased numbers of 

users and keep server hosting costs to an absolute minimum). The decision was taken to code CJAN from scratch in 

Java. 

At the beginning of 2002, Michael Davey started working with Brian on the specifications and a prototype. 

CJAN.org was managed as an Open Source project, a hobby they worked on in their spare time. 

Progress was slow, in part because some of the basic building blocks needed to implement CJAN simply didn't exist 

in open-source form in Java at that time so the developers were spending time creating the components and then 

trying to persuade the appropriate developer community to adopt the component and take over its management. The 

distributed architecture was a problem, too. CJAN was attempting to use the JXTA framework when it was in its 

infancy and only offered very fine-grained, low-level control of the framework. 

Sun Microsystems became interested in CJAN at the beginning of 2003. After some initial discussions with Brian 

and Michael and then the Apache community they sought the opinion of the wider Java community and teamed up 

with Collab.Net and O'Reilly publishing. On 11 June 2003 the Java.net community and website was launched [2] .

CJAN 51 

Ostensibly, CJAN.org failed because it was too ambitious - trying to build an open-source project on leading-edge 

technology. The final straw for the open-source project was the launch of the high-profile Java.Net website. 

Although to this day Java.Net does not offer a catalogue of reusable components, it has a huge community and the 

website features are good enough for most Java developers most of the time that developers rarely cite the need for 

such. 

See also 

• CPAN 

• CRAN 

• CTAN 

• JSAN 

• JXTA 

• Java.Net 


• Apache.org JJAR [3] is a functional webservice and toolset (at time of writing, JJAR is an abandoned 

experimental project) 

• Java.net CJAN wiki page [4] 

• SorceForge.net CJAN project documentation [5] has a number of documents and code, but activity has ceased. 

• Java.Net [6] the closest thing the Java community has to a CJAN repository. 

References 

[1] CJAN Project Summary on SF.Net (http:/ / sourceforge. net/ projects/ cjan) 

[2] Press release: SUN MICROSYSTEMS UNVEILS JAVA.NET (http:/ / www. sun. com/ smi/ Press/ sunflash/ 2003-06/ sunflash. 20030611. 4. 

xml) 

[3] http:/ / jakarta. apache. org/ commons/ sandbox/ jjar/ 

[4] http:/ / wiki. java. net/ bin/ view/ Projects/ CJAN 

[5] http:/ / sourceforge. net/ docman/ ?group_id=41872 

[6] http:/ / java. net/

Celtix 52 

Celtix 

Celtix delivers a Java enterprise service bus (ESB) runtime and set of APIs that make it easy to add transports, 

message formats, and security features. The goal is to simplify the construction, integration and flexible reuse of 

technical and business components using a standards-based, service-oriented architecture. 

Related Technologies 

• ASP.NET 2.0 - Web Services are Basic Profile Compliant compliant [1] 

• GlassFish Metro, the bundle including the JAX-WS Reference Implementation (JAX-WS RI) and the Tango 

(WSIT) project. 

• IBM WebSphere Application Server Version 5.0.2 to 5.1 are BP 1.0 compliant version 6.0+ are BP 1.1 compliant 

[2] 

• Apache Axis 1.2+ is BP 1.0 compliant 

• Apache Axis2 

• WebMethods Glue 

• JBossWS 

• Codehaus XFire 

• Apache CXF, the merger of Codehaus XFire and Celtix 

• DPWS 


• Celtix Homepage [3] at the ObjectWeb 

References 

[1] http:/ / msdn2. microsoft. com/ en-us/ library/ ms230196. aspx 

[2] http:/ / www-128. ibm. com/ developerworks/ webservices/ newto/ ws-websvc. html 

[3] http:/ / celtix. objectweb. org/

Chainsaw (log file viewer) 53 

Chainsaw (log file viewer) 


Stable release 2.0 / March 2, 2006 




Type GUI tool to view and analyze log files 

License Apache 2.0 Licence 

Website [1] 

Chainsaw is a java-based GUI tool to view and analyze log files - specifically logs generated by the Log4j logging 

system. Both Log4j and Chainsaw are Open source projects under Apache Software Foundation. The latest release is 

Chainsaw v2. [2] Chainsaw can read log files formatted in Log4j's XMLLayout [3] , receive events from remote 

locations, read events from a DB, or work with JDK 1.4 logging events. 

License 

The project is licensed under Apache License, V 2.0. Dependencies may not follow the same licensing. [4] 


• Apache Logging Services Chainsaw v2 Home [1] 

• JavaDoc API reference for Chainsaw v2 [5] 

References 

[1] http:/ / logging. apache. org/ chainsaw/ 

[2] "Apache Chainsaw v2 Download'" (http:/ / logging. apache. org/ chainsaw/ ). . Retrieved 2008-01-30. 

[3] http:/ / logging. apache. org/ log4j/ 1. 2/ apidocs/ org/ apache/ log4j/ xml/ XMLLayout. html 

[4] "Apache Chainsaw Project License'" (http:/ / logging. apache. org/ chainsaw/ license. html). . Retrieved 2008-01-30. 

[5] http:/ / logging. apache. org/ chainsaw/ apidocs/


clone (Java method) 

clone() is a method in the Java programming language for object duplication. In Java, objects are manipulated 

through reference variables, and there is no operator for copying an object -- the assignment operator duplicates the 

reference, not the object. The clone() method provides this functionality. 

Overview 

Classes that want copying functionality must implement some method to do so. To a certain extent that function is 

provided by "clone()". 

clone() acts like a constructor. Typically it calls the clone() method of its superclass to obtain the copy, etc. until it 

eventually reaches Object's clone() method. The special clone() method in the base class Object provides a standard 

mechanism for duplicating objects. 

The class Object's clone() method creates and returns a copy of the object, with the same class and with all the fields 

having the same values. However, clone() throws a CloneNotSupportedException unless the class you are trying to 

use it on implements the marker interface Cloneable. 

The default implementation of Object.clone() performs a shallow copy. When a class desires a deep copy or some 

other custom behavior, they must perform that in their own clone() method after they obtain the copy from the 

superclass. 

The syntax for calling clone in Java is: 

Object copy = obj.clone(); 

or commonly 

MyClass copy = (MyClass) obj.clone(); 

which provides the typecasting needed to assign the generic Object reference returned from clone to a reference to a 

MyClass object. 

One disadvantage with the design of the clone() method is that the return type of clone() is Object, and needs to be 

explicitly cast back into the appropriate type. However, overriding clone() to return the appropriate type is preferable 

and eliminates the need for casting in the client (using covariant return types, since J2SE 5.0). 

Another disadvantage is that one often cannot access the clone() method on an abstract type. Most interfaces and 

abstract classes in Java do not specify a public clone() method. As a result, often the only way to use the clone() 

method is if you know the actual class of an object; which is contrary to the abstraction principle of using the most 

generic type possible. For example, if one has a List reference in Java, one cannot invoke clone() on that reference 

because List specifies no public clone() method. Actual implementations of List like ArrayList and LinkedList all 

generally have clone() methods themselves, but it is inconvenient and bad abstraction to carry around the actual class 

type of an object.


Alternatives 

There are alternatives to clone(), notably the use of a copy constructor - a constructor that accepts as a parameter 

another instance of the same class - or a factory method. These methods are not always adequate when the concrete 

type of the cloned object is not known in advance. (However, clone() is often not adequate either for the same 

reason, as most abstract classes do not implement a public clone() method.) 

Also the use of serialization and deserialization is another alternative to using clone. 

clone() and the Singleton pattern 

When writing a class using the Singleton pattern, only one instance of that class can exist at a time. As a result, the 

class must not be allowed to make a clone. To prevent this, override the clone() method using the following code: 

public Object clone() throws CloneNotSupportedException { 

} 

throw new CloneNotSupportedException(); 

(Note: This is only necessary if a superclass implements a public clone() method, or to prevent a subclass from using 

this class's clone() method to obtain a copy. Since classes don't usually inherit a public clone() method (Object 

doesn't have a public clone() method), it is usually unnecessary to explicitly implement a non-functional clone() 

method. 

clone() and class hierarchy 

When working with the clone() in a hierarchy of classes, there are several things that must be handled properly. 

1) Every type reference that needs to call the clone function must have a clone() method in its own class or a publicly 

accessible clone() method in its parent classes. That means that if you want to clone a reference to an abstract base 

class, either the base class must have a clone() method, or one of its parents must have a publicly accessible clone() 

method. 

Example 

- since varY1 is of type Y, then Y must have clone(), or a parent of Y must have clone() 

abstract public class X implements Cloneable { 

} 


} 

return super.clone(); 

abstract public class Y extends X { } 

public class Z extends Y { } 

public class test1 { 

} 

public void function() throws CloneNotSupportedException { 

} 

Y varY1 = new Z(); 

Y varY2 = (Y) varY1.clone();


2) Every class that has any data other than primitives that has to be cloned must contain a clone() function that 

handles it. This includes all objects and all primitives that are allocated with the 'new' command such as variable 

length arrays. (This assumes that the programmer wants the objects to be cloned (deep copy) and not just have their 

reference copied (shallow copy).) 

Example 

- since class Z has a reference to an object of another class, there needs to be specific code to clone that object. 


} 


} 


abstract public class Y extends X { } 

public class ObjectABC implements Cloneable { 

} 


} 

public class Z extends Y { 

} 


private ObjectABC someABC; 


} 


} 

Z newZ = (Z) super.clone(); 

newZ.someABC = (ObjectABC) someABC.clone(); 

return newZ; 


} 

Easy Solution 


Y varY2 = (Y) varY1.clone(); 

The easiest solution to this is to make the base class "implements Cloneable" and have the base class and all 

sub-classes contain the clone() method. When a class has data in it that must be cloned, adding a line or two to the 

clone() method is straight forward. 

Example 



return super.clone();


} 

} 

abstract public class Y extends X { 

} 


} 

public class Z extends Y { 

} 



} 


} 

Downsides 



} 


Y varY2 = (Y) varY1.clone(); 

If every class in your hierarchy has a clone() method, then when the actual class is cloned all of these functions will 

be called, adding some overhead. Over many calls this could be significant. 

With complex object graphs deep copying can become problematic, with recursive references. Once one object is 

cloneable, others tend to follow until the entire graph attempts to implement Cloneable. Sooner or later you run into 

a class that you can't make Cloneable. 

It is not always appropriate to have multiple copies of the same object floating around. Besides, using clone() tends 

to defeat the "single object, multiple references" paradigm. 

clone() and final fields 

Generally, clone() is incompatible with final fields. Because clone() is essentially a default constructor (one that has 

no arguments) it is impossible to assign a final field within a clone() method; a compiler error is the result. Where 

the value of the field is an immutable object this is okay; just let the 'constructor' copy the reference and both the 

original and its clone will share the same object. 

But where the value is a mutable object it must be deep copied. The only solution is to remove the final modifier 

from the field, giving up all the benefits it conferred. 

For this reason, many programmers prefer to make the objects in the hierarchy Serializable, and create copies by 

serializing the old object and then creating a new object from the resulting bitstream, which should be nearly as fast 

as the calls to clone(), uses only one object's worth of extra memory, and that only during the operation, and handles 

final data members correctly.


References 

• McManus, Eamonn (April 4, 2007). "Cloning Java objects using serialization" (http:/ / weblogs. java. net/ blog/ 

emcmanus/ archive/ 2007/ 04/ cloning_java_ob. html). Eamonn McManus's Blog. java.net. Retrieved 2009-07-31. 

• Bloch, Joshua (2008). Effective Java: A Programming Language Guide. The Java Series (2nd ed.). 

Addison-Wesley. ISBN 0321356683. 

• "Avoid clone" (http:/ / www. javapractices. com/ topic/ TopicAction. do?Id=71). Collected Java Practices. 

Hirondelle Systems. 2009. Retrieved 2009-07-31. 

• "Object (Java Platform SE 6)" (http:/ / java. sun. com/ javase/ 6/ docs/ api/ java/ lang/ Object. html#clone()). 

Java Platform Standard Ed. 6. Sun Microsystems, Inc.. 2008. Retrieved 2009-07-31. 

Comparison of Java and C Sharp 

Introduction 

This article compares Microsoft's C# programming language with Sun's (now Oracle's) Java programming language. 

While the focus of this article is mainly the programming languages and their features, such a comparison will 

necessarily also consider some platform features and some library features. A comparison of the platforms are 

beyond the scope of this article, however. 

Neither Java nor C# can be evaluated without taking the respective platforms and libraries into consideration. For a 

platform comparison please see Comparison of the Java and .NET platforms. 

The comparison will naturally focus on the areas where the languages differ. This may skew the fact that the two 

languages and their platforms are actually more alike than they are different: Both are (primarily) statically, strongly 

and explicitly typed, both are class-based object-oriented, both are designed with semi-interpretation or runtime 

compilation in mind, both use garbage-collected memory models and both are considered "curly brace" C/C++ style 

languages. The common ancestry is also evident in the fact that common concepts are often termed the same way 

and more often than not have very similar syntax. 

Language and features 

Feature comparison 

Data types Java C# 

Single-root (unified) type system No Yes 

Signed integers Yes; 8, 16, 32, 64 bits Yes; 8, 16, 32, 64 bits 

Unsigned integers No Yes; 8, 16, 32, 64 bits 

Character Yes Yes 

Date/time Yes; reference type Yes; value type 

IEEE 754 binary32 floating point number Yes Yes 

IEEE 754 binary64 floating point number Yes Yes 

High precision floating point number No; but see Arbitrary size decimals 128-bit (28 digits) Decimal type 

Boolean type Yes Yes 

Strings Immutable reference type, Unicode Immutable reference type, Unicode 

Arbitrary size integers Reference type; no operators Yes


Arbitrary size decimals Reference type; no operators No 

Complex numbers No Yes 

Reference types Yes Yes 

Arrays Yes Yes 

Value types No; only primitive types Yes 

Enumerated types Yes; reference type Yes; scalar 

Lifted (nullable) types No; but wrapper types Yes 

Tuples No Yes 

Pointers No Yes 

Reference types Java C# 

Garbage collection Yes Yes 

Weak references Yes Yes 

Soft references Yes No 

Proxy support Yes; proxy generation Yes; object contexts 

Object initialization Bottom-up (fields and constructors) Top-down (fields); bottom-up (constructors) 

Object orientation Java C# 

Classes Yes Yes 

Interfaces Yes Yes 

Abstract classes Yes Yes 

Member accessibility levels 

Public, package, private, protected 

Public, protected, internal, protected internal, 

Class level inner classes Yes Yes 

Instance level inner classes Yes No 

Partial classes No Yes 

Deprecation/obsolescence Yes Yes 

Overload versioning Some Yes 

Properties No Yes 

Events No Yes 

Operators (operator overloading) No Yes 

Indexers No Yes 

Implicit conversions No Yes 

Explicit conversions No Yes 

Fields and initialization Java C# 

Fields Yes Yes 

Constants Yes Yes 

Static (class) constructors Yes Yes 

Instance constructors Yes Yes 

Finalizers/destructors Yes Yes 

Instance initializers Yes No 

Hierarchy initialization Top-bottom, lexical order Top-bottom-top, lexical order 

private


Object initializers No Yes 

Collection initializers No; can be modelled Yes 

Array initializers Yes Yes 

Methods and properties Java C# 

Virtual Virtual by default Non-virtual by default 

Abstract Yes Yes 

Sealing Yes Yes 

Explicit interface implementation No Yes 

Value (input) parameters Yes Yes 

Reference (input/output) parameters No Yes 

Output (output) parameters No Yes 

Variadic methods Yes Yes 

Optional arguments No Yes 

Named arguments No Yes 

Generator methods No Yes 

Extension methods No Yes 

Conditional methods No Yes 

Partial methods No Yes 

Generics Java C# 

Reified generics No Yes 

Co-variance Yes Yes 

Contra-variance Yes Yes 

Reference type constraint Yes; implicit Yes 

Value/primitive type constraint No Yes 

Constructor constraint No Yes 

Relation constraint Yes Yes 

Primitive/value type support No Yes 

Migration compatibility Yes No 

Functional programming Java C# 

Delegates/method references No Yes 

Closures/lambdas No; some use cases covered by anonymous inner 

classes 

Expression trees No Yes 

Query expressions No Yes 

Runtime (dynamic) binding Java C# 

Late-bound (dynamic) type No Yes 

Runtime type information and 

manipulation 

Yes 

Java C# 

Runtime type information Yes; but with type erasure Yes 

Runtime generics realization No Yes


Runtime type construction No; third party tools exist Yes 

Statements Java C# 

Loops Yes Yes 

Conditionals Yes Yes 

Flow control Yes Yes 

Assignment Yes Yes 

Exception control Yes Yes 

Variable declaration Yes Yes 

Variable type inference No Yes 

Deterministic disposal (ARM-blocks) No Yes 

Expressions and operators Java C# 

Arithmetic operators Yes Yes 

Logical operators Yes Yes 

Bitwise logic operators Yes Yes 

Conditional Yes Yes 

String concatenation Yes Yes 

Casts Yes Yes 

Boxing Yes; implicit Yes; implicit 

Unboxing Yes; implicit Yes; explicit 

Lifted operators No Yes 

Overflow control No Yes 

Strict floating point evaluation Yes; opt-in/out No 

Local classes Yes No 

Ad-hoc (anonymous) classes No Yes 

Verbatim (here-)strings No Yes 

Exceptions Java C# 

Checked exceptions Yes No 

Try-catch-finally Yes Yes 

Arrays and collections Java C# 

One-dimensional, zero-based index arrays Yes Yes 

Rectangular (multidimensional) arrays No Yes 

Jagged (arrays of arrays) arrays Yes Yes 

Non-zero based arrays No Some 

Unified arrays and collections No Yes 

Maps/dictionaries Yes Yes 

Sets Yes Yes 

Lists/vectors Yes Yes 

Maps Yes Yes 

Queues/stacks Yes Yes


Bags/multisets Yes Yes 

Metadata Java C# 

Metadata annotations/attributes Interface based Class based 

Positional arguments No; unless a single argument Yes 

Named arguments Yes Yes 

Default values At definition Through initialization 

Nested types Yes Yes 

Specialization No Yes 

Conditional metadata No Yes 

Preprocessing, compilation and 

packaging 

Java C# 

Namespaces Packages Namespaces 

Packaging Package Assembly 

File contents Restricted Free 

Conditional compilation No Yes 

Custom errors/warnings No Yes 

Explicit regions No Yes 

Threading and synchronization Java C# 

Native interoperability Java C# 

External/native methods Yes Yes 

Marshalling External glue code required Yes; metadata controlled 

Pointers and arithmetics No Yes 

Native types No Yes 

Fixed size buffers No Yes 

Explicit stack allocation No Yes 

Address pinning (fixing) No Yes 

Address-of No Yes 

Object pinning (fix variable to address) No Yes 

Data types 

Unified type system 

In Java the primitive types are special in that they are not object-oriented and they could not have been defined using 

the language itself. The Java reference types all derive from a common root type, however. C# has a unified type 

system in which all types ultimately derive from a common root type. Consequently, all types implement the 

methods of this root type, and extension methods defined for the object type apply to all types, even primitive int 

literals and delegates. Note, that unlike Java, C# this way supports objects with encapsulation which are not 

reference types. 

In Java compound types are synonymous with reference types; you can not define methods for a type unless it is also 

a class reference type. In C# the concepts of encapsulation and methods have been decoupled from the reference 

requirement so that a type can support methods and encapsulation without being a reference type. Only reference 

types support virtual methods and specialization, however.


The primitive types of Java are special and could not have been defined using the language itself. They also do not 

share a common ancestor with reference types. 

Simple/primitive types 

Both languages support a number built-in types which are copied and passed by value rather than by reference. Java 

calls these types primitive types, while they are called simple types in C#. The simple/primitive types typically have 

native support from the underlying processor architecture. 

C# has a few more primitive types than Java, due to the fact that it supports unsigned as well as signed integer types, 

and a decimal type for decimal floating-point calculations. 

Java lacks the unsigned types. In particular, Java lacks a primitive type for an unsigned byte. The Java byte type is 

signed, while the C# byte is unsigned and sbyte is signed. 

Both languages feature a native char (character) datatype as a simple type. Although the Java char type can used 

with bitwise operators, this is actually accomplished by promoting the char to an integer before the operation. 

C# has a type for high-precision (28 decimal digits) decimal arithmetic (based on the IEEE 754 Decimal128 format) 

for e.g. financial and monetary application. While Java lacks such a built-in type, the Java library does feature an 

arbitrary precision decimal type. This is not considered a language type and it does not support the usual arithmetic 

operators; rather it is a reference type which must be manipulated using the type methods. See more on arbitrary 

size/precision numbers below. 

The C# primitive/simple types implement a number of interfaces and consequently offer a number of methods 

directly on instances of the types - even on the literals. The C# type names are also merely aliases for Common 

Language Runtime types. The C# Long type is exactly the same type as the long type; the only difference is that the 

former is the canonical .NET name while the latter is in C# alias for it. 

Java does not offer methods directly on the primitive types. Instead methods which operate on the primitive values 

are offered through companion wrapper classes. A fixed set of such wrapper classes exist each of which wraps on of 

the fixed set of primitive types. As an example, the Java Long type is a reference type which wraps the primitive 

long type. They are not the same type, however. 

The following table summarizes the corresponding simple/primitive types of the languages: 

C# alias .NET CLR type Width (bits) Range (apx.) Java type Java wrapper 

sbyte SByte 8 -128 to 127 byte Byte 

byte Byte 

8 0 to 255 Not 

available 

Not available 

short Int16 16 -32768 to 32767 short Short 

ushort UInt16 

16 0 to 65535 Not 

available 

Not available 

int Int32 32 -2,147,483,648 to 2,147,483,647 int Integer 

uint UInt32 

long Int64 

ulong UInt64 

32 0 to 4,294,967,295 Not 

64 -9,223,372,036,854,775,808 to 

9,223,372,036,854,775,807 

available 

64 0 to 18,446,744,073,709,551,615 Not 

Not available 

long Long 

available 

Not available 

float Single 32 -3.402823e38 to 3.402823e38 float Float 

double Double 64 -1.79769313486232e308 to 1.79769313486232e308 double Double


decimal Decimal 

128 ±1.0 × 10e−28 to ±7.9 × 10e28 Not 

available 

Not available 

char Char 16 \u0000 to \uFFFF char Character 

bool Boolean 8 true, false boolean Boolean 

Advanced numeric types 

Both languages offer library-defined arbitrary size integer types. 

Only Java offers a data type for arbitrary precision decimal point calculations and only C# offers a type for working 

with complex numbers. 

In both languages the number of operations which can be performed are limited compared to the built-in IEEE 754 

floating point types. For instance, none of the types support square root or logarithms. 

By leveraging the C# support for type integration through custom operator overloading and custom (implicit and 

explicit) type conversions, C# achieves better parity with the built-in types. 

Java C# 

ze="6.85"> 

er bigNumber = 

igInteger("123456789012345678901234567890"); 

 

BigInteger bigNumber = 

BigInteger.Parse("1234567890123456789012345 

er answer = bigNumber.multiply(new BigInteger("42")); var answer = bigNumber * 42; 

er square = bigNumber.multiply(bigNumber); 

var square = bigNumber * bigNumber; 

er sum = bigNumber.add(bigNumber); 

var sum = bigNumber + bigNumber; 

 

Built-in compound data types 

Both languages treat strings as (immutable) objects of reference type. In both languages the type contains a number 

of methods to manipulate strings, parse, format etc. In both languages regular expressions are considered an external 

feature and is implemented in separate classes. 

Both languages' libraries define classes for working with dates and calendars in different cultures. The Java 

java.util.Date is a mutable reference type where the C# System.DateTime is a struct value type. C# additionally 

define a TimeSpan type for working with time periods. Both languages support date/time arithmetic according to 

different cultures. 

Reference types 

Both languages use classes and interfaces as the primary means for defining new, object-oriented types. See below 

for further details. 

Value types 

C# allows the programmer to create user-defined value types, using the struct keyword. Unlike classes, and like the 

standard primitives, such value types are passed and assigned by value rather than by reference. They can also be 

part of an object (either as a field or boxed), or stored in an array, without the memory indirection that normally 

exists for class types. 

Because value types have no notion of a null value and can be used in arrays without initialization, they always come 

with an implicit default constructor that essentially fills the struct memory space with zeroes. The programmer can 

only define additional constructors with one or more arguments. Value types do not have virtual method tables, and 

because of that (and the fixed memory footprint), they are implicitly sealed. However, value types can (and


frequently do) implement interfaces. For example, the built-in integer types implement a number of interfaces. 

Apart from the built-in primitive types, Java does not include the concept of value types. 

Enumerations 

Enumerations in C# are derived from a primitive integer type (8, 16, 32, or 64 bit). Any value of the underlying 

primitive type is a valid value of the enumeration type, though an explicit cast may be needed to assign it. C# also 

supports bit-mapped enumerations where an actual value may be a combination of enumerated values bitwise or'ed 

together. 

Enumerations in Java, are full objects. The only valid values are the ones listed in the enumeration. Also, as objects, 

each enumeration can contain its own methods and fields, like a dedicated toString() method, for instance, or 

comparators. They can be considerered classes with a predefined amount of instances, which are the enum constants. 

Special enumeration set and map collections provide fully type-safe functionality with minimal overhead. 

In both C# and Java programmers can use them in a switch statement without conversion to a string or primitive 

integer type. 

Delegates / method references 

C# implements object oriented method pointers in the form of delegates. A delegate is a special type which can 

capture a type-safe reference to a method. This reference can then be stored in a delegate-type variable or passed to a 

method through a delegate parameter for later invocation. C# delegates support covariance and contravariance, and 

can hold a reference to any signature-compatible static method, instance method or anonymous method or lambda 

expression. 

Delegates should not be confused with closures and inline functions. The concepts are related because a reference to 

a closure/inline function must be captured in a delegate reference to be useful at all. But a delegate does not always 

reference an inline function, it can also reference existing static or instance methods. Delegates form the basis of C# 

events but should not be confused with those either. 

Java does not have a language-level construct like the C# delegate. To mimic the functionality the developer will 

have to create an ad-hoc implementation of a class (typically an anonymous inner class) where one method performs 

the desired invocation. The following code snippets show how to mimic most of the delegate functionality in Java. 

Java C#


size="7.15"> 

define a delegate 

terface SomeDelegate { 

boolean Invoke(String arg); 

a target class 

ass Target { 

public boolean TargetMethod(String arg) { 

// do something 

return true; 

} 

usage 

id DoSomething() { 

> 

// construct a target with the target method 

final Target target = new Target(); 

// capture the delegate for later invocation 

SomeDelegate dlg = new SomeDelegate() { 

public boolean Invoke(String arg) { 

return target.TargetMethod(arg); 

} 

}; 

// invoke the delegate 

boolean result = dlg.Invoke("argumentstring"); 

Lifted (nullable) types 

 

// define a delegate 

private delegate bool SomeDelegate(string resou 

} 

 

// a target class 

class Target { 

public bool TargetMethod(string arg) { 

// do something 

return true; 

} 

} 

// usage 

void DoSomething() { 

// construct a target with the target metho 

var target = new Target(); 

// capture the delegate for later invocatio 

SomeDelegate dlg = target.TargetMethod; 

// invoke the delegate 

bool result = dlg("argumentstring"); 

C# allows value/primitive/simple types to be "lifted" to allow the special null value in addition to the type's native 

values. A type is lifted by adding a ? suffix to the type name. Conversions are implicitly defined to convert between 

values of the base and the lifted type. The lifted type can be compared against null or it can be tested for HasValue. 

Also, lifted operators are implicitly and automatically defined based on their non-lifted base, where - with the 

exception of some boolean operators - a null argument will propagate to the result. 

Java does not support type lifting as a concept, but the fixed set of built-in primitive types all have corresponding 

(boxed) wrapper types which do support the null value by virtue of being reference types. However, Java operators 

such as + are not defined for these companion wrapper types. Instead Java will fall back to the primitive operator and 

will attempt to unbox the operands before invocation. If one or both of the operands are null, this unboxing will 

cause a NullPointerException to be thrown. 

The following example illustrates how the lifted C# operator propagates the null value of the operand where the 

corresponding code in Java will throw an exception. 

Java C#

e="6.73"> 

= 42; 

= null; 


 

int? a = 42; 

int? b = null; 

ill generate a runtime NullPointerException 

// c will receive the null value 

e the * operator will attempt to unbox the null value // because * is lifted and one of the operands 

= a * b; 

int? c = a * b; 

 

Not all C# lifted operators have been defined to propagate null unconditionally if one of the operands is null. 

Specifically, the boolean operators have been lifted to support ternary logic thus keeping impedance with SQL. 

Late-bound (dynamic) type 

C# features a late bound dynamic type which supports no-reflection dynamic invocation, interoperability with 

dynamic languages as well as ad-hoc binding to (for example) document object models. The dynamic type resolves 

member access dynamically at runtime as opposed to statically/virtual a compile time. The member lookup 

mechanism is extensible with traditional reflection as a fall-back mechanism. 

There are several use cases for the dynamic type in C#: 

• Less verbose use of reflection: By casting an instance to the dynamic type, members such as properties, methods, 

events etc. can be directly invoked on the instance without using the reflection API directly. 

• Interoperability with dynamic languages: The dynamic type comes with a hub-and-spoke support for 

implementing dynamically typed objects and common runtime infrastructure for efficient member lookup. 

• Creating dynamic abstractions on the fly: For instance, a dynamic object could provide simpler access to 

document object models such as XML- or XHTML documents. 

Java does not support a late-bound type. The use cases for C# dynamic type have different corresponding constructs 

in Java: 

• For dynamic late-bound by-name invocation of preexisting types, reflection should be used. 

• For interoperability with dynamic languages, some form of interoperability API specific to that language will 

have to be used. The Java Virtual Machine platform does have multiple dynamic languages implemented on top if 

it, but there is no common standard for how to pass objects between languages. Usually this will involve some 

form of reflection or reflection-like API. As an example of how to use JavaFX objects from Java, see How to Use 

JavaFX in Your Swing Application [1] . 

• For creating and interacting with objects entirely at runtime, e.g. interaction with a document object model 

abstraction, a specific abstraction API will have to be used. 

Pointers 

C# allows use of pointers and corresponding pointer arithmetic. Pointers and pointer-arithmetic are potentially 

unsafe in a managed environment as they can be used to bypass the strict rules for object access. C# addresses that 

concern by requiring that code blocks or methods that use the feature be marked with the unsafe keyword, so that all 

clients of such code can be aware that the code may be less secure than otherwise. The compiler requires the /unsafe 

switch to allow compilation of a program that uses such code, and assemblies containing unsafe code may only 

execute if explicitly granted security permissions. Generally, unsafe code is either used to allow better 

interoperability with unmanaged APIs or system calls (which are inherently "unsafe"), or for performance reasons. 

Java does not permit pointers or pointer-arithmetic within the Java runtime environment and native interop is 

handled externally through JNI or other mechanisms.


Object handling 

Both C# and Java are designed from the ground up as object oriented languages using dynamic dispatch, with syntax 

similar to C++ (C++ in turn derives from C). Neither language is a superset of C or C++, however. Both mainly use 

garbage collection as a means of reclaiming memory resources, rather than explicit deallocation of memory (though 

C# requires explicit deallocation for graphical, GDI+ objects, in which case it uses the IDisposable interface). Both 

include thread synchronization mechanisms as part of their language syntax. 

In both languages objects are created with a new. 

References 

In both languages references are a central concept. All instances of classes are by reference. 

While not directly evident in the language syntax per se, both languages support the concept of weak references. An 

instance which is only referenced by weak references is eligible for garbage collection just as if there were no 

references at all. In both languages this feature is exposed through the associated libraries, even though it is really a 

core runtime feature. 

In addition to weak references, Java has soft references. Soft references are much like weak references, but the JVM 

will not deallocate softly-referenced objects until the memory is actually needed. 

Object initialization 

In both C# and Java, an object's fields can be initialized either by variable initializers (expressions that can be 

assigned to variables where they are defined) or by constructors (special subroutines that are executed when an 

object is being created). In addition, Java contains instance initializers, which are anonymous blocks of code with no 

arguments that are run before the constructor is executed. 

C# initializes object fields in the following order when creating an object: 

1. Derived static fields 

2. Derived static constructor 

3. Derived instance fields 

4. Base static fields 

5. Base static constructor 

6. Base instance fields 

7. Base instance constructor 

8. Derived instance constructor 

Some of the above fields may not be applicable (e.g. if an object does not have static fields). Derived fields are those 

that are defined in the object's direct class while base fields is a term for the fields that are defined in one of the 

object's superclasses. Note that an object representation in memory contains all fields defined in its class or any of its 

superclasses, even if some fields in superclasses are defined as private. 

It is guaranteed that any field initializers take effect before any constructors are called, since both instance 

constructor of the object's class and its super classes are called after field initializers are called. There is, however, a 

potential trap in object initialization when a virtual method is called from a base constructor. The overridden method 

in a subclass may reference a field that is defined in the subclass, but this field may not been initialized because the 

cubclass' constructor that contains field initialization is called after the constructor of its base class. 

In Java, the order of initialization is as follows: 

1. Invocation of another constructor (either of the object's class or of object's superclass) 

2. Instance variable initializers and instance initializers (in the order they appear listed in source code) 

3. The constructor body


Like in C#, a new object is created by calling a specific constructor. Within a constructor, the first statement may be 

invocation of another constructor. If this is omitted, the call to the super class' argument-less constructor is added 

implicitly by the compiler. Otherwise, either another overloaded constructor of the object's class can be called 

explicitly, or a superclass' constructor can be called. In the former case, the called constructor will again call another 

constructor (either of the object's class or its cubclass) and the chain sooner or later ends up at the call to one of the 

superclass' constructor. 

After another constructor is called (which causes direct invocation superclass' constructor, and so forth, down to the 

Object class), instance variables defined in the object's class are initialized. Even if there are no variable initializers 

explicitly defined for some variables, these variables are initialized to default values. Note that instance variables 

defined in superclasses are already initialized by this point, because they were initialized by superclass' constructor 

when it was called (either by constructor's code or by variables' initializers performed before constructor's code or 

implicitly to default values). In Java, variable initializers are executed according to their textual order in the source 

file. 

Finally, the constructor body is executed. This ensures proper order of initialization, i.e. the fields of a base class 

finish initialization before initialization of the fields of an object class begins. 

There are two main potential traps in Java's object initialization. First, variable initializers are expressions that can 

contain method calls. Since methods can reference any variable defined in the class, the method called in variable's 

initializer can reference a variable that is defined below the variable being initialized. Since initialization order 

corresponds to textual order of variable definitions, such a variable would not be initialized to the value prescribed 

by its initializer and would contain the default value. Another potential trap is when a method that is overridden in 

the derived class is called in the base class' constructor, which can lead to behavior the programmer would not expect 

when object of the derived class is created. According to initialization order, the body of the base class' constructor is 

executed before variable initializers are evaluated and before the body of the derived class' constructor is executed. 

The overridden method called form the base class' constructor can however reference variables defined in the 

derived class, but these are not yet initialized to the values specified by their initializers or set in derived class' 

constructor. 

Arrays and collections 

Arrays and collections concepts featured by both languages. The syntax used to declare and access arrays is 

identical, except that C# has added syntax for declaring and manipulating multidimensional arrays. 

Java C# 

Arrays are implicitly direct specializations of Object. They are 

not unified with collection types. 

Instead of a common iterable/enumerable interface, the for 

loop accepts either arrays or Iterable (a collection interface). 

This means that the same short syntax can be used in for-loops. 

Arrays and collections are completely separate with no 

unification. Arrays cannot be passed where sequences or 

collections are expected 

Arrays in C# are implicitly specializations the System.Array class which 

implement a number of collection interfaces. 

The foreach statement iterates through a sequence using the IEnumerable 

orIEnumerable interface. Because arrays always implicitly implement these 

interfaces, the loop will iterate through arrays as well. 

Arrays can be passed where sequences (IEnumerables) or collections/list interfaces 

are expected. However, the collection operations which alter the number of 

elements (insert/add/remove) will throw exceptions as these operations are not 

supported by arrays. 

In both languages arrays are covariant. This means that a String[] array is assignable to variables of Object[] because String is a specialization of 

(assignable to) Object. In both languages the arrays will perform a type check when inserting new values because type-safety would otherwise be 

compromised. This is in contrast to how generic collections have been implemented in both languages. 

Multidimensional arrays only in the form of arrays of arrays 

(also known as "jagged" arrays); Java does not have true 

rectangular multidimensional arrays. 

True multidimensional "rectangular" arrays, as well as the arrays-of-arrays (jagged 

arrays).


Multidimensional arrays can in some cases increase performance because of increased locality (as there is a single 

pointer dereference, instead of one for every dimension of the array as is the case for jagged arrays). However, since 

all array element access in a multidimensional array require multiplication/shift between the two or more 

dimensions, this is an advantage only in very random access scenarios. 

Another potential advantage is that the entire multidimensional array can be allocated with a single application of 

operator new, while jagged arrays require loops and allocations for every dimension. Note, though, that Java 

provides a syntactic construct for allocating a multidimensional jagged array with regular lengths; the loops and 

multiple allocations are then performed by the virtual machine and need not be explicit at the source level. 

Both languages feature an extensive set of collection types which includes various ordered and unordered types of 

lists, maps/dictionaries, sets etc. 

Type members 

Operator overloading and implicit and explicit conversions 

Operator overloading and user-defined casts are separate features which both aim to allow new types to become 

first-class citizens in the type system. By leveraging these features, types such as Complex and decimal has been 

integrated so that the usual operators like addition, multiplication work with the new types. 

Java does not include operator overloading nor custom conversions in order to prevent abuse of the feature, and to 

keep the language simple. [2] . 

Indexers 

C# also includes indexers which can be considered a special case of operator overloading (like C++ operator[]), or 

parametrized get/set properties. An indexer is a property named this[] which uses one or more parameters (indexes); 

the indices can be objects of any type: 

myList[4] = 5; 

string name = xmlNode.Attributes["name"]; 

orders = customerMap[theCustomer]; 

Java does not include indexers. The common Java pattern involves writing explicit get_ and set_ methods where a 

C# programmer would use an indexer. 

Partial classes 

C# allows a class definition to be split across several source files using a feature called partial classes. Each part 

must be marked with the keyword partial. All the parts must be presented to the compiler as part of a single 

compilation. Parts can reference members from other parts. Parts can implement interfaces and one part can define a 

base class. The feature is useful in code generation scenarios (such as UI design) where a code generator can supply 

one part and the developer another part to be compiled together. The developer can thus edit their part without the 

risk of a code generator overwriting that code at some later time. Unlike the class extension mechanism a partial 

class allows "circular" dependencies amongst its parts as they are guaranteed to be resolved at compile time. Java has 

no corresponding concept.


Inner- and local classes 

Both languages allow inner classes, where a class is defined lexically inside another class. However, in each 

language these inner classes have rather different semantics. 

In Java, unless the inner class is declared static, a reference to an instance of an inner class carries a reference to the 

outer class with it. As a result, code in the inner class has access to both the static and non-static members of the 

outer class. To create an instance of a non-static inner class, one has to name the instance of the embracing outer 

class [3] . This is done via a new new-operator introduced in JDK 1.3: outerClassInstance.new Outer.InnerClass(). 

This can be done in any class that has a reference to an instance of the outer class. 

In C#, an inner class is conceptually the same as a normal class. In a sense, the outer class only acts as a namespace. 

Thus, code in the inner class cannot access non-static members of the outer class unless it does so through an explicit 

reference to an instance of the outer class. Programmers can declare the inner class private to allow only the outer 

class to have any access to it. 

Java provides another feature called local classes or anonymous classes, which can be defined within a method body. 

These are generally used to implement an interface with only one or two methods, which are typically event 

handlers. They can also be used to override virtual methods of a super-class however. The methods in those local 

classes have access to the outer method's local variables declared final. C# satisfies the use-cases for these by 

providing anonymous delegates; see event handling for more about this. 

C# also provides a feature called anonymous classes, but it is rather different from Java's concept with the same 

name. It allows the programmer to instantiate a class by providing only a set of names for the properties the class 

should have, and an expression to initialize each. The types of the properties are inferred from the types of those 

expressions. These implicitly-declared classes are derived directly from object. 

Explicit member implementation 

C# also has "Explicit Member Implementation" which allows a class to specifically implement methods of an 

interface, separate to its own class methods, or to provide different implementations for two methods with the same 

name and signature inherited from two base interfaces. 

Events 

C# multicast-delegates are called events. Events provide support for event-driven programming and is an 

implementation of the observer pattern. To support this there is a special syntax to define events in classes, and 

operators to register, unregister or combine event handlers. 

Java does not offer events as a language construct. Java developers instead manually implement the observer [4] . 

Anonymous inner classes are commonly used to implement the listener, allowing you to define the body of the class 

and create an instance of it in a single point in the code. 

Statements and expressions 

Boxing and unboxing 

Both languages allow automatic boxing and unboxing to translate primitive data to and from their object form. 

Effectively, this makes the primitive types a subtype of the Object type. In C# this also means that primitive types 

can define methods, such as an override of Object's ToString() method. In Java, separate primitive wrapper classes 

provide such functionality. Java does not implicitly box primitive values when dereferenced and an explicit cast is 

required for an instance call on a primitive value — ((Integer)42).toString() instead of a C# instance call 

42.ToString(). Another difference is that Java makes heavy use of boxed types in generics (see below), and as such 

allows an implicit unboxing conversion (in C# this requires a cast). As these implicit unboxing conversions can 

potentially throw null pointer exceptions, modern integrated development environments and compilers can be


configured to highlight them. 

Generics 

In the field of generics the two languages show a superficial syntactical similarity, but they have deep underlying 

differences. 

Type erasure versus reified generics 

Generics in Java are a language-only construction; they are implemented only in the compiler. The generated 

classfiles include generic signatures only in the form of metadata (allowing the compiler to compile new classes 

against them). The runtime has no knowledge of the generic type system; generics are not part of the JVM. Instead, 

generics classes and methods are transformed during compilation through a process known as type erasure. During 

this process the compiler replaces all generic types with their raw version and inserts casts/checks appropriately in 

client code where the type and its methods are used. The resulting byte code will contain no references to any 

generic types or parameters (See also Generics in Java). 

C# builds on support for generics from the virtual execution system itself, i.e. it is not just a language feature. The 

language is merely a front-end for cross-language generics support in the CLR. During compilation generics are 

verified for correctness, but code generation for actually implementing the generics are deferred to class-load time. 

Client code (code invoking generic methods/properties) are fully compiled and can safely assume generics to be 

type-safe. This is called reification. Unlike with the Java generics, there is no need to inject down-casts or 

type-checks in clients code. At runtime, when a unique set of type parameters for a generic class/method/delegate is 

encountered for the first time, the class loader/verifier will synthesize a concrete class descriptor and generate 

method implementations. During the generation of method implementations all reference types will be considered a 

single type, as reference types can safely share the same implementations. Note, this is merely for the purpose of the 

implementing code. Different sets of reference types will still have unique type descriptors; their method tables will 

merely point to the same code. 

The Java design imposes restrictions on the developer compared to the C# design. The following list is not 

exhaustive (see also Java Generics FAQs - Frequently Asked Questions [5] by Angelika Langer): 

Java C# 

checks and downcasts are injected into client code (the code referencing the 

cs). Compared to non-generic code with manual casts, these casts will be the 

6] . But compared to compile-time verified code which would not need runtime 

nd checks, these operations represent a performance overhead. 

ot use primitive types as type parameters; instead the developer must use the 

er type corresponding to the primitive type. This incurs extra performance overhead 

uiring boxing and unboxing conversions as well a memory and garbage collection 

re because the wrappers will be heap allocated as opposed to stack allocated. 

ic exceptions are not allowed [7] and the can not use a type parameter in a catch 

[8] 

members are shared across all generic realizations [9] (during type erasure all 

tions are folded into a single class) 

parameters cannot be used in declarations of static fields/methods or in definitions 

ic inner classes 

t "import" a particular realization of a generic class 

nt size="7.49"> 

ort java.util.List // illegal 

ont> 

C#/.NET generics guarantees type-safety and is verified at compile time and no extra checks/casts are necessary 

runtime. Hence, generic code will run faster than non-generic code (and type-erased code) which require casts w 

handling non-generic or type-erased objects. 

Primitive and value types are allowed as type parameters in generic realizations. At runtime code will be 

synthesized and compiled for each unique combination of type parameters upon first use. Generics which are 

realized with primitive/value type do not require boxing/unboxing conversions. 

Can both define generic exceptions and use those in catch clauses 

Static members are separate for each generic realization. A generic realization is a unique class. 

No restrictions on use of type parameters 

Can "import" (using directive) a specific realization with an alias 

 

using StringList = System.Collections.Generic.List


t create an array where the component type is a generic realization (concrete 

eterized type) 

nt size="7.49"> 

ect tenPairs = 

new Pair[10]; // error 

ont> 

t create an array where the component type is a type parameter 

nt size="7.49"> 

lic class Lookup { 

public TValue[] GetEmptyValues(TKey key) { 

return new TValue[0]; // error 

} 

ont> 

A generic realization is a 1st class citizen and can be used as any other class; also an array component 

 

object tenPairs = 

new Pair[10]; // ok 

 

Type parameters represent actual, discrete classes and can be used like any other type within the generic definiti 

 

is no class literal for a concrete realization of a generic type A generic realization is an actual class. 

public class Lookup { 

public TValue[] GetEmptyValues(TKey key) { 

return new TValue[0]; // ok 

} 

} 

 

ceof is not allowed with type parameters or concrete generic realizations The is and as operators work the same for type parameters as for any other type. 

ot create new instances using a type parameter as the type With a constructor constraint, generic methods or methods of generic classes can create instances of classes wh 

information is erased during compilation. Special extensions to reflection must be 

o discover the original type. 

tion cannot be used to construct new generic realizations. During compilation extra 

typecasts) are injected into the client code of generics. This precludes creating new 

tions later. 

have default constructors. 

Type information about C# generic types is fully preserved at runtime, and allows complete reflection support a 

well as instantiation of generic types. 

Reflection can be used to create new realizations for new combinations of type parameters. 

C# allows generics directly for primitive types. Java, instead, allows the use of boxed types as type parameters (e.g., 

List instead of List), but this comes at a small cost since all such values need to be heap-allocated 

(however, a generic type can be specialized with an array type of a primitive type in Java, for example List is 

allowed). [10] 

Migration compatibility 

Java's type erasure design was motivated by a design requirement to achieve migration compatibility - not to be 

confused with backward compatibility. In particular the original requirements was "... there should be a clean, 

demonstrable migration path for the Collections APIs that were introduced in the Java 2 platform" [11] . This was 

interpreted [12] by the designers as meaning that any new generic collections should be passable to methods which 

expected one of the preexisting collection classes. 

Migration compatibility solves a hypothetical, temporal situation where you have two software products (A,B) used 

by you to build software product C. Both A and B are beyond your control, e.g. supplied by external vendors. 

Product B builds upon product A - i.e. they have a direct relationship which you are unable to intercept through 

configuration or otherwise. Vendor-A moves product A to take advantage of generics and stops supporting the 

non-generic version of A. The vendor of B does not move his product to take advantage of generics coordinated with 

A, creating a situation where the non-generic code of B must be able to call/use generic code of A. Migration 

compatibility allows the non-generic code of B to call and even manipulate objects originating in A. 

C# generics were introduced into the language while preserving full backwards compatibility: Old code (pre C# 2.0) 

runs unchanged on the new generics-aware runtime without recompilation. As for migration compatibility, new 

generic collection classes and interfaces were developed which supplemented the non-generic .NET 1.x collections 

rather than replacing them. In addition to generic collection interfaces, the new generic collection classes implement 

the non-generic collection interfaces where possible. This allows new generic collections to be passed to preexisting 

(non-generic aware) methods, as long as those methods are coded to use the collection interfaces and not the specific


classes. This is not full migration compatibility, however. 

Covariance and contravariance 

Covariance and contravariance is supported by both languages. Java has use-site variance which allows a single 

generic class to declare members using both co- and contravariance. C# has define-site variance for generic 

interfaces and delegates. Variance is not supported directly on classes but is supported through their implementation 

of variant interfaces. C# also has use-site covariance support for methods and delegates. 

Notation and special features 

Special feature keywords 

keyword feature, example usage 

checked, 

unchecked 

In C#, checked statement blocks or expressions can enable run-time checking for arithmetic overflow. 

get, set C# implements properties as part of the language syntax with their optional corresponding get and set accessors, as an alternative for 

the accessor methods used in Java, which is not a language feature but a coding-pattern based on method name conventions. 

goto C# supports the goto keyword. This can occasionally be useful, for example for implementing finite state machines or for generated 

code, but the use of a more structured method of control flow is usually recommended (see criticism of the goto statement). Java 

allows labeled breaks and continues, which make up for many of the uses of goto. 

switch(color) 

{ 

case Color.Blue: 

Console.WriteLine("Color is blue"); break; 

case Color.DarkBlue: 

Console.WriteLine("Color is dark"); 

goto case Color.Blue; 

// ... 

} 

out, ref C# has support for output and reference parameters. These allow returning multiple output values from a method, or passing values by 

reference. 

strictfp Java uses strictfp to guarantee the results of floating point operations remain the same across platforms. 

switch In C#, the switch statement also operates on strings and longs but only allows fallthrough for empty statements. Java's switch 

statement does not operate on strings nor long primitive type but falls through for all statements (excluding those with 'break'). 

throws Java requires every method to declare the checked exceptions or superclasses of the checked exceptions that it can throw. Any method 

can also optionally declare the unchecked exception that it throws. C# has no such syntax. 

public int readItem() throws java.io.IOException 

{ 

// ... 

} 

using C#'s using causes the Dispose method (implemented via the IDisposable interface) of the object declared to be executed after the code 

block has run or when an exception is thrown within the code block. 

// Create a small file "test.txt", write a string, 

// ... and close it (even if an exception occurs) 

using (StreamWriter file = new StreamWriter("test.txt")) 

{ 

file.Write("test"); 

}


Numeric applications 

To adequately support applications in the field of mathematic and financial computation, several language features 

exist. [13] In this category, Java provides the strictfp keyword, which enables strict floating-point calculations for a 

region of code. This will ensure that calculations return the exact same result on all platforms. C# provides no 

equivalent, but does provide the built-in decimal type, for accurate decimal floating-point calculations. This forgoes 

the problems that exist with binary floating-point representations (float, double). Such binary representations are not 

suited to accurately represent decimal numbers and hence introduce rounding errors. For financial applications, an 

accurate decimal type is essential. 

The BigDecimal class also provides such characteristics for Java. BigDecimal and BigInteger are types provided 

with Java that allow arbitrary-precision representation of numbers. As of 2010 the current stable release of the .NET 

framework (4.0) includes classes for manipulating arbitrary-precision integers and complex numbers (with operators 

overloaded for easy use so that BigInteger objects can be used just like any other primitive data type) but still .NET 

Framework lacks classes to deal with arbitrary-precision floating point numbers (see Arbitrary-precision arithmetic). 

In Java there is no way to provide the same level of integration for library-defined types such as BigDecimal or 

complex numbers as there is for the primitive types. For this purpose, C# provides the following: 

• Operator overloading and indexers providing convenient syntax (see below). 

• Implicit and explicit conversions; allow conversions such as exist for the built-in int type that can implicitly 

convert to long. 

• Valuetypes and generics based on valuetypes; in Java every custom type must be allocated on the heap, which is 

detrimental for performance of both custom types and collections. 

In addition to this, C# can help mathematic applications with the checked and unchecked operators that allow to 

enable or disable run-time checking for arithmetic overflow for a region of code. It also offers rectangular arrays, 

that have advantages over regular nested arrays for certain applications. [13] 

Methods 

Methods in C# are non-virtual by default, and have to be declared virtual explicitly if desired. In Java, all non-static 

non-private methods are virtual. Virtuality guarantees that the most recent override for the method will always be 

called, but incurs a certain runtime cost on invocation as these invocations cannot be normally inlined, and require an 

indirect call via the virtual method table. However, some JVM implementations, including the Sun reference 

implementation, implement inlining of the most commonly called virtual methods. 

Java methods are virtual by default (although they can be "sealed" by using the final modifier to disallow 

overriding). There is no way to let derived classes define a new, unrelated method with the same name. 

This means that by default in C#, and only when explicitly asked in Java, you can define new methods in a derived 

class with the same name and signature than the one in its base class. Which implies that when you call that method 

on such an object, depending on the current knowledge of the caller (if it knows its exact subclass or not), the result 

will be different. 

In Java (by default), the subclass's method will be called, but you will be able to call the base class' own method if 

needed. In C# (by default), the base class' method will be called, and you won't be able to intercept the call. 

In very specific cases, when a base class is designed by a different person, and a new version introduces a method 

with the same name and signature as some method already present in the derived class, problems can happen. 

In Java, this will mean that the method in the derived class will implicitly override the method in the base class, even 

though that may not be the intent of the designers of either class. 

To prevent this versioning problem, C# requires that if a method should be overridden, the override keyword must be 

specified. Otherwise, the method will "hide" the inherited method. A compiler warning to this effect is issued, which 

can be silenced by specifying the new keyword. This avoids the problem which can arise from a base class being


extended with a protected/public method whose signature is already in use by a derived class. 

Generator methods 

Any C# method declared as returning IEnumerable, IEnumerator and/or the generic versions of these interfaces can 

be implemented using yield syntax. This is a form of limited, compiler-generated continuations and can drastically 

reduce the code required to traverse or generate sequences, although that code is just generated by the compiler 

instead. The feature can also be used to implement infinite sequences, e.g. the sequence of Fibonacci numbers. 

Below is an example of a C# generator method that takes an enumerable input (possibly an array of ints) and yields 

the even numbers. The method will not iterate through all items on the invocation; rather it will return an iterator 

which will pull items from numbers only on demand. 

public static IEnumerable GetEven(IEnumerable numbers) { 

} 

foreach(int i in numbers) if (i % 2 == 0) yield return i; 

In Java, generators can be defined only using (possibly anonymous) classes, requiring more boilerplate code. 

Explicit interface implementation 

In either language if a method (or property in C#) is specified with the same name and signature in multiple 

interfaces, the members will clash when a class is designed which implements those interfaces. An implementation 

will by default implement a common method for all of the interfaces. If separate implementations are required 

(because the methods really do serve separate purposes, or because return values differ between the interfaces) C#'s 

explicit interface implementation will solve the problem, though allowing different results for the same method, 

depending on the current cast of the object. In Java there is no way to solve this problem other than cleaning the code 

and refactoring one or more of the interfaces to avoid name clashes. 

Closures 

A closure is an inline function which captures variables from its lexical scope. 

[14] [15] 

C# supports closures as anonymous methods or lambda expressions with full-featured closure semantics. 

In Java, anonymous inner classes remains the preferred way to emulate closures. Aside from being a more verbose 

construction, this approach also has some drawbacks compared to real closures, such as limited access to variables 

from the enclosing scopes (only final members can be referenced). 

When a reference to a method can be passed around for later execution, a problem arises about what to do when the 

method has references to variables/parameters in its lexical scope. C# closures can fully capture any 

variable/parameter from its lexical scope. In Java's anonymous inner classes only references to final members of the 

lexical scope are allowed, thus requiring the developer to artificially introduce extra levels of indirections and boxing 

primitive types if he wants to reference and update those from the inner class. 

While Java does not currently feature closures, it has been announced that some form of closures will be included in 

JDK 7. [16]


Language integrated query 

C#s Language INtegrated Query (LINQ) is not really a single feature; rather it is a number of features designed to 

work together to allow for in-language querying capabilities. LINQ has emerged as one of the most distinguishing 

features between Java and C#. 

LINQ consists of the following features: 

• Extension methods allow existing interfaces/classes to be extended with new methods. Implementations can be 

shared or an interface can have a dedicated implementation. 

• Lambdas allow for expression of criteria in a functional fashion. 

• Expression trees allow a specific implementation to capture a lambda as a concrete syntax tree rather than an 

executable block. This can be leveraged by implementations to represent criteria in a different language, e.g. in 

the form of a SQL where clause as is the case with e.g. Linq#LINQ_to_SQL 

• Anonymous types and type inference supports capturing and working with the result type of a query. A query 

may both join and project over query sources which may lead to a result type which cannot be named. 

• Query expressions to support a syntax familiar to SQL. 

• Nullable (lifted) types to allow for better match with query providers which support nullable types, like e.g. SQL. 

Lambdas and expression trees 

C# features a special type of in-line closures called lambdas. These are anonymous methods: they have a signature 

and a body, but no name. They are not methods in that they cannot form part of a class interface. They are mainly 

used to specify local function-valued arguments in calls to other methods, a technique mainly associated with 

functional programming. On top of that, lambda functions can double as a way to define special data structures 

called expression trees. Whether they are seen as an executable function or a data structure depends on compiler type 

inference and what type of variable or parameter they are assigned/cast to. Lambdas and expression trees play key 

roles in LINQ. Java does not feature lambdas or expression trees; its primary mechanism for inline scope capture and 

method definition is the anonymous inner class syntax. 

Partial methods 

Related to partial classes C# allows partial methods to be specified within partial classes. A partial method is an 

intentional declaration of a method with a number of restrictions on the signature. These restrictions ensure that if a 

definition is not actually provided by any class part, then the method and every call to it can be safely erased. This 

feature allows code to provide a large number of interception points (like the template method GoF design pattern) 

without paying any runtime overhead if these extension points are not being used by another class part at compile 

time. Java has no corresponding concept. 

Extension methods 

Using a special this designator on the first parameter of a method, C# allows the method to act as if it were a member 

method of the type of the first parameter. This extension of the foreign class is purely syntactical. The extension 

method needs to be static and defined within a purely static class. It must obey any restriction on such external static 

methods and thus cannot break object encapsulation. The "extension" is only active within scopes where the 

namespace of the static host class has been imported. Java has no corresponding concept.


Conditional compilation 

Unlike Java, C# implements conditional compilation using preprocessor directives. It also provides a Conditional 

attribute to define methods that are only called when a given compilation constant is defined. This way, assertions 

can be provided as a framework feature with the method Debug.Assert(), which is only evaluated when the DEBUG 

constant is defined. Since version 1.4, Java provides a language feature for assertions, which are turned off at 

runtime by default but can be enabled using the "-enableassertions" or "-ea" switch when invoking the JVM. 

Namespaces and source files 

C#'s namespaces are similar to those in C++. Unlike package names in Java, a namespace is not in any way tied to 

location of the source file. While it's not strictly necessary for a Java source file location to mirror its package 

directory structure, it is the conventional organization. 

Both languages allow importing of classes (e.g., import java.util.* in Java), allowing a class to be referenced using 

only its name. Sometimes classes with the same name exist in multiple namespaces or packages. Such classes can be 

referenced by using fully qualified names, or by importing only selected classes with different names. To do this, 

Java allows importing a single class (e.g., import java.util.List). C# allows importing classes under a new local name 

using the following syntax: using Console = System.Console. It also allows importing specializations of classes in 

the form of using IntList = System.Collections.Generic.List. 

Java has a static import syntax that allows using the short name of some or all of the static methods/fields in a class 

(e.g., allowing foo(bar) where foo() can be statically imported from another class). C# has a static class syntax (not 

to be confused with static inner classes in Java), which restricts a class to only contain static methods. C# 3.0 

introduces extension methods to allow users to statically add a method to a type (e.g., allowing foo.bar() where bar() 

can be an imported extension method working on the type of foo). 

The Sun Microsystems Java compiler requires that a source file name must match the only public class inside it, 

while C# allows multiple public classes in the same file, and puts no restrictions on the file name. C# 2.0 and later 

allows splitting a class definition into several files by using the partial keyword in the source code. In Java, a public 

class will always be in its own source file. In C#, source code files and logical units separation are not tightly related. 

Exception handling 

Java supports checked exceptions (in addition to unchecked exceptions). C# only supports unchecked exceptions. 

Checked exceptions force the programmer to either declare the exception thrown in a method, or to catch the thrown 

exception using a try-catch clause. 

Checked exceptions can encourage good programming practice, ensuring that all errors are dealt with. However 

Anders Hejlsberg, chief C# language architect, argues that they were to some extent an experiment in Java and that 

[17] [18] 

they haven't been shown to be worthwhile except in small example programs. 

One criticism is that checked exceptions encourage programmers to use an empty catch block (catch (Exception e) 

{}), which silently eats exceptions, rather than letting the exceptions propagate to a higher-level exception-handling 

routine. Another criticism of checked exceptions is that a new implementation of a method may cause unanticipated 

checked exceptions to be thrown, which is a contract-breaking change. This can happen in methods implementing an 

interface that only declares limited exceptions, or when the underlying implementation of a method changes. To 

allow for such unanticipated exceptions to be thrown, some programmers simply declare the method can throw any 

type of exception ("throws Exception"), which defeats the purpose of checked exceptions. In some cases however, 

exception chaining can be applied instead; re-throwing the exception in a wrapper exception. For example, if an 

object is changed to access a database instead of a file, an SQLException could be caught and re-thrown as an 

IOException, since the caller may not need to know the inner workings of the object.


There are also differences between the two languages in treating the try-finally statement. The finally is always 

executed, even if the try block contains control-passing statements like throw or return. In Java, this may result in 

unexpected behavior if the try block is left by a return statement with some value, and then the finally block that is 

executed afterwards is also left by a return statement with a different value. C# resolves this problem by prohibiting 

any control-passing statements like return or break in the finally block. 

A common reason for using try-finally blocks is to guard resource managing code, thus guaranteeing the release of 

precious resources in the finally block. C# features the using statement as a syntactic shorthand for this common 

scenario, in which the Dispose() method of the object of the using is always called. 

Finally blocks 

Java allows flow of control to leave the finally block of a try statement, regardless of the way it was entered. This 

can cause another control flow statement (such as return) to be terminated mid-execution. For example: 

int foo() { 

} 

try { 

return 0; 

} finally { 

} 

return 1; 

In the above code, the return statement within try block causes control to leave it, and therefore finally block is 

executed before the actual return happens. However, finally block itself performs a return as well; thus, the original 

return that caused it to be entered is not actually executed, and the above method returns 1 rather than 0. 

C# does not allow any statements which allow control flow to leave the finally block prematurely, except for throw. 

In particular, return is not allowed at all, goto is not allowed if the target label is outside the finally block, and 

continue and break are not allowed if the nearest enclosing loop is outside the finally block. 

Lower level code 

The Java Native Interface (JNI) feature allows Java programs to call non-Java code. However, JNI does require the 

code being called to follow several conventions and impose restrictions on types and names used. This means that an 

extra adaption layer between legacy code and Java is often needed. This adaption code must be coded in a non-Java 

language, often C or C++. Java Native Access (JNA) allows easier calling of native code that only requires writing 

Java code, but comes at a performance cost. 

In addition, third party libraries provide for Java-COM bridging, e.g. JACOB [19] (free), and J-Integra for COM [20] 

(proprietary). 

.NET Platform Invoke (P/Invoke) offers the same capability by allowing calls from C# to what Microsoft refers to as 

unmanaged code. Through metadata attributes the programmer can control exactly how the parameters and results 

are marshalled, thus avoiding the need for extra adaption code. P/Invoke allows almost complete access to 

procedural APIs (such as Win32 or POSIX), but limited access to C++ class libraries. 

In addition, .NET Framework also provides a .NET-COM bridge, allowing access to COM components as if they 

were native .NET objects. 

C# also allows the programmer to disable the normal type-checking and other safety features of the CLR, which then 

enables the use of pointer variables. When using this feature, the programmer must mark the code using the unsafe 

keyword. JNI, P/Invoke, and "unsafe" code are equally risky features, exposing possible security holes and 

application instability. An advantage of unsafe, managed code over P/Invoke or JNI is that it allows the programmer 

to continue to work in the familiar C# environment to accomplish some tasks that otherwise would require calling


out to unmanaged code. An assembly (program or library) using unsafe code must be compiled with a special switch 

and will be marked as such. This enables runtime environments to take special precautions before executing 

potentially harmful code. 

Runtime environments 

Java (the programming language) is designed to execute on the Java platform via the Java Runtime Environment 

(JRE). The Java platform includes the Java Virtual Machine (JVM) as well as a common set of libraries. The JRE 

was originally designed to support interpreted execution with final compilation as an option. Most JRE environments 

execute fully or at least partially compiled, possibly with adaptive optimization. The Java compiler produces Java 

bytecode. Upon execution the bytecode is loaded by the Java runtime and either interpreted directly or compiled to 

machine instructions and then executed. 

C# is designed to execute on the Common Language Runtime (CLR). The CLR is designed to execute fully 

compiled code. The C# compiler produces Common Intermediate Language instructions. Upon execution the 

runtime loads this code and compiles to machine instructions on the target architecture. 

Language history and evolution 

Java 

Java is older than C# and has built up a large and highly active user base, becoming the lingua franca in many 

modern branches of computer science, particularly areas which involve networking. Java dominates programming 

courses at high school and college level in the United States, and there are currently more Java than C# books. [21] 

Java's maturity and popularity have ensured more third party Java API and libraries (many of them open source) than 

C#. 

An occasionally voiced criticism [22] of the Java language is that it evolves slowly, lacking some features which 

make fashionable programming patterns and methodologies easier. Some critics suggest that the designers of C# 

may pander too quickly to current trends in programming, thus lacking focus and simplicity. Java's designers seem to 

have taken a more conservative stand on adding major new features to their language syntax than other current 

languages, perhaps not wanting to tie the language too tightly with trends which may prove to be dead ends. 

These trends have been broken with the Java 5.0 release, which introduced several new major language features: a 

foreach construct, autoboxing, methods with variable number of parameters (varargs), enumerated types, generic 

types, and annotations. With the exception of Generics, C# included all these features from its beginning, some 

under different names. [23] Proposals and specifications for the new features had been worked on in the Java 

community for considerable time before they were introduced. Indeed, some had been in gestation since before C#'s 

initial release (e.g., work on Generics formally began in May 1999 [24] ) such was the Java community's conservatism 

at that time. 

Problem-specific language additions to Java have been considered and, for now at least, rejected. This approach, 

along with a number of other new languages and technologies that address themselves specifically towards current 

programming trends, has sparked a renewed debate within the Java camp about the future direction of the Java 

language and whether its 'conservative evolution' is right. 

As of 2008 debate continued over the inclusion of closures [25] and properties [26] into the language syntax for Java 7.


C# 

By contrast, C# is a relatively new language. Microsoft has studied existing languages such as Java and Object 

Pascal, and has changed some aspects of the language and runtime environment in response to perceived failures and 

difficulties with its predecessors. C# accommodates constructs more commonly found in languages such as C++, 

Delphi (the design of which was Anders Hejlsberg's principal job when he was at Borland), and, in recent C# 

versions, borrows from dynamic scripting languages such as Ruby and Python. 

C# 3.0 adds SQL-like language integrated queries suited for querying data from collections, databases or XML 

documents, building upon general-purpose language features, including lambda expressions and extension methods, 

to allow queries to be expressed and optimized for user types. 

Before creating C#, Microsoft implemented a modified Java environment, called J++, adding new features in a 

manner which was in direct contravention to the standards and conventions ensuring the platform neutrality which 

lies at the heart of Java. This violated the license agreement Microsoft had signed, requiring that standards and 

specifications be strictly adhered to in return for using the Java name and brand logos. Sun Microsystems sued, and 

in settling the suit, Microsoft agreed to discontinue J++. (The settlement allowed other existing Java-using Microsoft 

products to continue such use for seven years. [27] ) With the release of the .NET framework (and C#), the project was 

revived in the form of J#. 

See also 

• Comparison of C# and VB.NET 



• Comparison of the Java and .Net platforms 


• C# and Java: Comparing Programming Languages [28] at MSDN 

• A Comparison of C# and Java [29] 

• Java vs. C# - Code for Code Comparison [30] 

• Nine Language Performance Round-up [31] 

• Java and C-Sharp Compared [32] 

• MSDN: The C# Programming Language for Java Developers [33] 

• 31 Differences between C# and Java [34] 

• Standard ECMA-334 C# Language specification [35] 

• Java Language Specification (Sun) [36] 

References 

[1] http:/ / blogs. sun. com/ javafx/ entry/ how_to_use_javafx_in 

[2] August 1998 Java News (http:/ / www. cafeaulait. org/ 1998august. html) 

[3] Java Language Specification Third Edition: section 15.9 Class Instance Creation Expressions (http:/ / java. sun. com/ docs/ books/ jls/ 

third_edition/ html/ expressions. html#41147) 

[4] Goetz, Brian (26 July 2005). "Java theory and practice: Be a good (event) listener" (http:/ / www. ibm. com/ developerworks/ java/ library/ 

j-jtp07265/ index. html). IBM Developer Works. . Retrieved 2008-12-23. 

[5] http:/ / www. angelikalanger. com/ GenericsFAQ/ JavaGenericsFAQ. html 

[6] http:/ / www. angelikalanger. com/ GenericsFAQ/ FAQSections/ TechnicalDetails. html#FAQ110 



[9] there one instances of a static field per instantiation of a parameterized type? (http:/ / www. angelikalanger. com/ GenericsFAQ/ 

FAQSections/ TypeParameters. html#Is) 

[10] Generics in C#, Java, and C++ (http:/ / www. artima. com/ intv/ genericsP. html)


[11] JSR 14: http:/ / www. jcp. org/ en/ jsr/ detail?id=14 

[12] http:/ / gafter. blogspot. com/ 2004/ 09/ puzzling-through-erasure-answer. html 

[13] Java for Scientific Computation: Prospects and Problems (http:/ / www. pds. ewi. tudelft. nl/ pubs/ papers/ scicomp01. pdf) 

[14] Richter, Jeffrey (April 2001). "An Introduction to Delegates" (http:/ / msdn. microsoft. com/ en-ca/ magazine/ cc301810. aspx). MSDN 

Magazine. . Retrieved 2008-12-23. 

[15] Campbell, Dustin (9 February 2007). "What's In A Closure?" (http:/ / diditwith. net/ 

PermaLink,guid,235646ae-3476-4893-899d-105e4d48c25b. aspx). Did it with .NET. . Retrieved 2008-12-23. 

[16] Closures Coming in Java 7 (http:/ / java. dzone. com/ news/ closures-coming-java-7) 

[17] The Trouble with Checked Exceptions (http:/ / www. artima. com/ intv/ handcuffs. html) 

[18] Why doesn't C# have exception specifications? (http:/ / msdn2. microsoft. com/ en-us/ vcsharp/ aa336812. aspx) 

[19] http:/ / jacob-project. sourceforge. net/ 

[20] http:/ / j-integra. intrinsyc. com/ products/ com/ 

[21] O'Reilly, Tim (2006-08-02). "Programming Language Trends" (http:/ / radar. oreilly. com/ archives/ 2006/ 08/ 

programming_language_trends_1. html). Radar. O'Reilly. . 

[22] i-Technology Viewpoint: Java's Not Evolving Fast Enough (http:/ / au. sys-con. com/ node/ 163294) 

[23] Java 5 catches up with C# (http:/ / www. barrycornelius. com/ papers/ java5/ ) 

[24] JSR 14: Add Generic Types To The JavaTM Programming Language (http:/ / jcp. org/ en/ jsr/ detail?id=014) 

[25] Debate over closures for Java (http:/ / gafter. blogspot. com/ 2006/ 09/ debate-over-closures-for-java. html) 

[26] Property Support in Java, the Java Way (http:/ / www. javalobby. org/ java/ forums/ t88090. html) 

[27] CNET. "Sun, Microsoft settle Java suit" (http:/ / news. cnet. com/ 2100-1001-251401. html). . 

[28] http:/ / msdn. microsoft. com/ en-us/ library/ ms836794. aspx 

[29] http:/ / www. 25hoursaday. com/ CsharpVsJava. html 

[30] http:/ / www. javacamp. org/ javavscsharp/ 

[31] http:/ / www. osnews. com/ story. php?news_id=5602 

[32] http:/ / www. csharphelp. com/ archives/ archive96. html 

[33] http:/ / msdn. microsoft. com/ en-us/ library/ ms228602. aspx 

[34] http:/ / www. geeks. ltd. uk/ Knowledgebase/ Compare-c-sharp-java. html 

[35] http:/ / www. ecma-international. org/ publications/ standards/ Ecma-334. htm 

[36] http:/ / java. sun. com/ docs/ books/ jls/ 

Comparison of Java and C++ 

This is a comparison of the Java programming language with the C++ programming language. 

Design aims 

The differences between the C++ and Java programming languages can be traced to their heritage, as they have 

different design goals. 

• C++ was designed mainly for systems programming, extending the C programming language. To this procedural 

programming language designed for efficient execution, C++ has added support for statically-typed 

object-oriented programming, exception handling, scoped resource management, and generic programming, in 

particular. It also added a standard library which includes generic containers and algorithms. 

• Java was created initially to support network computing. It relies on a virtual machine to be secure and highly 

portable. It is bundled with an extensive library designed to provide a complete abstraction of the underlying 

platform. Java is a statically typed object-oriented language that uses a syntax similar to C, but is not compatible 

with it. It was designed from scratch, with the goal of being easy to use and accessible to a wider audience. 

The different goals in the development of C++ and Java resulted in different principles and design trade-offs between 

the languages. The differences are as follows :


C++ Java 

Compatible with C source code, except for a few corner cases. No backward compatibility with any previous language. The syntax is 

however strongly influenced by C/C++. 

Write once compile anywhere (WOCA) Write once run anywhere / everywhere (WORA / WORE) 

Allows both procedural programming and object-oriented 

programming. 

Encourages an object oriented programming paradigm. 

Allows direct calls to native system libraries. Call through the Java Native Interface and recently Java Native Access 

Exposes low-level system facilities. Runs in a protected virtual machine. 

Only provides object types and type names. Is reflective, allowing metaprogramming and dynamic code generation at 

Has multiple binary compatibility standards (commonly Microsoft 

and Itanium/GNU) 

Optional automated bounds checking. (e.g. the at() method in 

vector and string containers) 

runtime. 

Has a binary compatibility standard, allowing runtime check of correctness 

of libraries. 

Normally performs bounds checking. HotSpot can remove bounds checking. 

Supports native unsigned arithmetic. No native support for unsigned arithmetic. 

Standardized minimum limits for all numerical types, but the actual 

sizes are implementation-defined. Standardized types are available 

as typedefs (uint8_t, ..., uintptr_t). 

Pointers, References, and pass by value are supported 

Explicit memory management, though third party frameworks exist 

to provide garbage collection. Supports destructors. 

Supports class, struct, and union and can allocate them on heap or 

stack 

Standardized limits and sizes of all primitive types on all platforms. 

Primitive data types always passed by value. Objects are passed by nullable 

reference (comparable to using pointers for all class or struct parameters in 

C++). [1] 

Automatic garbage collection (can be triggered manually). Doesn't have the 

concept of Destructor and usage of finalize() is not recommended. 

Supports only class and allocates them on the heap. Java SE 6 optimizes with 

escape analysis to allocate some objects on the stack. 

Allows explicitly overriding types. Rigid type safety except for widening conversions. Autoboxing/Unboxing 

The C++ Standard Library has a much more limited scope and 

functionality than the Java standard library but includes: Language 

support, Diagnostics, General Utilities, Strings, Locales, Containers, 

Algorithms, Iterators, Numerics, Input/Output and Standard C 

Library. The Boost library offers much more functionality including 

threads and network I/O. Users must choose from a plethora of 

(mostly mutually incompatible) third-party libraries for GUI and 

other functionality. 

added in Java 1.5. 

The standard library has grown with each release. By version 1.6 the library 

included support for locales, logging, containers and iterators, algorithms, 

GUI programming (but not using the system GUI), graphics, multi-threading, 

networking, platform security, introspection, dynamic class loading, blocking 

and non-blocking I/O, and provided interfaces or support classes for XML, 

XSLT, MIDI, database connectivity, naming services (e.g. LDAP), 

cryptography, security services (e.g. Kerberos), print services, and web 

services. SWT offers an abstraction for platform specific GUIs. 

Operator overloading for most operators Meaning of operators is immutable. 

Full multiple inheritance, including virtual inheritance. Single inheritance only from classes, multiple from interfaces. 

Compile time Templates Run time Generics 

Function pointers, function objects, lambdas (in C++0x) and 

interfaces 

No standard inline documentation mechanism. 3rd party software 

(e.g. Doxygen) exists. 

const keyword for defining immutable variables and member 

functions that do not change the object. 

No function pointer mechanism. Instead idioms such as Interfaces, Adapters 

and Listeners are extensively used. 

Javadoc standard documentation 

final provides a limited version of const, equivalent to type* const pointers 

for objects and plain const of primitive types only. No const member 

functions, nor any equivalent to const type* pointers. 

Supports the goto statement. Supports labels with loops and statement blocks.


Source code can be written to be platform independent (can be 

compiled for Windows, BSD, Linux, Mac OS X, Solaris etc. without 

needing modification) and written to take advantage of platform 

specific features. Is typically compiled into native machine code. 

Is compiled into byte code for the JVM. Is dependent on the Java platform 

but the source code is typically written not to be dependent on operating 

system specific features. 

C++ is a powerful language designed for system programming. The Java language was designed to be simple and 

easy to learn with a powerful cross-platform library. The Java standard library is considerably large for a standard 

library. However, Java does not always provide full access to the features and performance of the platform that the 

software runs on. The C++ standard libraries are simple and robust providing containers and associative arrays. [2] 

Language features 

Syntax 

• Java syntax has a context-free grammar which can be parsed by a simple LALR parser. Parsing C++ is somewhat 

more complicated; for example, Foo(3); is a sequence of comparisons if Foo is a variable, but it creates an 

object if Foo is the name of a class template. 

• C++ allows namespace level constants, variables, and functions. All such Java declarations must be inside a class 

or interface. 

• In C++ declarations, a class name declares an object of that class as a value (a.k.a. value semantics). There is no 

way to do this in Java. Objects are not values in Java. In Java declarations, a class name declares a reference to an 

object of that class (a.k.a. reference semantics). The equivalent way to do this in C++ is to use "*" to declare a 

pointer. 

• In C++, the operator "." takes an object as the left operand and accesses a member of the object. Since objects 

cannot be values in Java, and all objects are accessed through references, this cannot be done in Java. In Java, the 

"." operator takes a reference to an object as the left operand and access a member of that object. The equivalent 

operator in C++ is "->". 

e="7.71"> 

{ // Declares class Foo 

; // Member variable 

: x(0) { // Constructor for Foo, 

// initializes x 

ar(int i) { // Member function bar() 

eturn 3*i + x; 

e="7.71"> 

C++ Java 

es a to be a Foo object value, 

lized using the default constructor 

wanted to use another constructor, 

uld declare it as "Foo a(args);" 

 

class Foo { // Defines class Foo 

public int x = 0; // Member variable, 

// with initializer 

public Foo() { // Constructor for Foo 

} 

public int bar(int i) {// Member method bar() 

return 3*i + x; 

} 

} 

 

Foo a; 

// declares a to be a reference to a Foo object 

a = new Foo(); 

// initializes using the default constructor 

// If you wanted to use another constructor, 

// you would declare it as "Foo a = new Foo(args);


e="7.71"> 

; 

the contents of a to a new Foo object b; 

ative syntax is "Foo b(a)" 

 

Foo b = a.clone(); 

// copies the values of all members 

// of this instance if, and only if, 

// Foo implements a public method called 

// clone() which returns a new copy of the object 

 

e="7.71">a.x = 5; // modifies the object a a.x = 5; // modifies the object 

e="7.71"> 

.x 

es c to be a pointer to a 

ject (initially 

ned; could point anywhere) 

e="7.71"> 

oo(); 

c to reference a new Foo object 

e="7.71"> 

c; 

d to reference the same object as c 

e="7.71"> 

es the object referenced by c 

e="7.71"> 

// invokes Foo::bar() for a 

; // invokes Foo::bar() for *c 

e="7.71"> 

->x


C++ Java 

const Foo *a; // you cannot modify the object 

//pointed to by a through a 

private final Foo a;//Use getA() instead of a 

public Foo getA(){ 

return a.clone() 

} 

a = new Foo(); a=new Foo();//Only in constructor 

a->x = 5; 

// ILLEGAL 

Foo *const b = new Foo(); 

// you can declare a "const" pointer 

b = new Foo(); 

//ILLEGAL, you can't re-bind it 

b->x = 5; 

// LEGAL, you can still modify the object 

getA().x=5; 

//Only modifies a clone of a's x, not a.x 

final Foo b = new Foo(); 

// you can declare a "final" reference 

b = new Foo(); 

// ILLEGAL, you can't re-bind it 

b.x = 5; 

// LEGAL, you can still modify the object 

• C++ supports goto statements; Java enforces structured control flow, and relies on labelled break and labelled 

continue statements to provide some goto-like functionality. Some commenters point out that these labelled flow 

control statements break the single point-of-exit property of structured programming. [3] 

• C++ provides low-level features which Java lacks. In C++, pointers can be used to manipulate specific memory 

locations, a task necessary for writing low-level operating system components. Similarly, many C++ compilers 

support inline assembler. In Java, such code has to reside in external libraries, and can only be accessed through 

the Java Native Interface with a significant overhead for each call. 

Semantics 

• C++ allows default values for arguments of a function/method, Java does not. However, method overloading can 

be used to obtain similar results in Java. 

• The minimal compilation unit in C++ is a function; the compilation unit in Java is a class. In C++, functions can 

be compiled separately. In Java, to compile and maintain methods separately requires moving them into super and 

extended classes or using some other code refactoring technique. 

• C++ allows a range of implicit conversions between native types, and also allows the programmer to define 

implicit conversions involving user-defined types. In Java, only widening conversions between native types are 

implicit; other conversions require explicit cast syntax. 

• A consequence of this is that although loop conditions (if, while and the exit condition in for) in Java and C++ 

both expect a boolean expression, code such as if(a = 5) will cause a compile error in Java because there is no 

implicit narrowing conversion from int to boolean. This is handy if the code was a typo for if(a == 5). Yet 

current C++ compilers usually generate a warning when such an assignment is performed within a conditional 

expression. 

• For passing parameters to functions, C++ supports both pass-by-reference and pass-by-value. In Java, parameters 

are always passed by value. [4] However, in Java all non-primitive values are references to objects (in C++ terms, 

they are (smart)-pointers). Objects are not values in Java and only their references can be manipulated; C++ 

developers who are used to having objects as values may confuse this with pass-by-reference. 

• Java built-in types are of a specified size and range defined by the virtual machine; In C++, a minimal range of 

values is defined for built-in types, but the exact representation (number of bits) can be mapped to whatever 

native types are supported on a given platform. 

• For instance, Java characters are 16-bit Unicode characters, and strings are composed of a sequence of such 

characters. C++ offers both narrow and wide characters, but the actual size of each is platform dependent, as is


the character set used. Strings can be formed from either type. 

• The rounding and precision of floating point values and operations in C++ is platform dependent. Java provides 

an optional strict floating-point model that guarantees consistent results across platforms, though possibly at the 

cost of slower run-time performance. 

• In C++, pointers can be manipulated directly as memory address values. Java does not have pointers — it only 

has object references and array references, neither of which allow direct access to memory addresses. In C++ one 

can construct pointers to pointers, while Java references only access objects. 

• In C++ pointers can point to functions or methods (function pointers or functors). The equivalent mechanism in 

Java uses object or interface references. 

• Through the use of stack-allocated objects, C++ supports scoped resource management, a technique used to 

automatically manage memory and other system resources that supports deterministic object destruction. Yet, 

scoped resource management in C++ cannot be guaranteed; it is only a design pattern, and hence relies on 

programmers' adherence. Java supports automatic memory management using garbage collection, but other 

system resources (windows, communication ports, threads) often have to be explicitly released if the garbage 

collector can not determine they are no longer used. 

• C++ features programmer-defined operator overloading which is not supported in Java. The only overloaded 

operators in Java are the "+" and "+=" operators, which concatenate strings as well as performing addition. 

• Java features standard API support for reflection and dynamic loading of arbitrary new code. 

• C++ supports static and dynamic linking of binary to manage the space required for binary and performance. 

• Java has generics, whose main purpose is to provide type-safe containers. C++ has templates, which provide more 

extensive support for generic programming. 

• Both Java and C++ distinguish between native types (these are also known as "fundamental" or "built-in" types) 

and user-defined types (these are also known as "compound" types). In Java, native types have value semantics 

only, and compound types have reference semantics only. In C++ all types have value semantics, but a reference 

can be created to any type, which will allow the object to be manipulated via reference semantics. 

• C++ supports multiple inheritance of arbitrary classes. In Java a class can derive from only one class, but a class 

can implement multiple interfaces (in other words, it supports multiple inheritance of types, but only single 

inheritance of implementation). 

• Java explicitly distinguishes between interfaces and classes. In C++ multiple inheritance and pure virtual 

functions make it possible to define classes that function almost like Java interfaces do, with a few small 

differences. 

• Java has both language and standard library support for multi-threading. The synchronized keyword in Java 

provides simple and secure mutex locks to support multi-threaded applications, though synchronized sections 

have to be left in LIFO order. Java also provides robust and complex libraries for more advanced multi-threading 

synchronization. In C++ there is currently no defined memory model for multi-threading; however, third party 

libraries provide support roughly equivalent to that of Java; obvious difference being the non-uniformity of these 

C++ libraries. 

• C++ methods can be declared as virtual functions, which means the method to be called is determined by the 

run-time type of the object. By default, methods in C++ are not virtual. In Java, methods are virtual by default, 

but can be made non-virtual by using the final keyword. 

• C++ enumerations are primitive types and support conversion to and comparison with other integer types. Java 

enumerations are actually instances of a class (they extend java.lang.Enum) and may therefore define 

constructors, fields, and methods as any other class.


Resource management 

• Java offers automatic garbage collection. Memory management in C++ is usually done through constructors, 

destructors, and smart pointers. The C++ standard permits garbage collection, but does not require it; garbage 

collection is rarely used in practice. The enforced use of automatic garbage collection means that writing 

real-time software can be difficult in Java. [3] 

• C++ can allocate arbitrary blocks of memory. Java only allocates memory through object instantiation. (Note that 

in Java, the programmer can simulate allocation of arbitrary memory blocks by creating an array of bytes. Still, 

Java arrays are objects.) 

• Java and C++ use different idioms for resource management. Java relies mainly on garbage collection, which can 

only reclaim memory and may be a last shot at other resources, while C++ relies mainly on the RAII (Resource 

Acquisition Is Initialization) idiom. This is reflected in several differences between the two languages: 

• In C++ it is common to allocate objects of compound types as local stack-bound variables which are destroyed 

when they go out of scope. In Java compound types are always allocated on the heap and collected by the 

garbage collector (except in virtual machines that use escape analysis to convert heap allocations to stack 

allocations). 

• C++ has destructors, while Java has finalizers. Both are invoked prior to an object's deallocation, but they 

differ significantly. A C++ object's destructor must be implicitly (in the case of stack-bound variables) or 

explicitly invoked to deallocate the object. The destructor executes synchronously just prior to the point in the 

program at which the object is deallocated. Synchronous, coordinated uninitialization and deallocation in C++ 

thus satisfy the RAII idiom. In Java, object deallocation is implicitly handled by the garbage collector. A Java 

object's finalizer is invoked asynchronously some time after it has been accessed for the last time and before it 

is actually deallocated, which may never happen. Very few objects require finalizers; a finalizer is only 

required by objects that must guarantee some clean up of the object state prior to deallocation — typically 

releasing resources external to the JVM. In Java safe synchronous deallocation of resources has to be 

performed explicitly using the try/finally construct. 

• In C++ it is possible to have a dangling pointer – a stale reference to an object that has already been 

deallocated; attempting to use a dangling pointer typically results in program failure. In Java, the garbage 

collector won't destroy a referenced object. 

• In C++ it is possible to have uninitialized primitive objects, Java enforces default initialization. 

• In C++ it is possible to have an object that is allocated, but has no reachable reference to it. Such an 

unreachable object cannot be destroyed (deallocated), and results in a memory leak. In contrast, in Java an 

object will not be deallocated by the garbage collector until it becomes unreachable (by the user program). 

(Note: weak references are supported, which work with the Java garbage collector to allow for different 

strengths of reachability.) Garbage collection in Java prevents many memory leaks, but leaks are still possible 

under some circumstances. [5] 

• Java is more prone to leaking non-memory resources, while idiomatic C++ makes that much harder. 

Libraries 

• C++ provides cross-platform access to many features typically available in platform-specific libraries. Direct 

access from Java to native operating system and hardware functions requires the use of the Java Native Interface. 

Runtime 

• C++ is normally compiled directly to machine code which is then executed directly by the operating system. Java 

is normally compiled to byte-code which the Java virtual machine (JVM) then either interprets or JIT compiles to 

machine code and then executes.


• Due to its unconstrained expressiveness, low level C++ language features (e.g. unchecked array access, raw 

pointers, type punning) cannot be reliably checked at compile-time or without overhead at run-time. Related 

programming errors can lead to low-level buffer overflows and segmentation faults. The Standard Template 

Library provides higher-level abstractions (like vector, list and map) to help avoid such errors. In Java, low level 

errors either cannot occur or are detected by the JVM and reported to the application in the form of an exception. 

• The Java language requires specific behavior in the case of an out-of-bounds array access, which generally 

requires bounds checking of array accesses. This eliminates a possible source of instability but usually at the cost 

of slowing down execution. In some cases, compiler analysis can prove a bounds check unnecessary and 

eliminate it. C++ has no required behavior for out-of-bounds access of native arrays, thus requiring no bounds 

checking for native arrays. C++ standard library collections like std::vector, however, offer optional bounds 

checking. In summary, Java arrays are "always safe; severely constrained; always have overhead" while C++ 

native arrays "have optional overhead; are completely unconstrained; are potentially unsafe." 

Templates vs. Generics 

Both C++ and Java provide facilities for generic programming, templates and generics, respectively. Although they 

were created to solve similar kinds of problems, and have similar syntax, they are actually quite different. 

C++ Templates Java Generics 

Classes and functions can be templated. Classes and methods can be genericized. 

Parameters can be any type or integral value. Parameters can only be reference types (not primitive types). 

Separate copies of the class or function are likely to be generated for each type 

parameter when compiled. 

One version of the class or function is compiled, works for all 

type parameters. 

Objects of a class with different type parameters are different types at run time. Type parameters are erased when compiled; objects of a class 

Implementation source code of the templated class or function must be included 

in order to use it (declaration insufficient). 

Templates can be specialized -- a separate implementation could be provided for 

a particular template parameter. 

Template parameters can have default arguments (only for template classes, not 

functions). 

Does not support wildcards. Instead, return types are often available as nested 

typedefs. 

Does not directly support bounding of type parameters, but metaprogramming 

provides this [6] 

with different type parameters are the same type at run time. 

Signature of the class or function from a compiled class file is 

sufficient to use it. 

Generics cannot be specialized. 

Generic type parameters cannot have default arguments. 

Supports wildcard as type parameter if it is only used once. 

Supports bounding of type parameters with "extends" and 

"super" for upper and lower bounds, respectively; allows 

enforcement of relationships between type parameters. 

Allows instantiation of class of type parameter type. Does not allow instantiation of class of type parameter type 

(except through reflection). 

Type parameter of templated class can be used for static methods and variables. Type parameter of templated class cannot be used for static 

methods and variables. 

Static variables are not shared between classes of different type parameters. Static variables are shared between instances of a classes of 

Templated classes and functions do not enforce type relations for type parameters 

in their declaration. Use of a wrong type parameter results in the template code 

"not working", usually generating an error message at a place in the template 

code where an operation is not allowed for that type and not in the user's code. 

Proper use of templated classes and functions is dependent on proper 

documentation. Metaprogramming provides these features at the cost of 

additional effort. 

different type parameters. 

Generic classes and functions can enforce type relationships for 

type parameters in their declaration. Use of a wrong type 

parameter results in a type error at the code that uses it. 

Operations on parametrized types in generic code are only 

allowed in ways that can be guaranteed to be safe by the 

declaration. This results in greater type safety at the cost of 

flexibility.


Templates are Turing-complete (see template metaprogramming). Generics are not Turing-complete. 

Miscellaneous 

• Java and C++ use different techniques for splitting up code in multiple source files. Java uses a package system 

that dictates the file name and path for all program definitions. In Java, the compiler imports the executable class 

files. C++ uses a header file source code inclusion system for sharing declarations between source files. (See 

Comparison of imports and includes.) 

• Compiled Java code files are generally smaller than code files in C++ as Java bytecode is usually more compact 

than native machine code and Java programs are never statically linked. 

• C++ compilation features an additional textual preprocessing phase, while Java does not. Thus some users add a 

preprocessing phase to their build process for better support of conditional compilation. 

• In both languages, arrays have a fixed size. In Java, arrays are first-class objects, while in C++ they are merely a 

continuous run of their base objects, often referred to using a pointer to their first element and an optional length. 

In Java, arrays are bounds-checked and know their length, while in C++ you can treat any subsequence as an 

array in its own right. Both C++ and Java provide container classes (std::vector and java.util.ArrayList 

respectively) which are resizable and store their size. 

• Java's division and modulus operators are well defined to truncate to zero. C++ does not specify whether or not 

these operators truncate to zero or "truncate to -infinity". -3/2 will always be -1 in Java, but a C++ compiler may 

return either -1 or -2, depending on the platform. C99 defines division in the same fashion as Java. Both 

languages guarantee (where a and b are integer types) that (a/b)*b + (a%b) == a for all a and b (b != 0). The C++ 

version will sometimes be faster, as it is allowed to pick whichever truncation mode is native to the processor. 

• The sizes of integer types is defined in Java (int is 32-bit, long is 64-bit), while in C++ the size of integers and 

pointers is compiler and ABI dependent within given constraints. Thus, carefully-written C++ code can take 

advantage of the 64-bit processor's capabilities while still functioning properly on 32-bit processors. However, 

care must be taken to write the C++ program in a portable manner. In contrast, Java's fixed integer sizes mean that 

programmer error in this regard shouldn't be possible. This may incur a performance penalty since Java code 

cannot run using an arbitrary processor's word size. 

Performance 

In addition to running a compiled Java program, computers running Java applications must also run the Java Virtual 

Machine JVM, while compiled C++ programs can be run without external applications. Early versions of Java were 

significantly outperformed by statically compiled languages such as C++. This is because the program statements of 

these two closely related languages may compile to a few machine instructions with C++, while compiling into 

several byte codes involving several machine instructions each when interpreted by a JVM. For example: 

Java/C++ statement C++ generated code (x86) Java generated byte 

vector[i]++; mov edx,[ebp+4h] 

mov eax,[ebp+1Ch] 

inc dword ptr [edx+eax*4] 

aload_1 

iload_2 

dup2 

iaload 

iconst_1 

While this may still be the case for embedded systems because of the requirement for a small footprint, it is 

frequently argued that advances in just in time (JIT) compiler technology for long-running server and desktop Java 

processes will close the performance gap. 

iadd 

iastore 

code


Several studies of mostly numerical benchmarks argue that Java could potentially be faster than C++ in some 

circumstances, [7] [8] [9] . However, it was shown that numerical (micro-)benchmarks are not appropriate for 

evaluation of languages as compiler is able to optimize both cases equally, or eliminate benchmarked code entirely. 

[10] [11] [12] If referring to a real world program, Java would suffer because of number of reasons: [13] [14] [15] 

• All objects are allocated on the heap. For functions using small objects this can result in huge performance 

degradation as stack allocation costs essentially zero. 

• Methods are by-default virtual. This increases memory usage as much as several times for small objects because 

of virtual function tables. Also, it induces performance penalty, because JIT compiler has to do additional 

optimization passes even for de-virtualization of small functions. 

• A lot of casting required even using standard containers induces performance penalty as it is needed to walk 

through entire inheritance hierarchy. 

• Virtual Java Machine Increases memory usage even further, thus reducing memory locality and increasing 

chances of cache misses and therefore slowdown of the program. 

• Lack of access to low level details does not allow developer to better optimize the program where the compiler is 

unable to do so. [16] 

It is argued, however, that compared to Java, C++ also has a number of downsides: 

• Pointers make optimization difficult since they may point to arbitrary data. However this is obsoleted as new 

compilers introduced strict-aliasing rule [17] and because of support of the C99 keyword restrict. [18] 

• Java garbage collection may have better cache coherence than usual usage of malloc/new for memory allocation 

as its allocations are generally made sequentially. Nevertheless, arguments exist that both allocators equally 

fragment the heap and no one exhibits better cache locality. 

• Run-time compilation can potentially use additional information available at run-time to optimise code more 

effectively, such as knowing what processor the code will be executed on. However this claim is effectively made 

obsolete as most state-of-the-art C++ compilers generate multiple code paths to employ full computational 

abilities of the given system [19] . 

Proprietary Control 

C++ is not a trademark of any company or organization and is not owned by any individual. [20] Java is a trademark 

of Sun Microsystems, which is now owned by Oracle. [21] 

The C++ language is defined by ISO/IEC 14882, an ISO standard, which is published by the ISO/IEC 

JTC1/SC22/WG21 committee. The Java language is defined by the Java Language Specification[36], a book which 

is published by Sun (now Oracle). 

External references 

• Java and C++ Memory Management [22] — an exhaustive publication about object-oriented memory management 

that compares Java and C++ in terms of Memory Modeling. 

• How Java Differs from C [23] — excerpt from Java in a Nutshell by David Flanagan 

• Java vs. C++ resource management comparison [24] - Comprehensive paper with examples 

• Java vs C performance... again... [25] - In-depth discussion of differences between Java and C / C++ with regard to 

performance


References 

[1] Java is Pass-By-Value (http:/ / javadude. com/ articles/ passbyvalue. htm) 

[2] Java and C++ Library (http:/ / en. wikibooks. org/ wiki/ C+ + _Programming/ Programming_Languages/ Comparisons/ Java#Libraries) 

[3] Robert C. Martin (January 1997). "Java vs. C++: A Critical Comparison" (http:/ / www. objectmentor. com/ resources/ articles/ javacpp. pdf) 

(PDF). . 

[4] James Gosling, Bill Joy, Guy Steele, and Gilad Bracha, The Java language specification, third edition. Addison-Wesley, 2005. ISBN 

0-321-24678-0 (see also online edition of the specification (http:/ / java. sun. com/ docs/ books/ jls/ third_edition/ html/ j3TOC. html)). 

[5] "Java memory leaks -- Catch me if you can" (http:/ / www-128. ibm. com/ developerworks/ rational/ library/ 05/ 0816_GuptaPalanki/ ) by 

Satish Chandra Gupta, Rajeev Palanki, IBM DeveloperWorks, 16 Aug 2005 

[6] Boost type traits library (http:/ / www. boost. org/ libs/ type_traits/ doc/ html/ boost_typetraits/ reference. html) 

[7] "Microbenchmarking C++, C# and Java" (http:/ / www. ddj. com/ 184401976) by Thomas Bruckschlegel, Dr. Dobbs, June 17, 2005 

[8] "Performance of Java versus C++" (http:/ / scribblethink. org/ Computer/ javaCbenchmark. html) by J.P. Lewis and Ulrich Neuman, USC, 

Jan. 2003 (updated 2004) 

[9] "Java will be faster than C++" (http:/ / trs-new. jpl. nasa. gov/ dspace/ bitstream/ 2014/ 18351/ 1/ 99-1827. pdf) by Kirk Reinholtz, JPL, Apr 

2001 

[10] http:/ / www. ibm. com/ developerworks/ java/ library/ j-jtp02225. html#2. 0 

[11] http:/ / www. irrlicht3d. org/ pivot/ entry. php?id=446 

[12] "Java (not really faster) than C++ benchmark (http:/ / bruscy. republika. pl/ pages/ przemek/ java_not_really_faster_than_cpp. html) 

illustrates 

[13] http:/ / www. jelovic. com/ articles/ why_java_is_slow. htm 

[14] http:/ / warp. povusers. org/ grrr/ java. html 

[15] . p. 18. page.mi.fu-berlin.de/prechelt/Biblio//jccpprtTR.pdf. 

[16] Clark, Nathan; Amir Hormati, Sami Yehia, Scott Mahlke (2007). "Liquid SIMD: Abstracting SIMD hardware using lightweight dynamic 

mapping". HPCA’07: 216–227. 

[17] http:/ / cellperformance. beyond3d. com/ articles/ 2006/ 06/ understanding-strict-aliasing. html 

[18] Demystifying the Restrict Keyword (http:/ / www. cellperformance. com/ mike_acton/ 2006/ 05/ demystifying_the_restrict_keyw. html) 

[19] www.slac.stanford.edu/comp/unix/.../icc/.../optaps_dsp_qax.htm Targeting IA-32 Architecture Processors for Run-time Performance 

Checking 

[20] Bjarne Stroustrup's FAQ: Do you own C++? (http:/ / www. research. att. com/ ~bs/ bs_faq. html#revenues) 

[21] ZDNet: Oracle buys Sun; Now owns Java (http:/ / blogs. zdnet. com/ BTL/ ?p=16598). 

[22] http:/ / task3. cc/ 289/ object-oriented-memory-management 

[23] http:/ / www. ora. com/ catalog/ javanut/ excerpt/ index. html#except 

[24] http:/ / www. fatalmind. com/ papers/ java_vs_cplusplus/ resource. html 

[25] http:/ / www. azulsystems. com/ blog/ cliff-click/ 2009-09-06-java-vs-c-performanceagain


Comparison of the Java and .NET platforms 

Legal issues 

Standardization 

The two platforms, their programming libraries, their binary formats, and their runtime environments have largely 

been governed by very different means. 

International standards organizations Ecma International and ISO/IEC define the standard for the .NET executable 

environment (known as the Common Language Infrastructure, or CLI), and .NET executable format (known as 

Common Intermediate Language, or CIL), but excluding most of the foundation classes (the Base Class Library, or 

BCL). This formal committee-based standardization process is in keeping with the way very popular languages like 

COBOL, Fortran and C have been standardized in the past. The standards do not include many new libraries that 

Microsoft has implemented on top of the standard framework, such as those for accessing databases, or building GUI 

and Web applications, such as Windows Forms, ASP.NET and ADO.NET. 

To date, no part of Java has been standardized by Ecma International, ISO/IEC, ANSI, or any other third-party 

standards organization. While Sun Microsystems has unlimited and exclusive legal rights to modify and license its 

Java trademarks, Sun voluntarily participates in a process called the Java Community Process (JCP) that allows 

interested parties to propose changes to any of Sun's Java technologies (from language and tools to API) via forums, 

consultation exercises and expert groups. The JCP requires a membership fee for commercial contributors, while 

non-commercial contributors and individuals can join for free. 

Within the rules of the JCP anyone can bring forward a proposal for a new Platform Edition Specifications or 

suggest changes to the Java language. All proposals are reviewed and voted on by interested JCP members at various 

stages throughout their lifecycle, however when it comes to including changes into the standard reference 

implementations (Java SE, Java EE and Java ME) modifications may be subject to rejection by Sun, who retain 

ultimate power of veto. 

Java standards are maintained by a suite of test applications which examine every aspect of a given Java 

implementation against a rigorous specification. Only if an implementation passes the tens of thousands of individual 

tests can it use the trademarked name "Java", and associated logos and brands. 

License 

Java 

While "Java" is a Sun trademark, and only Sun can license the name "Java", numerous free software projects exist 

that are compatible with Sun Java. Most notably, GNU Classpath and GCJ provide a free software class library and a 

compiler that are partially compatible with the current version of Sun Java. [1] Sun announced in November 13, 2006 

that all Java source code, excluding closed-source code for which they do not retain rights, will be released under a 

modified version of the GPL, [2] and released two fundamental parts of the JRE and JDK: HotSpot and the javac 

[3] [4] 

compiler under the GPL. 

Following their promise, Sun released the complete source code of the Class library under GPL on May 8, 2007, 

except some limited parts that were licensed by Sun from 3rd parties who did not want their code to be released 

under an open-source license [5] (see also Free Java implementations). Sun's goal is to replace the parts that remain 

closed with alternative implementations and make the class library completely open. 

In June 2008, Red Hat announced [6] that the IcedTea project has passed the rigorous Java TCK, indicating a fully 

functional open-source implementation of the Java platform.


.NET 

Microsoft's .NET CLI executable environment, and some of the corresponding class library, have been 

standardized and can be freely implemented without a license. A few standards-compliant free software 

environments have been implemented, such as the Mono Project and DotGNU. The Mono Project has also 

implemented many of Microsoft's non-standard libraries by examining Microsoft materials, similar to GNU 

Classpath and Java. 

Microsoft is currently distributing a shared source version of its .NET runtime environment for academic use, 

however it is only supported on Windows XP SP2 and has not been updated after .NET 2.0. [7] 

The Mono project aims to avoid infringing on any patents or copyrights, and to the extent that they are successful, 

the project can be safely distributed and used under the GPL. On November 2, 2006, Microsoft and Novell 

announced a joint agreement whereby Microsoft promised not to sue Novell or its customers for patent 

infringement. [8] According to a statement on the blog of Mono project leader Miguel de Icaza, this agreement only 

extends to Mono for Novell developers and users. [9] Because of the possible threat of Microsoft patents, the FSF 

[10] [11] 

recommends that people avoid creating software that depends on Mono or C#. 

The Microsoft/Novell agreement was criticized by some in the open source community because it violates the 

principles of giving equal rights to all users of a particular program (see Agreement with Microsoft and Mono and 

Microsoft's patents). 

In response to the Microsoft/Novell agreement the Free Software Foundation revised its GNU General Public 

License to close the loophole used by Microsoft and Novell to bypass the GPL's very restrictive provisions on patent 

deals. [12] The FSF also stated that by selling coupons for Novell's Linux software, the mechanism by which 

Microsoft circumvented the GNU license, it considers Microsoft to be a Linux vendor, and thereby subject to the full 

terms and conditions laid out in the GPL. [12] (Microsoft issued the coupons because on the patent deal worked out 

between the two companies Novell's network patents were considered far more profitable to Microsoft than 

Microsoft's .NET patents were to Novell.) 

Community 

In its proprietorship of Java, Sun works with an open culture, allowing multiple parties, from organizations to 

individuals, to steer the decision making process. Sun retains exclusive and unlimited legal rights to its Java 

intellectual properties, and the Java community is subject to those rights. 

Sun's acceptance of third-party contributions goes to solve the problem of vendor lock-in at the cost of sometimes 

creating a baffling array of options for beginners wishing to choose a Java-based solution. Java has grown in 

popularity to become one of the most popular languages of the early 21st century, and the pluralist nature of its 

development has resulted in many different groups tackling the same (or similar) problems. This issue is particularly 

acute in the Enterprise space (web/Ajax/Web2.0 applications), where one must not only be familiar with Java, but 

also the various competing frameworks. 

While Microsoft has developed C# and .NET without a formal community contribution system, the language and 

some parts of the executable format and runtime have been standardized and freely distributed through Ecma and 

ISO in an open and vendor-neutral process, rather than a process that retains veto and copy rights for Microsoft. 

However, the standards do not include many new libraries that Microsoft has implemented on top of the standard 

framework (see Standardization). Numerous C# and CLI community software projects, help and documentation 

sites, and discussion forums are under active development and maintenance, including those focusing on Windows 

development with Microsoft .NET or the Mono project, Free software Operating system development under the 

Mono project, and mobile development using Microsoft's .NET compact framework.. 

Microsoft is distributing a shared source release (version 1.0) of the .NET virtual machine that can be compiled and 

used on Windows, FreeBSD, Mac OS X, and other platforms. [13] An updated version (2.0) is currently available, but


the only officially supported platform is Windows. [14] A community port to Linux of the 1.0 shared source .NET 

virtual machine is also available. [15] In March 2003, O'Reilly Media published a book about Microsoft's shared 

source .NET runtime. [16] 

Traditional computer applications 

Desktop applications 

Although Java's AWT (Abstract Windowing Toolkit) and Swing libraries are not shy of features, Java has struggled 

to establish a foothold in the desktop market. Sun Microsystems has also been slow, in the eyes of some, to promote 

Java to developers and end users alike in a way which makes it an appealing choice for desktop software. Even 

technologies such as Java Web Start, which have few parallels within rival languages and platforms, have barely 

been promoted. 

The release of Java version 6.0 in December 11, 2006, saw a renewed focus on the desktop market with an extensive 

set of new tools for closer integration with the desktop. At the 2007 JavaOne conference Sun made further desktop 

related announcements, including a new language aimed at taking on Adobe Flash (JavaFX), a new lightweight way 

of downloading the JRE which sees the initial footprint reduced to under 2Mb, and a renewed focus on multimedia 

libraries. 

An alternative to AWT and Swing is the Standard Widget Toolkit (SWT), which was originally developed by IBM 

and now maintained by the Eclipse Foundation. It attempts to achieve improved performance and visualization of 

Java desktop applications by relying on underlying native libraries where possible. 

.NET is becoming more common in open source and free software systems due to its inclusion [17] by the GNOME 

desktop environment using the Mono framework. 

Server applications 

This is probably the arena in which the two platforms are closest to being considered rivals. Java, through its Java 

EE (a.k.a. Java Platform Enterprise Edition) platform, and .NET through ASP.NET, compete to create web-based 

dynamic content and applications. 

Both platforms are well used and supported in this market, with a bevy of tools and supporting products available for 

Java EE and .NET. And both have high profile backers. For example, for Java: Oracle included direct support for 

Java into its database, while Google has used Java to power tools like Gmail. [18] 

Some of Sun's current Java-related license agreements for Java EE define aspects of the Java platform as a trade 

secret, [19] and prohibit the end user from contributing to a third-party Java environment. Specifically, at least one 

current license for a Sun Java EE development package contains the following terms: "You may make a single 

archival copy of Software, but otherwise may not copy, modify, or distribute Software." — "Unless enforcement is 

prohibited by applicable law, you may not decompile, or reverse engineer Software." — "You may not publish or 

provide the results of any benchmark or comparison tests run on Software to any third party without the prior 

written consent of Sun." — "Software is confidential and copyrighted." [19] However, while Sun's software is subject 

to the above license terms, Sun's Java EE API reference has been implemented under an open source license by the 

JBoss and JOnAS projects. 

Microsoft's implementation of ASP.NET is not part of the standardized CLI, and while Microsoft's runtime 

environment and development tools are not subject to comparable secrecy agreements to Java EE, the official 

Microsoft tools are not open source or free software, and require Windows servers. However, a cross-platform free 

software ASP.NET 2.0 implementation is part of the Mono project (minus webparts and Web Services 

Enhancements). [20]


Embedded applications 

Mobile applications 

Java ME has a very large base within the mobile phone and PDA markets, with only the cheapest devices now 

devoid of a KVM (a cut down Java Virtual Machine for use on devices with limited processing power). Java 

software, including many games, is commonplace. 

While almost every mobile phone includes a JVM, these features are not always heavily used by users (particularly 

in North America). Initially Java applications on most phones typically consisted of menuing systems, small games, 

or systems to download ringtones etc. However, more powerful phones are increasingly being sold with simple 

applications pre-loaded, such as translation dictionaries, world clock displays (darkness/light, timezones, etc.) and 

calculators. Some of these are written in Java, although how often phone owners actually use them is probably 

unknown. 

In January 2007 Steve Jobs suggested that Apple's iPhone would not support Java. [21] [22] Significantly, at that time 

Java's mobile platform was perceived as nearly ubiquitous across the cell phone market, commonly being used by 

software companies to write device-neutral mobile applications. Noted commentators argued against Jobs' stand, [23] 

but when the iPhone finally appeared it did indeed lack both Java and Adobe's rival Flash technology, favoring 

instead simple web applications using the phone's Safari browser. 

In May 2007 Sun used the JavaOne conference to announce JavaFX Mobile, as a direct response to Adobe's attempt 

to introduce Flash onto mobile devices. 

In October 2007 Apple bowed to pressure and announced that by early 2008 the iPhone would be opened up to allow 

development of software other than via the Safari browser. Neither Java nor Flash is supported under this plan, and 

Apple does not allow interpreters for any language to run on the phone. 

Home entertainment technologies 

Java has found a market in digital television, where it can be used to provide software which sits alongside 

programming, or extends the capabilities of a given Set Top Box. TiVo, for example, has a facility called "Home 

Media Engine", which allows JavaTV software to be transmitted to an appropriate TiVo device to complement 

programming or provide extra functionality (for example, personalized stock tickers on a business news program.) 

A variant of Java has been accepted as the official software tool for use on the next generation optical disc 

technology Blu-ray, via the BD-J interactive platform. This will mean that interactive content, such as menus, games, 

downloadables, etc. on all Blu-ray optical discs will be created under a variant of the Java platform. Blu-ray 

equipment first went on sale to the consumer in 2006, and is currently not widely owned. However, the release of the 

Sony PlayStation 3 in late 2006 and early 2007 may give the platform a boost. 

Rather than using Java, HD DVD (the defunct high definition successor to DVD) uses a technology jointly 

developed by Microsoft and Disney called HDi that is based on XML, CSS, JavaScript, and other technologies that 

are comparable to those used by standard web browsers. 

The BD-J platform API is more extensive than its iHD rival, with an alleged 8,000 methods and interfaces, as 

opposed to iHD's 400. [24] And while Microsoft is pushing iHD's XML presentation layer by including it with 

Windows Vista, iHD is still a newcomer in a market sector where Java technologies are already commonplace. [25] 

However, the fact that the HD DVD format has been abandoned in favor of Blu-ray means that HDi is no longer 

supported on any Optical disc format, making the BD-J format a clear winner. [26]


Runtime inclusion in operating systems 

.NET/Mono 

On Windows, Microsoft is promoting .NET as its flagship development platform, [27] by including the .NET runtime 

in Windows XP Service Pack 2 and 3, Windows Server 2003, Windows Vista, Windows Server 2008 and Windows 

7. Microsoft also distributes the Visual C# Express development environment at no cost. [28] 

.NET Framework 3.5 runtime is not pre-installed on versions of Windows prior to Vista SP1, and must be 

[29] [30] 

downloaded by the user, which has been criticized because of its large size (65 MB download for .NET 3.5). 

While neither .NET nor Mono are installed with Mac OS X out-of-the-box, the Mono project can be downloaded and 

installed separately, for free, for any Mac user who wants to build and/or run C# and .NET software. As of 13 May 

2008, Mono's System.Windows.Forms 2.0 is API complete (contains 100% of classes, methods etc. in Microsoft's 

System.Windows.Forms 2.0); also System.Windows.Forms 2.0 works natively on Mac OS X. 

C# and the CLI are included and used in a number of Linux and BSD based operating systems by way of including 

[31] [32] [33] 

the free software Mono Project. 

As a result of inclusion of .NET or Mono runtimes in the distributions of Windows and Linux, non-GUI applications 

that utilize the programming interfaces that are common to both .NET and Mono can be developed in C# or any 

other .NET language and then deployed across many operating systems and processor architectures using a runtime 

environment that is available as a part of the operating system's installation. [34] [35] [36] Both Microsoft .NET and the 

Mono project have complete support for the Ecma- and ISO-standardized C# language and .NET runtime, and many 

of Microsoft's non-standardized .NET programming interfaces have been implemented or are under development in 

Mono, [37] but each environment includes many components that have not been implemented in the other. 

Java 

Starting with XP SP1a, Windows does not ship with a Java runtime environment. However according to a September 

2003 press release some OEMs agreed to pre-install the JRE on their desktop and laptop models. Mentioned were 

Acer, Dell, Gateway, Hewlett-Packard, and Toshiba. [38] These companies combined make up a simple majority of 

consumer PC's sold in the United States of America. [39] 

Java comes pre-installed on all new Apple computers since Mac OS X 10.0. Because Apple maintains the Java 

runtime for Mac OS X, updates are usually one or two versions behind the versions available from Sun for the other 

operating systems, and versions of Java are usually tied to the specific operating system version, so newer Java 

versions are usually unavailable for older versions of OS X. 

Java comes pre-installed with many commercial Unix flavors, including those from Sun, IBM and Hewlett Packard. 

As of June 2009, the Fedora 9, [40] Ubuntu 8.04, [41] Debian, [42] Slackware extra, [43] Mandriva [44] and OpenSUSE [45] 

distributions are available with OpenJDK, based completely on free and open source code. [46] Since June 2008, 

OpenJDK passed all of the compatibility tests in the Java SE 6 JCK and can claim to be a fully compatible Java 6 

implementation. [47] [48] OpenJDK can run complex applications such as Netbeans, Eclipse, GlassFish, or JBoss. 

The Operating System Distributor License for Java (DLJ) [49] is a Sun initiative to ease distribution issues with 

operating systems based on OpenSolaris or Linux. 

If Java is not installed on a computer by default, it may be downloaded by the user as a web plugin. The web plugin 

process has been criticized because of the size of the Java plugin. Unlike other plugins the Java download is a full 

runtime environment, capable of running not just applets, but full applications and dynamic WebStart apps. Because 

of this the perceived download footprint is larger than some web plugins. However, compared to Java, other popular 

browser plugins have larger sizes: Java 6 JRE is 13 MB, but Acrobat Reader is 33 MB, QuickTime 19 MB, 

Windows Media Player 25 MB, the .NET Framework 3.0 runtime is 54 MB, and the .NET Framework 3.5 runtime is 

197 MB (it's a united package for x86, x64 and IA-64, each part has approximately 60 MB).


At the JavaOne event in May 2007 Sun announced that the deployment issues with Java would be solved in two 

major updates during the lifespan of Java 6 (the changes will not be held over to Java 7.) These include: 

• the introduction of a new consumer JRE edition, with an initial 2Mb footprint and the ability to download the 

remaining 9Mb in sections using an on-demand methodology. 

• the development of drop-in cross platform JavaScript code, which can be used from a web page to install the 

necessary JRE for a given applet or Rich Internet Application to run, if necessary. 

• an improvement in support for automatically downloading updates to the JRE. 

• support for pre-loading of the JRE, so applets and applications written in Java start up almost instantaneously. 

See also 

• Comparison of Java and C# languages 


• C# 


• ECMA-335 Common Language Infrastructure (CLI), 4th edition (June 2006) [50] Free download of Ecma CLI 

standard 

• ISO/IEC 23271:2006 Common Language Infrastructure (CLI) Partitions I to VI [51] The official ISO/IEC CLI 

standard 

References 

[1] Results of comparison between jdk15 and classpath (http:/ / www. kaffe. org/ ~stuart/ japi/ htmlout/ h-jdk15-classpath) 

[2] Free and Open Source Java - Project Overview (http:/ / www. sun. com/ software/ opensource/ java/ project_overview. jsp) 

[3] Sun openjdk: Home (http:/ / openjdk. java. net/ ) 

[4] Sun Java 2 Runtime License Agreement (http:/ / java. sun. com/ j2se/ 1. 4. 2/ j2re-1_4_2_13-license. txt) 

[5] "Open JDK is here!" (http:/ / mail. openjdk. java. net/ pipermail/ announce/ 2007-May. txt). Sun Microsystems. 2007-05-08. . Retrieved 

2007-05-09. 

[6] Java Finally Free and Open (http:/ / truthhappens. redhatmagazine. com/ 2008/ 06/ 19/ java-finally-free-and-open/ ) 

[7] Rotor: Shared Source CLI Provides Source Code for a FreeBSD Implementation of .NET (http:/ / msdn. microsoft. com/ msdnmag/ issues/ 

02/ 07/ SharedSourceCLI/ ) 

[8] Microsoft and Novell Announce Broad Collaboration on Windows and Linux Interoperability and Support (http:/ / www. novell. com/ news/ 

press/ item. jsp?id=1196) 

[9] "Statement on the blog of Mono project leader Miguel de Icaza regarding patent protection for Mono" (http:/ / tirania. org/ blog/ archive/ 

2006/ Nov-04. html). 2006-11-04. . Retrieved 2006-11-06. 

[10] Stallman, Richard (2009-06-26). "Why free software shouldn't depend on Mono or C#" (http:/ / www. fsf. org/ news/ 

dont-depend-on-mono). Free Software Foundation. . Retrieved 2009-07-02. "We should systematically arrange to depend on the free C# 

implementations as little as possible. In other words, we should discourage people from writing programs in C#. Therefore, we should not 

include C# implementations in the default installation of GNU/Linux distributions, and we should distribute and recommend non-C# 

applications rather than comparable C# applications whenever possible." 

[11] "Microsoft's Empty Promise" (http:/ / www. fsf. org/ news/ 2009-07-mscp-mono). Free Software Foundation. 2009-07-16. . Retrieved 

2009-078-03. "Until that happens, free software developers still should not write software that depends on Mono. C# implementations can still 

be attacked by Microsoft's patents: the Community Promise is designed to give the company several outs if it wants them. We don't want to see 

developers' hard work lost to the community if we lose the ability to use Mono, and until we eliminate software patents altogether, using 

another language is the best way to prevent that from happening." 

[12] Microsoft takes on the free world. (http:/ / money. cnn. com/ magazines/ fortune/ fortune_archive/ 2007/ 05/ 28/ 100033867/ index. htm) 

[13] Shared Source Common Language Infrastructure 1.0 Release (http:/ / www. microsoft. com/ downloads/ details. 

aspx?FamilyId=3A1C93FA-7462-47D0-8E56-8DD34C6292F0& displaylang=en) 

[14] Shared Source Common Language Infrastructure 2.0 Release (http:/ / www. microsoft. com/ downloads/ details. 

aspx?familyid=8c09fd61-3f26-4555-ae17-3121b4f51d4d& displaylang=en) 

[15] Rotor Comes to Linux (http:/ / www. ondotnet. com/ pub/ a/ dotnet/ 2002/ 07/ 01/ rotorlinux. html) 

[16] oreilly.com -- Online Catalog: Shared Source CLI Essentials (http:/ / www. oreilly. com/ catalog/ sscliess/ ) 

[17] Mono-Applications-Aplenty!, OSNews (http:/ / www. osnews. com/ story. php/ 9780/ Mono-Applications-Aplenty!)


[18] Google Web Toolkit (http:/ / code. google. com/ webtoolkit/ ) 

[19] Java EE SDK 5 Update 2 No JDK download page (reference to license agreement) (http:/ / javashoplm. sun. com/ ECom/ docs/ Welcome. 

jsp?StoreId=22& PartDetailId=java_ee_sdk-5_02-nojdk-oth-JPR& SiteId=JSC& TransactionId=noreg) 

[20] Mono: ASP.NET (http:/ / www. mono-project. com/ ASP. NET) 

[21] Jobs: No Java for you (http:/ / blogs. zdnet. com/ Burnette/ ?p=238) 

[22] Steve Jobs on iPhone: No Java For You (http:/ / www. javalobby. org/ java/ forums/ t88464. html) 

[23] Steve Jobs alert: Killer Java app for iPhone (http:/ / scobleizer. com/ 2007/ 03/ 20/ steve-jobs-alert-killer-java-app-for-iphone/ ) 

[24] HD-DVD vs. Blu-Ray, round 2 (http:/ / blogs. zdnet. com/ carroll/ index. php?p=1583) 

[25] Format Wars - Blu-ray vs HD DVD (http:/ / www. pcauthority. com. au/ print. aspx?CIID=60242& SIID=) 

[26] Zaharov-Reutt, Alex (2008-02-21). "Microsoft's HDi interactivity layer loses from HD DVD's death - but does it matter?" (http:/ / www. 

itwire. com/ content/ view/ 16780/ 1154/ 1/ 0/ ). itwire.com. . Retrieved 2008-08-27. "While many claimed that creating interactivity with HDi 

was much simpler than using BD-J, the fact that HD DVD will see few future releases beyond 2008 means that, whatever the enthusiasts 

position on the relative merits of HDi vs BD-J, the BD-J interactivity format is now the winner" 

[27] Microsoft article that refers to C# as its "flagship" language. (http:/ / www. microsoft. com/ learning/ books/ developer/ feature/ 050301. 

mspx) 

[28] microsoft.com: Visual C# (http:/ / msdn. microsoft. com/ vstudio/ express/ visualcsharp/ ) 

[29] "Dear Microsoft" (http:/ / channel9. msdn. com/ ShowPost. aspx?PageIndex=1& PostID=370737#370737). 2008-01-09. . Retrieved 

2008-02-03. 

[30] ".Net framework 3.5 size 166MB!" (http:/ / www. codeprof. com/ dev-archive/ 179/ 12-1020-1798773. shtm). 2007-11-10. . Retrieved 

2008-02-03. 

[31] Fedora embraces Mono - ZDNet UK (http:/ / news. zdnet. co. uk/ software/ 0,1000000121,39246774,00. htm) 

[32] Debian Mono Packages (http:/ / packages. debian. org/ mono) 

[33] Wikipedia Uses Mono; Mono Integrated into Ubuntu/Debian - OSNews.com (http:/ / www. osnews. com/ story. php?news_id=10714) 

[34] Fedora Catches Mono (http:/ / www. desktoplinux. com/ news/ NS2809897659. html) 

[35] SUSE 10.1 released (http:/ / www. mono-project. com/ news/ archive/ 2006/ May-11-1. html) 

[36] Wikipedia Uses Mono; Mono Integrated into Ubuntu/Debian (http:/ / www. osnews. com/ story. php/ 10714/ 

Wikipedia-Uses-Mono-Mono-Integrated-into-UbuntuDebian) 

[37] "Mono – Plans" (http:/ / www. mono-project. com/ Plans). . Retrieved 2008-12-23. 

[38] Sun signs up five more OEMs for Java (http:/ / www. infoworld. com/ article/ 03/ 09/ 23/ HNsunoems_1. html) 

[39] "Digitimes.com" (http:/ / www. digitimes. com/ systems/ a20070420PR208. html). . Available only for paid subscribers. 

[40] Wade, Karsten (2008-03-13). "OpenJDK in Fedora 9!" (http:/ / developer. redhatmagazine. com/ 2008/ 03/ 12/ 

openjdk-to-replace-icedtea-in-fedora-9/ ). redhatmagazine.com. . Retrieved 2008-04-05. "Thomas Fitzsimmons updated the Fedora 9 release 

notes source pages to reflect that Fedora 9 would ship with OpenJDK 6 instead of the IcedTea implementation of OpenJDK 7. Fedora 9 

(Sulphur) is due to release in May 2008." 

[41] "openjdk-6 in Ubuntu" (https:/ / launchpad. net/ ubuntu/ + source/ openjdk-6). . Retrieved 2008-04-19. 

[42] "Package: openjdk-6-jdk" (http:/ / packages. debian. org/ stable/ openjdk-6-jdk). debian.org. 2009-02-14. . Retrieved 2009-02-16. 

[43] Slackware Java package (http:/ / packages. slackware. it/ package. php?q=current/ jdk-6-i586-1) 

[44] Mandriva Java package (http:/ / qa. mandriva. com/ twiki/ bin/ view/ Main/ JavaPackaging#Compati) 

[45] "Package: OpenJDK" (http:/ / en. opensuse. org/ OpenJDK). opensuse.org. . Retrieved 2009-06-01. 

[46] Reinhold, Mark (2008-04-24). "There's not a moment to lose!" (http:/ / blogs. sun. com/ mr/ entry/ in_hardy_heron). . Retrieved 2008-04-19. 

[47] Sharples, Rich (2008-06-19). "Java is finally Free and Open" (http:/ / blog. softwhere. org/ archives/ 196). . 

[48] Angel, Lillian (2008-03-13). "OpenJDK to replace IcedTea in Fedora 9" (http:/ / langel. wordpress. com/ 2008/ 03/ 13/ openjdk-in-fedora-9/ 

). . Retrieved 2008-04-05. 

[49] Operating System Distributor License for Java (DLJ) (https:/ / jdk-distros. dev. java. net/ ) 

[50] http:/ / www. ecma-international. org/ publications/ standards/ ecma-335. htm 

[51] http:/ / www. iso. org/ iso/ iso_catalogue/ catalogue_tc/ catalogue_detail. htm?csnumber=42927


Constant interface 

In the Java programming language, the constant interface pattern describes the use of an interface solely to define 

constants, and having classes implement that interface in order to achieve convenient syntactic access to those 

constants. However, since the usage of constants is an implementation detail, it is considered inappropriate to define 

an interface for this purpose. [1] [2] In general, collecting system constants into classes independent of behaviour, 

might create a poor object-oriented design, because it is often a sign of low cohesion. It is for these reasons that 

implementing constants interfaces is considered to be an anti-pattern. 

Use of this anti-pattern has a few other downsides: 

1. It pollutes the class namespace with read-only variables that may not be of use. 

2. Contrary to the compile-time tactical utility of implementing a constants interface, the incidental run-time 

artifacts have little practical purpose (cf. marker interfaces which also have no methods but are useful at 

run-time). 

3. If binary code compatibility is required in future releases, the constants interface must remain forever an interface 

(it cannot be converted into a class), even though it has not been used as an interface in the conventional sense. 

4. Without an IDE that resolves where the constant are coming from, tracking it back to its containing class or 

interface can be time consuming. 

5. A variable (representing an instance) of the interface is syntactically no more useful than the interface name itself 

(since it has no methods). 

Example 

public interface Constants { 

} 

public static final double PI = 3.14159; 

public static final double PLANCK_CONSTANT = 6.62606896e-34; 

public class Calculations implements Constants { 

} 

public double getReducedPlanckConstant() { 

} 

Alternatives 

return PLANCK_CONSTANT / (2 * PI); 

Many of the pitfalls of the anti-pattern can be avoided by converting the constants interface to a proper class with no 

instances: 

public final class Constants { 

private Constants() { 

} 

// restrict instantiation 

public static final double PI = 3.14159;


} 

public static final double PLANCK_CONSTANT = 6.62606896e-34; 

This still leaves the original intent of the pattern mostly un-addressed (i.e. there is no syntax for accessing the 

constants unqualified). However, since Java 5, consider using static import [2] to achieve the same goal: 

import static Constants.PLANCK_CONSTANT; 

import static Constants.PI; 

public class Calculations { 

} 

public double getReducedPlanckConstant() { 

} 

return PLANCK_CONSTANT / (2 * PI); 

To varying degrees, the issues listed above have now been addressed: 

1. Because static members can be imported specifically, the class namespace need not be polluted with all members 

of the constants interface. 

2. Run-time and compile-time semantics are more closely aligned when using static imports instead of constants 

interfaces. 

3. The compiled code has one less binary compatibility constraint (that "class Calculations implements Constants"). 

4. Because static imports apply only to the current file (and not the whole class hierarchy) it is easier to discover 

where each static member is declared. 

5. There is less need to declare variables of the constants interface type, and it is potentially clearer that no concrete 

instances actually exist. 

Note however, the changes do nothing to improve the cohesion of the Constants class, so static imports should not be 

considered to be a panacea. 

References 

[1] Bloch, Joshua, Effective Java, 2nd Edition, p. 98 

[2] Sun Microsystems, Inc. (2004). "Static Import" (http:/ / java. sun. com/ j2se/ 1. 5. 0/ docs/ guide/ language/ static-import. html).


Java 4K Game Programming Contest 

The Java 4K Game Programming Contest (aka 'Java 4K' and 'J4K') is an informal contest that was started by the 

Java Game Programming community to challenge their software development abilities. The goal of the contest is to 

develop the best game possible within four kilobytes (4096 bytes) of data. While the rules originally allowed for 

nearly any distribution method, recent years have required that the games be packaged as either an executable JAR 

file, a Java Webstart application, or a Java Applet. 

History 

The Java 4K Game Programming Contest came into being on August 28, 2002 when a user by the handle of 

codymanix posted the suggestion to the Sun Microsystems Java forums. After a bit of argument over how feasible a 

game would be in 4K, a user by the handle of mlk officially organized the contest on August 29, 2002. 

Slowly but surely, entries began to trickle in for the contest. The majority of these entries were Applets, as it was 

believed that separating the images from the class files would help reduce the size of the file. Future contests would 

see a reversal of this as game creators utilized compressed JAR files to reduce the size of their code. 

One of the most interesting points about the first contest was that non-game applications were allowed. One 

contestant produced a telnet server in 4K of Java! However, this artifact of the first competition did not survive, and 

was most likely allowed because of the loose handling of the first contest. While no winner was officially declared 

the first year, the 4K Racing game submitted by Robin Chaddock (aka Abuse/AbU5e) was generally agreed upon to 

have "won". 

Successive competitions became more and more organized, with many of the contestants pitching in to handle 

administration and promotion of the contest. All contests received official judging, with the method of judging being 

refined each year. By the third year, the contest was officially transitioned over to the JavaGaming.org forums. The 

fourth year saw the introduction of the JavaUnlimited website as the official repository for the contest. The site had 

been used the previous year to track entries that had been posted to the official threads on JavaGaming.org and 

forum.java.sun.com. 

Tradeoffs 

Because the Java class file format incurs quite a bit of overhead, creating a complete game in 4K can be quite a 

challenge. As a result, contestants must choose how much of their byte budget they wish to spend on graphics, 

sound, and gameplay. Finding the best mix of these factors can be extremely difficult. Many new entrants believe 

that impressive graphics alone are enough to carry a game. However, entries with more modest graphics and focus 

on gameplay have regularly scored higher than such technology demonstrations. 

Prizes 

When first conceived, the "prize" for winning the contest was a bundle of "Duke Dollars", a virtual currency used on 

Sun Microsystems' Java forums. This currency could theoretically be redeemed for physical prizes such as watches 

and pens. Unfortunately, the artificial currency was being downplayed by the introduction of the 4K contest, thus 

leaving no real prize at all. 

While there has been some discussion of providing prizes for the contest, it has continued to thrive without them. 

Most entrants seem to feel content to compete with their peers in a challenge of skill and ability. The reward has 

been nothing more than praise from those who play the games.


Reasons for success 

While there has been a great deal of debate on why the Java 4K contest is so successful, the consensus from the 

contestants seems to be that it provides a very appealing challenge. Not only do the entrants get the chance to show 

off how much they know about Java programming, but the 4K size helps "even the odds" compared to other 

competitions where the use of artists and musicians can easily place an entry far ahead of the others. 

This may explain why spinoff contests targeting 8K, 16K, or a specific API like LWJGL have never taken off. In 

fact, the contestants seem to believe that 4K is the "sweet spot" that balances what an individual can do. Because of 

the tricks developed for the 4K contest, it's believed that adding even a single kilobyte would open the doors to far 

more complex games that are beyond the ability of a single developer. 

Year 2 (2004) 

Heavy use of pre-rendered sprites, transparency, and sound effects defined this year's entries. The strongest 

contenders were Defender 4000, Abuse's Shooty-Transparenty Game, and Space Invaders. However, Space Invaders' 

lack of sound caused it to fall behind the other two entries which were competing hard to pack in the most 

technology and gameplay. 

Of particular interest were the different tactics used by the two entries. For graphics, Abuse used precious few high 

color images which he then applied transparency and rotation to at runtime. Jbanes, on the other hand, developed an 

imaging packing technique that allowed him to store twenty-one single-color images. Rather than applying rotation 

and transparency, he chose to use his larger number of images to produce pre-rendered animations. For sound, Abuse 

used clear chimes and other instruments from the MIDI soundbank. Jbanes chose to use runtime-generated PCM 

sound that sounded more like video games of the late 1970s and early 1980s. 

Both approaches had their merit, so it's difficult to say what finally swayed the judge's opinion. What is known is 

that Year 2 was the last year that sound would be a deciding factor in the games. In future years, the bytes allocated 

to sound were reallocated to other functions such as 3D graphics, levels, and bosses. 

Year 2 was the first year that official judging took place. Unlike subsequent years, the only judge was the contest 

organizer, mlk. After careful consideration, the judge decided to award Prong with the Best Technical Achievement 

Award, and declared Defender 4000 as the overall winner. Interestingly, he scored each game but did not use this 

score in determining the winner. Abuse's Shooty-Transparenty Game actually scored one point higher than Defender 

4000. 

Official List of Year 2 Entries [1] 

Year 3 (2005) 

Year 3 was defined by a major influx of professional Java developers, 3D graphics in the games, and a gradual 

transition to the JavaGaming.org forums. JavaUnlimited also began mirroring the competitors in a permanent 

archive. While the mirror started as a manually edited HTML page, it eventually grew into a complete contest 

management site with a database back-end. 

Judging this year was handled by a panel of three volunteer, professional developers who were not participating in 

the contest. One of the volunteer judges was Chris Melissinos, Sun's Chief Gaming Officer. The scoring method 

used was based on the method that mlk had applied the previous year, but was updated to allow the judges to give 

awards for exceptional gameplay or technological achievements. 

While most of the entries were of exceptional quality, T4XI by Kevin Glass (aka kevglass) was chosen as the winner. 

Besides having extremely original gameplay, it provided exceptional graphics through a pseudo-3D effect that gave 

perspective to the buildings.


A minor amount of controversy erupted due to entries that judges had failed to score. Entries like JM4K and 

IsOlation Net where either too complex for the judges to launch, or contained networking components that they 

couldn't test. After this year's competition, the rules were changed to require that games be self-executable. In 

addition, contestants were warned in advance about the difficulties in judging networked games. 

List of Games [2] 

List of Scores: (DHTML [3] ) (XLS [4] ) 

Year 4 (2006) 

Year 4 marked a period of transition toward making gameplay a priority over graphics and technical 

accomplishment. Many of the games were fairly simple in design, but aimed to make up for it with engrossing or 

addictive gameplay. 

For the first time in the contest's history, a special forum was setup on JavaGaming.org to host the contest. In 

addition, the JavaUnlimited.net site became the official site for entries and judging. While judging was originally 

going to be handled through JavaUnlimited by the Javagaming.org community, pushback from several members 

resulted in falling back on a more traditional judging system. 

After the results came back, Miners4K by Markus_Persson was declared the winner. Second place was given to 

Kevin Glass's Roll4K, and third place was given to Goomba4K by Woogley. 

The results of Year 4's judging were significantly better than those of Year 3, in part due to the rule changes which 

forced the entries to conform to easily executable formats. However, this did not completely eliminate judging 

issues. Some controversy erupted when two entries (Xero and JSquares) were given lower scores due to technical 

glitches. Several recommendations were posed to prevent this from happening in future contests, including trimmed 

mean scoring and verification of judge's scoring before acceptance. 

List of Games & Results [5] 

Year 5 (2007) 

Year 5 launched in December 2006 and lasted until March 1, 2007. It saw some great games, with much less focus 

on 3D and pseudo-3D graphics. Most games were 2D, with Pipe Extreme and Trailblazer being the only notable 

exceptions (one could argue that a few others are 3D as well, but distinctly less so). 

Just like year 4, a forum was hosted on JavaGaming.org to host the contest. JavaUnlimited's system was used for 

hosting the games again, being considered the official site for the entries. A site update was planned for 

JavaUnlimited, but did not occur. Originally, the plan was to have a public vote and a judging panel. One month 

after the contest closing date the organizer without further explanation dropped the judging panel, which caused 

some unrest in the forums, accusations of censorship, locked threads and two participants withdrawing their entries 

from the contest (bringing the total down from 65 to 58) [6] . Voting was limited to javagaming.org forum 

participants, and within the alloted time, 25 people voted. About two months after the contest closing date, the 

official results were announced. 

The winner was Metro4k by Blaine Hodge, followed by Jojoh's Roadfourk and Ulf Ochsenfahrt's aichess4k. Metro4k 

is a Sim City-like city simulation game, Roadfourk a racing game, and aichess4k a chess game featuring an AI 

opponent. 

Unlike previous years, year 5 saw no game take the "last place", because the approval voting system used only gave 

votes to around half the games. 

• List of Games [7] 

• Results [8]


Year 6 (2008) 

Year 6 launched in December 2007 and lasted until March 1, 2008. Notably less games were submitted than in 2006 

and 2007 - only 21 in total. Most of the games were 2d, with a total of 3 games using 3D or pseudo-3D graphics. 

The competition was hosted on a new website, Java4k.com [9] . Games from previous years can also be found on the 

new website. Before the launch of the contest, woogley had announced his withdrawal from arranging contest. The 

task of administrating the contest and hosting the site was therefore taken over by Arni Arent (appel) and Joakim 

Johnsson (jojoh). Just like previous years, there was also a dedicated forum [10] at JavaGaming.org [11] . 

The games were then thoroughly reviewed by five judges; Arni Arent, Joakim Johnsson, Kevin Glass, Matt Hicks 

and Chris Melissinos. They reviewed each game in three categories; Overall, Technical and Presentation. The results 

were announced on March 28, 2008. 

The top three games in each category are listed below. 

Overall Score 

1. Spiderball4k by Måns Olson 

2. Pinball 4K by Tom-Robert Bryntesen 

3. t4nks by Markus Persson 

Technical Score 

1. Z4rch by Simon 

2. Mini Golf by Tim Foden 

3. 'Pinball 4K by Tom-Robert Bryntesen 

Presentation Score 

1. t4nks by Markus Persson 

2. Spiderball4k by Måns Olson 

3. war4k by Michael Bliem 

• The results of the competition [12] 

• The judges' reviews of the games [13] 

• List of games [14] 


• Web Archive of the Original Thread [15] - Actual thread was deleted by Sun during a regular system purge 

• Incomplete list of first year entries [16] - Saved by Archive.org 

• Year 2 Thread [17] - On Sun's Java Forums 

• Java Unlimited [18] - The repository for submitted games since 2005. 

• 4K Game Design Tricks [19] - A Wiki article to assist new entrants. 

• 4K Tips and Sources [20] - A set of tips, tutorials and game source codes for 4K Java participants 

• JavaGaming.org Contest Forums [21] - Each year (starting with year 3) has its own sub-forum. 

• Why are 4K Games so much fun to write and Play? [22] 

• Should there be Java game competitions without size limits? [23]


References 

[1] http:/ / forum. java. sun. com/ thread. jspa?threadID=471050& start=279& tstart=0 

[2] http:/ / www. javaunlimited. net/ games/ java4k_2005. php 

[3] http:/ / games. datadino. com/ 4K_2005/ scores. html 

[4] http:/ / games. datadino. com/ 4K_2005/ 4K%20Scores. xls 

[5] http:/ / javaunlimited. net/ results/ 

[6] "JavaGaming Forum" (http:/ / www. javagaming. org/ forums/ index. php?topic=16357. msg129239#msg129239). . Retrieved 2007-04-30. 

[7] http:/ / javaunlimited. net/ games/ java4k_2007. php 

[8] http:/ / javaunlimited. net/ vote/ 

[9] http:/ / www. java4k. com/ index. php?action=home 

[10] http:/ / www. javagaming. org/ forums/ index. php?board=56. 0 

[11] http:/ / www. javagaming. org 

[12] http:/ / java4k. com/ overall. html 

[13] http:/ / java4k. com/ reviews. html 

[14] http:/ / java4k. com/ index. php?action=games& cid=4 

[15] http:/ / web. archive. org/ web/ 20021029192411/ http:/ / forum. java. sun. com/ thread. jsp?forum=406& thread=293877 

[16] http:/ / web. archive. org/ web/ 20030804050840/ http:/ / www. saber-x. com/ midgarddesign/ 4k. html 

[17] http:/ / forum. java. sun. com/ thread. jspa?threadID=471050& start=15& tstart=0 

[18] http:/ / javaunlimited. net/ 

[19] http:/ / wiki. java. net/ bin/ view/ Games/ 4KGamesDesign 

[20] http:/ / www. ahristov. com/ tutorial/ java4k-tips. html 

[21] http:/ / www. javagaming. org/ forums/ index. php?board=46. 0 

[22] http:/ / www. javagaming. org/ forums/ index. php?topic=11611. 0 

[23] http:/ / www. javagaming. org/ forums/ index. php?topic=11509. 0 

CookXml 

CookXml is a unique XML data binding engine in Java. It is capable mapping XML documents of desired format 

directly onto the corresponding object-oriented classes, essentially treating XML as a programming language rather 

than merely a data storage format. Therefore, it is ideal to use CookXml to write any programs that interprets XML. 

The tag library of CookXml is constructed dynamically at run time, and thus allows dynamic XML schema. The 

current implementation has unmarshaling part done. 

CookXml is free software, distributed under a permissive, X11 style licence. 

Unmarshaling 

CookXml offers the ability to directly mapping XML documents onto existing classes by breaking down the process 

into three general steps. Then use a set of delegates, together forming a tag library, to handle actions performed at 

these steps. 

1. Object creation. Each element tag corresponds to an object instance. The action to create the object instance 

corresponds to a creator in CookXml. 

2. Property setting. Each attribute of the XML element corresponds to setting a property of the object instance. This 

property can be handled by a setter in CookXml. For languages that offer reflection, such as Java and C#, such 

property setting can be automatically detected using reflection. In these cases, to match the string attribute value 

to the target property class type, a converter is necessary. 

3. Add action. When CookXml obtains an object corresponding to an element tag, it is "added" to the parent object 

corresponding to the parent element tag. The specific add action is handled by an adder in CookXml. 

Save for CDATA nodes, the three above types of actions can handle all elements in an XML document. CDATA in 

general can be handled either in the creator function or the adder function.

CookXml 107 

Creators, setters, adders, and converters together form a tag library which is used by the CookXml engine to perform 

the XML data binding. 

Dynamic Tag Library Construction 

Because CookXml tag library uses delegates, its tag library needs to be dynamically constructed. This feature is both 

good and bad. It is bad because there will be a slight initiation cost when the tag library is constructed, and its 

integrity may not be verified until runtime. It is also good because it allows developers to easily extend an existing 

tag library at run time. 

Preorder and Postorder Addition 

Like any trees that can be traversed in preorder and postorder, the object corresponding to an XML element can be 

added to the parent object in preorder or postorder. In the preorder addition, the object is added to the parent before 

descendant XML elements get processed. In the postorder addition, the object is added to the parent after descendant 

XML elements get processed. 

XML Tag Inheritance 

One discovery made while writing CookXml was that class inheritance of Object-oriented languages can be mirrored 

into XML element tag inheritance. Semantically, tag inheritance means that the derived tag will inherit the setters 

and adders of the inherited tags. 

For example, javax.swing.JMenu is a child class of javax.swing.JMenuItem. Assuming that javax.swing.JMenu is 

mapped to tag and javax.swing.JMenuItem is mapped to tag, then we can declare in CookXml 

that tag inherits tag. tag then inherts the setters for attributes such as "text" and "icon" 

of the tag. 

Polymorphisms of OOP can be mirrored in XML tag inheritance as well. Class casting is similar to dynamically 

renaming the current namespace and the tag of the element being processed. 

XML tag inheritance is a methodology not present in any other XML data binding tools. This feature is immensely 

useful in mapping XML documents to classes with deep inheritance hierarchy, typically found in GUI API. Thus 

CookXml is useful in writing XUL motors. CookSwing and CookSwt are two such examples for mapping XML 

documents to Swing and SWT classes. 

Namespace Handling 

Since version 3.0, CookXml is capable of dealing XML documents with multiple namespaces. For backward 

compatibility, CookXml also parse XML documents without namespaces or partially utilizing namespaces. 

Other Implementation Details 

As of version 3.0, CookXml operates on top of XML DOM tree to map an XML document to objects. This feature 

allows developers to utilize XML schema if such exist to verify the incoming XML documents. On the other hand, 

the memory consumption for a large XML document can be problematic.

CookXml 108 

Schema and Documentation Generation 

Since a tag library for CookXml contains all the mappings between an XML element and its corresponding object 

classes, it is entirely possible to use this map to generate documentations from this feature. The documentation 

output can be HTML documents, or XML Schemas. 

CookXmlDoc, a doclet API for CookXml can extract Javadoc tags and comments from the tag library source code. 

The resulting information can in turn be used by an HTML doclet can then generate the appropriate tag 

documentations. See CookSwing Tag Documentation [1] for an example. 

Future Work 

Streaming is a key feature that is under consideration. Such capability would reduce the memory consumption due to 

the construction DOM tree as well as improving the overall performance. 

See also 

• CookSwing 


• CookXml Home Page [2] 

• CookSwing: XML to Swing GUI [3] 

• CookSwt: XML to SWT GUI [4] 

References 

[1] http:/ / cookxml. yuanheng. org/ cookswing/ tagdoc/ 

[2] http:/ / cookxml. yuanheng. org/ 

[3] http:/ / cookxml. yuanheng. org/ cookswing/ 

[4] http:/ / cookxml. yuanheng. org/ cookswt/

Cougaar 109 

Cougaar 

Cougaar is a Java-based architecture for the construction of large-scale distributed multi-agent systems. Cougaar is 

the product of multi-year DARPA research projects ALP [1] and Ultra*Log. [2] 

Cougaar is open source and includes not only the core runtime framework, but also a variety of demonstration, 

visualization, and management components to simplify the development of complex, distributed applications. 

Cougaar is an abbreviation, of sorts, for "Cognitive Agent Architecture". 


• Cougaar Project Webpage [3] 

References 

[1] Adalı, S. and Pigaty, L. 2003. The DARPA Advanced Logistics Project. Annals of Mathematics and Artificial Intelligence 37, 4 (Apr. 2003) 

(http:/ / www. springerlink. com/ content/ r4007674t7127781) 

[2] Todd Carrico and Mark Greaves "Agent Applications in Defense Logistics" Chapter in "Defence Industry Applications of Autonomous 

Agents and Multi-Agent Systems", Springer 2008 (http:/ / www. springerlink. com/ content/ k6x53g3527606726) 

[3] http:/ / www. cougaar. org

Deterministic Parallel Java 110 

Deterministic Parallel Java 

OS Cross-platform 

Website http:/ / dpj. cs. uiuc. edu 

Deterministic Parallel Java (DPJ) is an extension of the Java programming language which adds parallel constructs 

that provide a deterministic programming model for object-oriented languages. The language extensions define a 

type system that a programmer (or interactive porting tool) can use to annotate Java code with type information, and 

a compiler can use to type-check that a DPJ program has deterministic semantics, i.e., produces the same visible 

output for a given input, in all executions. Parallel algorithms that cannot be expressed entirely in the statically 

checked type system require run-time mechanisms to enforce determinism: two key research goals are to make the 

type system more expressive and to minimize the need to fall back to run-time techniques. With minor 

modifications, language extensions should be applicable to other base OO languages, such as C++ and C#. 

This work is funded by NSF grants CSA 07-02724 and CNS 07-20772, and by Intel and Microsoft through the 

UPCRC Illinois. 


• The Deterministic Parallel Java Website [1] 

References 

[1] http:/ / dpj. cs. uiuc. edu 

Devoxx 

Devoxx (formerly named JavaPolis) is an annual European Java 

conference organized by the Belgian Java User Group (BeJUG). 

The conference takes place every year around December. [1] With 

over 2,800 attendees in 2006, JavaPolis became the biggest 

vendor-independent Java conference in the world. [1] In 2008, the 

conference was renamed Devoxx. 

Location 

Devoxx takes place in the second-biggest European cinema 

complex, the MetroPolis, located in Antwerp, Belgium. As a 

JavaPolis 2006 

result, the speakers' video and slides are projected on the huge cinema screens using the available THX audio setup.

Devoxx 111 

Related links 

• Devoxx home page [2] 

• The JavaPolis home page [3] 

• the Belgian Java User Group home page [4] 

• Parleys.com hosts the JavaPolis (video) presentations [5] 

References 

Cinema screens 

[1] Case Study: JavaPolis at atlassian.com (http:/ / www. atlassian. com/ software/ confluence/ casestudies/ javapolis. jsp) 

[2] http:/ / www. devoxx. com 

[3] http:/ / www. javapolis. com 

[4] http:/ / www. bejug. org 

[5] http:/ / www. parleys. com 

Doclets 

Doclet programs work with the Javadoc tool to generate documentation from code written in Java. 

Doclets are written in the Java programming language and use the doclet API to: 

• Select which content to include in the documentation. 

• Format the presentation of the content. 

• Create the file that contains the documentation. 

The standard doclet included with Javadoc generates API documentation as frame-based HTML files. Many 

non-standard doclets are available on the web, often for free. These can be used to: 

• Create other non-API types of documentation. 

• Output the documentation to other non-HTML file types such as PDF. 

• Output the documentation as HTML with additional features such as a search. 


• http:/ / java. sun. com/ j2se/ 1. 4. 2/ docs/ tooldocs/ javadoc/ overview. html


Elastic Path 

Industry Software 

Founded 2000 

Headquarters Vancouver, British Columbia, Canada 

Area served Global 

Products Enterprise Ecommerce Solutions 

Website http:/ / www. elasticpath. com 

Elastic Path Software is a privately-held company that provides enterprise ecommerce solutions. Founded in 2000 by 

Harry Chemko [1] , Mark Williams and Jason Billinglsey [2] , the company provides a Java-based ecommerce 

platform, web hosting, outsourcing, and consulting services. [3] Elastic Path is headquartered in Vancouver, Canada 

with offices in Reading, UK. 

Background 

Elastic Path evolved from a web services business to developing an ecommerce platform. Elastic Path has a client 

base of more than 200 customers worldwide and more than 100 employees at offices in Reading, UK and 

Vancouver, Canada. Elastic Path grew without any outside capital [4] and earned a spot on the PROFIT 100 ranking 

of "Canada's Fastest-growing Companies" two years in a row. [5] 

Clients 

Elastic Path has more than 200 clients worldwide including Vancouver 2010 Winter Olympics [6] and Paralympic 

Games [7] , Virgin Media, Sony Ericsson, and Time Inc. 

Ecommerce blog 

Elastic Path hosts the Get Elastic Blog, providing ecommerce trends and best practice advice. Get Elastic was ranked 

as the #1 ecommerce blog in the world by AdAge Power 150. [8] 


• Elastic Path Official Website [9] 

• Get Elastic eCommerce blog [10] 

• Elastic Path's GREP Developer Community [11] 

• The Globe and Mail features Elastic Path's Founder: Harry Chemko. March 17, 2010. Retrieved March 31, 2010 

[12] 

• Branham Group Inc announces Elastic Path as One of the Top 10 Growth Companies of 2009. April 1, 2010. 

Retrieved April 8, 2010 [13] 

• The Vancouver Courier features Elastic Path as the Vancouver 2010 Olympic Online Store Operator. February 

24, 2010. Retrieved April 8, 2010 [14] 

• The Globe and Mail notes Elastic Path as a Creative and Effective Workplace. February 22, 2010. Retrieved April 

8, 2010 [15] 

• E-Commerce Times interviews Elastic Path's Director of Ecommerce Research, Linda Bustos, on Tips for 

E-Commerce-Challenged Telcos. December 7, 2009. Retrieved April 8, 2010 [16]


References 

[1] http:/ / list. canadianbusiness. com/ rankings/ profit100/ 2009/ communication/ article. aspx?id=20090601_30009_30009 Profit. June 1, 2009. 

retrieved March 31, 2010 

[2] http:/ / www. bdc. ca/ en/ about/ mediaroom/ news_releases/ 2008/ 2008102111. htm?cookie_test=1 BDC. October 21, 2008. retrieved April 

13, 2010 

[3] http:/ / www. financialpost. com/ small-business/ succession/ story. html?id=1626778 Financial Post. May 25, 2009. Retrieved March 31, 

2010 

[4] http:/ / www. techvibes. com/ blog/ elastic-path-growing-and-hiring-despite-recession. Techvibes. May 7, 2009. Retrieved March 31, 2010 

[5] http:/ / www. canadianbusiness. com/ profit_magazine/ press_room/ article. jsp?content=20090603_122513_6692 Profit. July 3, 2090. 

Retrieved March 31, 2010 

[6] http:/ / www. theglobeandmail. com/ report-on-business/ article977315. ece Globe and Mail. March 23, 2009. Retrieved March 31, 2010 

[7] http:/ / www. bivinteractive. com/ index. php?option=com_content& task=view& id=2272& Itemid=30 Business in Vancouver. March 3, 

2010. Retrieved March 31, 2010 

[8] http:/ / adage. com/ power150/ AdAge Power 150. Retrieved April 8, 2010 

[9] http:/ / www. elasticpath. com/ 

[10] http:/ / www. getelastic. com/ 

[11] http:/ / grep. elasticpath. com/ index. jspa 

[12] http:/ / www. theglobeandmail. com/ report-on-business/ your-business/ grow/ harry-chemko/ article1502194/ 

[13] http:/ / www. branham300. com/ index. php?year=2010& listing=14 

[14] http:/ / www2. canada. com/ vancouvercourier/ news/ story. html?id=403693d8-4ecd-419f-9013-2dc5a9bacc42 

[15] http:/ / m. theglobeandmail. com/ report-on-business/ managing/ weekend-workout/ workplace-creativity-shrivels-on-the-vine/ 

article1474956/ ?service=mobile 

[16] http:/ / www. ecommercetimes. com/ story/ Tips-for-E-Commerce-Challenged-Telcos-68822. html?wlc=1270764587 

Electronic Disturbance Theater 

The Electronic Disturbance Theater (EDT) formed in 1997, by performance artist and published writer Ricardo 

Dominguez, is a small company of cyber activists and performance artists who engage in the development in both 

the theory and practice of non-violent acts of defiance. Instead of showing their views in person on the streets, the 

EDT would create a program to allow Electronic Civil Disobedience (ECD) called FloodNet a form of hacktivism 

which would help create the simulation of a sit-in protest over the internet simply known as a virtual sit-in 

demonstration to disrupt their oppressors, but overloading their computer networks and servers. The Electronic 

Disturbance Theater group have the belief that that the Internet should not be used purely as a means for 

communication and data exchange. Instead it should be a forum for direct action as well. 

Richard Dominguez, Brett Stabaum, Stefan Wray, and Carmin Krarasic would be collectively known as The 

Electronic Disturbance Theatre or EDT for short. Taking the idea of the American Civil Rights Movement of the 

1960s, the EDT’s members would avoid using the real names and created aliases to cover their identities. As a 

collective group they organise and program computer software to show their views against anti-propagandist and 

military actions, and begin mobilizing micro-networks to act in solidarity by staging virtual sit-ins on-line and 

allowing the emergence of a collective presence in direct digital actions. 

FloodNet 

Their objective was with the use of digital media and internet based technology, to cause online civil disobedience in 

support of the Zapatista rebels residing in the state of Chiapas in Mexico. EDT uses both electronic mail aka e-mail 

and the internet to promote their work around the world, encouraging fellow supporters to download and run a 

HTML (Hyper Text Makeup Language) and Java applet, (a internet program used to help support interactive web 

based features or programs that a HTML cannot provide alone), based tool called FloodNet a computer based 

program, created by members of the Electronic Disturbance theater company Carmin Krarasic and Brett Stabaum. 

The FloodNet program would simply reload a Uniform Resource Locator or URL for short several times; effectively 

slowing the website and network server down, if a high number of protesters were to join in the sit-in at one time.


The EDT would first execute the FloodNet software in what would be for them a dress rehearsal before attacking 

their main targets on April 10 and a month later 1998, on both Mexican and American government websites, 

representing both the Mexican President Ernesto Zedillo and American President Bill Clinton. 

The Flood Net would work on this basic idea taken from street theatre practices and political rallies and protest but 

instead present it on a much larger and international stage, with the facilitation of macro-networks and non-digital 

forms of action. 

The EDT’s mission was to allow the voices of the Zapatista to be heard, after the attack of the small remote village of 

Acteal in Chiapas, Mexico. The Paramilitary a government funded military squad would surround a catholic church 

during a Tsotsil Mayan, (a spoken Mexican language from around the Chiapas area of Mexico), for the next several 

hours the Paramilitary would shot everyone to death. those inside the church and any which tried to escape resulting 

in the death of fifteen children, nine men, and twenty one women, four of which were pregnant at the time on 

December 22, 1997. This event would become known as the Acteal Massacre. Those who were convicted of this 

crime were later released in the Supreme Court to the outrage of many, after ignoring eye witness reports and 

allowing those that confessed to this crime on humanity. Instead the Supreme Court forcing on the mismanagement 

of the investigation and the fabrication of evidence. 

The Electronic Disturbance Theater took notice of these actions, when others did not and arranged their first act of 

Electronic Civil Disobedience against the Mexican Government. Those that had downloaded the FloodNet program 

in support of the Zapatista’s were asked the input the names repetitively of those that had lost their life’s at the hands 

of the Mexican Army in military attacks. This would then target the servers to return an error message each time 

these URL’s would be requested. This data request would then be stored on a server’s error log and in the eyes of the 

Zapatista and the Electronic Disturbance Theater group, a symbolical list of those forty five Acteal civilians that had 

died straight to their murderers. If enough people were to use the FloodNet applet, this would cause the computer 

server running the website to overload, so that when a regular visitor or somebody working within the site was to try 

and access the website or send company based emails and files, the pages would ether load extremely slowly or not 

at all. Working off the same basis of a real sit-in demonstration, where the protestors block the entrance to a public 

building of their oppressors and preventing access to the building. 

With around twenty five percent of the world’s population, in one way or another connected to the World Wide Web, 

with the use of dial-up internet connection, wired or wireless internet broadband connection and even mobile internet 

technology, everyone of these means of communication can allow the internet to be used as a means of non-violent 

action within our Human Rights, and is viewable around the world, and can be translated into different languages but 

most importantly not controlled by the government. The EDT networked performances have already opened access 

and communication between three unlikely micro-networks: net.art, net.activism, and net.hackers, with technology 

always evolving their no telling how these areas will grow. 

However June 10, 1998, the EDT would strike the Mexican Secretaria de Gobernacion, (Secretary of Government), 

which is involved in immigration policies as well as Mexico’s federal public security forces working in conjunction 

with the military against Zapatista communities in Chiapas unsuccessfully. The Mexican government would have a 

programmed countermeasure in place. This is what the EDT believe took place. A countermeasure was built into the 

operating Java script was placed in the Secretaria de Gobernacion’s website that was designed to activate whenever 

FloodNet was directed toward its servers. Upon activation, the website would open window after window on the 

FloodNet user’s internet browser. If the FloodNet user remained connected long enough, their browser whether it is 

Netscape, Firefox or Internet Explorer, could crash the activist's computer, forcing the activist to reboot their system 

stopping the FloodNet program at the source. The EDT has now since dealt with both the Mexican Government both 

online and offline, and the United States Department of Defence, who has now inserted a counter attack system into 

their Internet Browser based coding to prevent anymore FloodNet based attacks to the system and server. 

The FloodNet system would be used again against the World Trade Organization in 1999, where the group would 

release their online civil disobedience software to the public under the name ‘’Zapatista Disturbance Development’s


Kit.’’ 

Cyber Terrorism? 

The Electronic Disturbance Theater has and will remain a heated topic of debate, within its area of political up rise, 

civil disobedience, hacktivism, and to a much larger scale extremes acts of cyber terrorism. Many people do have the 

right and believe in free speech. The FloodNet programs does allow this in a safer way to the protestors, (as their real 

identities can be hidden under their user names.), allowed people around the world to express their views on the 

subject without travelling to the protest rallies and provide a non-violent way to be heard in the form of these sit-in 

demonstrations, however this causes incorrect actions that block bandwidth, and the internet should be open for 

everybody no matter what their political views. The Virtual Republic representatives view this blocking of 

communications and data as an act of cyber terrorism. They believe the system should be open for all internet users, 

and be accessible with a simple point then click and to those individuals or groups should be banned. Protestors are 

asked to protest outside of their oppressors location, with signs and don’t interact with the business inside which with 

the blocking of communication and data the EDT are doing. Against such self-evident truths, the digital agit-prop 

actions of EDT call for the right to block data in the struggle for the development of democracy and human rights. 


• ECD [1] 

• EDTECD [2] 

• On Electronic Civil Disobedience [3] 

• Digital Zapatismo [4] 

• The Acteal Massacre - Chiapas Mexico - December 22, 1997 [5] 

• Electronic Disturbance Theater [6] 

• Electronic Disturbance Theater [7] 

• The Zapatista Tactical FloodNet [8] 

• FloodNet Foyer [9] 

References 

[1] http:/ / www. thing. net/ ~rdom/ ecd/ ecd. html 

[2] http:/ / www. thing. net/ ~rdom/ ecd/ EDTECD. html 

[3] http:/ / www. thing. net/ ~rdom/ ecd/ oecd. html 

[4] http:/ / www. thing. net/ ~rdom/ ecd/ DigZap. html 

[5] http:/ / www. libertadlatina. org/ Crisis_Mexico_Chiapas_Acteal_Massacre. htm 

[6] http:/ / wiki. brown. edu/ confluence/ display/ MarkTribe/ Electronic+ Disturbance+ Theater 

[7] http:/ / digitalarts. lcc. gatech. edu/ unesco/ internet/ artists/ int_a_edtheater. html 

[8] http:/ / www. thing. net/ ~rdom/ ecd/ ZapTact. html 

[9] http:/ / www. thing. net/ ~rdom/ zapsTactical/ foyer3. htm


Event dispatching thread 

The event dispatching thread (EDT) is a background thread used in Java to process events from the Abstract 

Window Toolkit (AWT) graphical user interface event queue. These events are primarily update events that cause 

user interface components to redraw themselves, or input events from input devices such as the mouse or keyboard. 

The AWT uses a single-threaded painting model in which all screen updates must be performed from a single thread. 

The event dispatching thread is the only valid thread to update the visual state of visible user interface components. 

Updating visible components from other threads is the source of many common bugs in Java programs that use 

Swing [1] . 

Swing and thread safety 

Most AWT and Swing object methods are not thread safe: invoking them from multiple threads risks thread 

interference or memory consistency errors [2] [3] . To avoid these problems, Swing standards states that all user 

interface components should be created and accessed only from the AWT event dispatch thread. A popular 

third-party Look and Feel named Substance [4] goes as far as to refuse to instantiate any Swing component off of the 

Event Dispatch Thread [5] , to prevent coders from making such a mistake. 

Executing code in the EDT 

Other application threads can execute code in the event dispatching thread by defining the code in a Runnable object 

and pass it to the SwingUtilities helper class or to the EventQueue. Two methods of these classes allow: 

• synchronous code execution (SwingUtilities.invokeAndWait(Runnable) or 

EventQueue.invokeAndWait(Runnable)) 

• and asynchronous code execution (SwingUtilities.invokeLater(Runnable) or EventQueue.invokeLater(Runnable)) 

from the EDT. 

The method invokeAndWait() should never be called from the event dispatching thread—it will throw an exception. 

The method SwingUtilities.isEventDispatchThread() or EventQueue.isDispatchThread() can be called to determine 

if the current thread is the event dispatching thread. 

Another solution for executing code in the EDT is using the worker design pattern. The SwingWorker class, 

developed by Sun Microsystems, is an implementation of the worker design pattern, and as of Java 6 is part of 

standard Swing distribution. The open source project Foxtrot [6] provides another synchronous execution solution 

similar to SwingWorker. 

See also 

• Abstract Window Toolkit (AWT) 

• Swing (Java) 

• SwingWorker 

• BackgroundWorker, an equivalent .NET Framework class for SwingWorker 


• javax.swing (Swing API Javadoc documentation) 

• java.awt (AWT API Javadoc documentation) 

• Swing API documentation [7] 

• AWT API documentation [8] 

• The Event-Dispatching Thread [9]


• SwingWorker [10] description from the Swing tutorial 

• AWT/Swing event handling [11] article about event pumping, dispatch and processing, and the EDT 

• Foxtrot project home page [6] 

• Spin project home page [12] 

References 

[1] This problem is not specific to Java Swing. There is the same issue in most Widget toolkits, as for example Windows Forms, where the 

BackgroundWorker class performs the same purpose as SwingWorker in Java. 

[2] "The Event Dispatch Thread" (http:/ / java. sun. com/ docs/ books/ tutorial/ uiswing/ concurrency/ dispatch. html). Sun Microsystems. . 


[3] http:/ / weblogs. java. net/ blog/ alexfromsun/ archive/ 2005/ 11/ debugging_swing_1. html 

[4] https:/ / substance. dev. java. net/ 

[5] http:/ / www. pushing-pixels. org/ ?p=368 

[6] http:/ / foxtrot. sourceforge. net/ 

[7] http:/ / java. sun. com/ javase/ 6/ docs/ technotes/ guides/ swing 

[8] http:/ / java. sun. com/ javase/ 6/ docs/ technotes/ guides/ awt 

[9] http:/ / java. sun. com/ docs/ books/ tutorial/ uiswing/ misc/ threads. html#EDT 

[10] http:/ / java. sun. com/ docs/ books/ tutorial/ uiswing/ misc/ threads. html#SwingWorker 

[11] http:/ / tech. stolsvik. com/ 2009/ 03/ awt-swing-event-pumping-and-targeting. html 

[12] http:/ / spin. sourceforge. net/

Facelets 118 

Facelets 

Stable release 1.1.15 / November 24, 2009 

Preview release 1.2-dev / November 10, 2006 


Operating 

system 


Size 5.07 MB (archived) 

Type Web Framework 


Website http:/ / facelets. dev. java. net/ 

Facelets is an open source web framework under the Apache license and the default view handler technology (aka 

view declaration language) for JavaServer Faces (JSF). The framework requires valid input XML documents to 

work. Facelets supports all of the JSF UI components and focuses completely on building the JSF component tree, 

reflecting the view for a JSF application. 

Although both JSP and JSF technologies have been improved to work better together, Facelets eliminates the issues 

noted in Hans Bergsten's article "Improving JSF by Dumping JSP" [1] 

Facelets is similar enough to Apache Tapestry to draw comparison. In fact, Tapestry was well ahead of its time when 

it first came out , and Facelets does draw on some of its ideas. The project is conceptually similar to Tapestry's, 

which uses the jwcid attribute, while Facelets uses the jsfc attribute combined with proper namespaces to convert 

HTML elements into the corresponding JSF components. Also, there are some similarities to the Tiles framework 

regarding support templating as well as composition. 

Initially, Facelets was available as a separate, alternative view declaration language for JSF 1.1 and JSF 1.2 which 

both used JSP as the default view declaration language. Starting from JSF 2.0, Facelets has been promoted as the 

default, and JSP has been deprecated as a legacy fall back [2] . 

Example 

The following example shows an XHTML template for taking the use of Facelets component-aliasing. The jsfc 

attribute is used here, shows which tags to replace when compiling the page with the corresponding JavaServer 

Faces components. 

 

 

 

 

 

 

 

 

 

Facelets 119 

The above code can be viewed in a browser, and edited with conventional WYSIWYG design tools. This is not 

possible with regular JSF 1.2 pages (shown below the same functionality). 

 

 

 

 

 

 

 

 

 

 

See also 

• JavaServer Faces 

Bibliography 

• Wadia, Zubin; Marinschek, Martin; Saleh, Hazem; Byrne, Dennis (September 22, 2008), The Definitive Guide to 

Apache MyFaces and Facelets [3] (1st ed.), Apress, pp. 400, ISBN 978-1590597378 

• Wadia, Zubin; Aranda, Bruno (May 26, 2008), Facelets Essentials: Guide to JavaServer Faces View Definition 

Framework [4] (1st ed.), Apress, pp. 84, ISBN 978-1430210498 


• Facelets Home Page [5] 

• Facelets compared to Tiles [6] 

• Facelets Developer Documentation [7] 

References 

[1] Hans Bergsten (June 6, 2004). "Improving JSF by Dumping JSP" (http:/ / onjava. com/ pub/ a/ onjava/ 2004/ 06/ 09/ jsf. html). O'Reilly 

Media. . 

[2] JavaServer Faces 2.0, The Complete Reference by Ed Burns and Chris Schal, page 55: 'The expert group decided to move forward with 

Facelets as the basis for new features while letting JSP remain as a backward compatibility layer'. 

[3] http:/ / www. apress. com/ book/ view/ 9781590597378 


[5] https:/ / facelets. dev. java. net/ 

[6] http:/ / www. ibm. com/ developerworks/ java/ library/ j-facelets/ 

[7] https:/ / facelets. dev. java. net/ nonav/ docs/ dev/ docbook. html


final (Java) 

In the Java programming language, the final keyword is used in several different contexts to define an entity which 

cannot later be changed. 

Final classes 

A final class cannot be subclassed. This is done for reasons of security and efficiency. Accordingly, many of the 

Java standard library classes are final, for example java.lang.System and java.lang.String. All methods in a final 

class are implicitly final. 

Example: 

public final class MyFinalClass {...} 

Restricted subclassers are often referred to as "soft final" classes. [1] 

Final methods 

A final method cannot be overridden by subclasses. This is used to prevent unexpected behavior from a subclass 

altering a method that may be crucial to the function or consistency of the class. [2] 

Example: 

public class MyClass { 

} 

public final void myFinalMethod() {...} 

A common misconception is that declaring a class or method final improves efficiency by allowing the compiler to 

directly insert the method inline wherever it is called. This is not completely true; the compiler is unable to do this 

because the classes loaded at runtime might not be the same versions of the ones that were just compiled. Further, 

the runtime environment and JIT compiler have the information about exactly what classes have been loaded, and 

are able to make better decisions about when to inline, whether or not the method is final. [3] 

Final variables 

A final variable can only be assigned once. This assignment does not grant the variable immutable status. If the 

variable is a field of a class, it must be assigned in the constructor of its class. (Note: If the variable is a reference, 

this means that the variable cannot be re-bound to reference another object. But the object that it references is still 

mutable, if it was originally mutable.) 

Unlike the value of a constant, the value of a final variable is not necessarily known at compile time. 

Example: 

public class Sphere { 

public static final double PI = 3.141592653589793; // this is 

essentially a constant 

public final double radius; 

public final double xpos; 

public final double ypos; 

public final double zpos;


} 

Sphere(double x, double y, double z, double r) { 

} 

[...] 

radius = r; 

xpos = x; 

ypos = y; 

zpos = z; 

Any attempt to reassign radius, xpos, ypos, zpos will meet with a compile error. In fact, even if the constructor 

doesn't set a final variable, attempting to set it outside the constructor will result in a compile error. 

To illustrate that finality doesn't guarantee immutability: suppose we replace the three position variables with a 

single one: 

public final Position pos; 

where pos is an object with three properties pos.x, pos.y and pos.z. Then pos cannot be assigned to, but the three 

properties can, unless they are final themselves. 

Like full immutability, finality of variables has great advantages, especially in optimization. For instance, Sphere 

will probably have a function returning its volume; knowing that its radius is constant allows us to memoize the 

computed volume. If we have relatively few Spheres and we need their volumes very often, the performance gain 

might be substantial. Making the radius of a Sphere final informs developers and compilers that this sort of 

optimization is possible in all code that uses Spheres. 

Blank final 

The blank final, which was introduced in Java 1.1, is a final variable whose declaration lacks an initializer. [4] [5] A 

blank final can only be assigned to once and it must be definitely unassigned when an assignment occurs. In order to 

do this, a Java compiler runs a flow analysis to ensure that, for every assignment to a blank final variable, the 

variable is definitely unassigned before the assignment; otherwise a compile-time error must occur. [6] 

In general, a Java compiler will ensure that the blank final is not used until is assigned a value and that once assigned 

a value, the now final variable cannot be reassigned another value. [7] 

Difference from the C++ "const" type qualifier 

• In C++, a const field is not only protected from being reassigned, but there is the additional limitation that only 

const methods can be called on it and it can only be passed as the const argument of other methods. 

• Non-static inner classes can freely access any field of the enclosing class, final or not. 


• Its Time To Deprecate Final [8] 

• The Final Word On the final Keyword by Renaud Waldura [9]


References 

[1] "How to Use the Eclipse API" (http:/ / www. eclipse. org/ articles/ article. php?file=Article-API-Use/ index. html). The Eclipse Foundation.. 

2010. . Retrieved 23 July 2010. 

[2] Writing Final Classes and Methods (http:/ / java. sun. com/ docs/ books/ tutorial/ java/ IandI/ final. html) 

[3] Java theory and practice: Is that your final answer? (http:/ / www. ibm. com/ developerworks/ java/ library/ j-jtp1029. html) 

[4] Flanagan, David (May 1997). "Chapter 5 Inner Classes and Other New Language Features:5.6 Other New Features of Java 1.1" (http:/ / web. 

deu. edu. tr/ doc/ oreily/ java/ javanut/ ch05_06. htm). Java in a Nutshell (2nd Edition ed.). O'Reilly. ISBN 1-56592-262-X. . 

[5] "Types, Values, and Variables" (http:/ / java. sun. com/ docs/ books/ jls/ second_edition/ html/ typesValues. doc. html). Java Language 

Specification Chapter 4. Sun Microsystems, Inc. 2000. . Retrieved 23 July 2010. 

[6] "Definite Assignment" (http:/ / java. sun. com/ docs/ books/ jls/ second_edition/ html/ defAssign. doc. html). Java Language Specification. 

Sun Microsystems, Inc.. 2000. . Retrieved 23 July 2010. 

[7] Pattis, Richard E.. "More Java" (http:/ / www. cs. cmu. edu/ ~pattis/ 15-1XX/ 15-200/ lectures/ morejava/ lecture. html). Advanced 

Programming/Practicum 15-200. School of Computer Science Carnegie Mellon University. . Retrieved 23 July 2010. 

[8] http:/ / butunclebob. com/ ArticleS. MichaelFeathers. ItsTimeToDeprecateFinal 

[9] http:/ / renaud. waldura. com/ doc/ java/ final-keyword. shtml#vars 

FloodNet 

The Zapatista Tactical FloodNet is a Java Applet that assists in the execution of virtual sit-ins by automatically 

reloading the targeted website several times every minute. Additionally, it allows for users to post statements to the 

site by sending them to the server log. 

FloodNet was created by the Electronic Disturbance Theater members Carmin Karasic and Brett Stalbaum. This 

activist group executed FloodNet in April and December 1998 on Mexican and American government sites, 

respectively. 

The FloodNet program will only cause desired effect when thousands of users are logged in simultaneously, where 

all their browsers will automatically reload targeted website and cause desired effect. Desired effect being to cause 

so much traffic inside the server that any other user attempting to log in will not be able to view the website. 


• An explanation of FloodNet [8] 

• The FloodNet Foyer [9]

FormEngine 123 

FormEngine 

Developer(s) 

imatics Software GmbH [1] 

Stable release 1.6.3 / July 14, 2010 



License MIT License 

Website 

FormEngine Home [2] 

The FormEngine is a Java framework for dynamic form creation and complex form processing for web 

applications. 

About 

The primary goal of this framework is to help application developers in two areas of interest: 

1. dynamic creation of form definitions at runtime 

2. a simple albeit powerful way to dynamically process complex calculations and validations of form input (user 

data) 

Characteristics 

The FormEngine framework is build for use in available (or new) Java web application projects. It can be integrated 

with a few easy steps into a servlet container. 

Form processing occurs in form sessions that bind data processing abilities along with the snapshot of the current 

data model to the task that's been initiated by a user/client. A form session manages a form instance that behaves just 

like described in the form definition. The FormEngine relies on AJAX techniques to allow client-server 

communication during a form session. 

Calculations and data validation have to be implemented server-side only. Several design patterns aim for 

minimizing memory needs. Renderers are implemented thread-safe and can be used simultaneously with multiple 

form instances of a single form definition. 

History 

The FormEngine Java framework project started in 2007. It was created to overcome the shortfalls of other web form 

frameworks in several areas. It is used in a business process management suite (*) as a replacement for the Chiba 

Engine, a form framework to process XForms definitions. The FormEngine framework was first released for open 

use under a modified MIT license in december 2009. 

Articles and further information 

Several articles have been posted about the FormEngine Java framework, such as "FormEngine : Multidynamische 

Formulare" (german) [3] . 

For further information see External links.

FormEngine 124 

See also 

• JavaServer Faces 

• XForms 

• Google Web Toolkit 


• form-engine.de Home [2] 

• FormEngine example page [4] 

• Chiba Engine Home [5] 

• imatics ProcessSuite [6] - A business process management suite that makes use of the FormEngine framework 

References 

[1] http:/ / www. imatics. de 

[2] http:/ / www. form-engine. de/ en/ index. jsp 

[3] Java Magazine (2010), " it-republik.de (http:/ / it-republik. de/ jaxenter/ artikel/ FormEngine-Multidynamische-Formulare-2893. html)". 

FormEngine: Multidynamische Formulare 

[4] http:/ / www. form-engine. de/ en/ examples/ examples. jsp 

[5] http:/ / chiba-project. org/ chiba/ 

[6] http:/ / www. processsuite. de/ langen/ index. html 

Generics in Java 

Generics are a facility of generic programming that was added to the Java programming language in 2004 as part of 

J2SE 5.0. They allow "a type or method to operate on objects of various types while providing compile-time type 

safety." [1] 

Hierarchy and classification 

As per Java Language Specification [2] : 

• A type variable is an unqualified identifier. Type variables are introduced by generic class declarations, generic 

interface declarations, generic method declarations, and by generic constructor declarations. 

• A class is generic if it declares one or more type variables. These type variables are known as the type parameters 

of the class. It defines one or more type variables that act as parameters. A generic class declaration defines a set 

of parameterized types, one for each possible invocation of the type parameter section. All of these parameterized 

types share the same class at runtime. 

• An interface is generic if it declares one or more type variables. These type variables are known as the type 

parameters of the interface. It defines one or more type variables that act as parameters. A generic interface 

declaration defines a set of types, one for each possible invocation of the type parameter section. All 

parameterized types share the same interface at runtime. 

• A method is generic if it declares one or more type variables. These type variables are known as the formal type 

parameters of the method. The form of the formal type parameter list is identical to a type parameter list of a class 

or interface. 

• A constructor can be declared as generic, independently of whether the class the constructor is declared in is itself 

generic. A constructor is generic if it declares one or more type variables. These type variables are known as the 

formal type parameters of the constructor. The form of the formal type parameter list is identical to a type 

parameter list of a generic class or interface.


Motivation for generics 

The following block of Java code illustrates a problem that exists when not using generics. First, it declares an 

ArrayList of type Object. Then, it adds a String to the ArrayList. Finally, it attempts to retrieve the added String and 

cast it to an Integer. 

List v = new ArrayList(); 

v.add("test"); 

Integer i = (Integer)v.get(0); // Run time error 

Although the code compiles without error, it throws a runtime exception (java.lang.ClassCastException) when 

executing the third line of code. This type of problem can be avoided by using generics and is the primary motivation 

for using generics. 

Using generics, the above code fragment can be rewritten as follows: 

List v = new ArrayList(); 

v.add("test"); 

Integer i = v.get(0); // (type error) Compile time error 

The type parameter String within the angle brackets declares the ArrayList to be constituted of String (a descendant 

of the ArrayList's generic Object constituents). With generics, it is no longer necessary to cast the third line to any 

particular type, because the result of v.get(0) is defined as String by the code generated by the compiler. 

Compiling the third line of this fragment with J2SE 5.0 (or later) will yield a compile-time error because the 

compiler will detect that v.get(0) returns String instead of Integer. For a more elaborate example, see [3] . 

Here is a small excerpt from the definitions of the interfaces List and Iterator in package java.util: 

public interface List { 

} 

void add(E x); 

Iterator iterator(); 

public interface Iterator { 

} 

E next(); 

boolean hasNext(); 

Wildcards 

Generic type parameters in Java are not limited to specific classes. Java allows the use of wildcards to specify 

bounds on the type of parameters a given generic object may have. Wildcards are type parameters of the form "?", 

possibly annotated with a bound. Given that the exact element type of an object with a wildcard is unknown, 

restrictions are placed on the type of methods that may be called on the object. 

As an example of an unbounded wildcard, List indicates a list which has an unknown object type. Methods 

which take such a list as an argument can take any type of list, regardless of parameter type. Reading from the list 

will return objects of type Object, and writing non-null elements to the list is not allowed, since the parameter type is 

not known. 

To specify the upper bound of a generic element, the extends keyword is used, which indicates that the generic type 

is a subtype of the bounding class. Thus it must either extend the class, or implement the interface of the bounding 

class. So List


The use of wildcards above is necessary since objects of one type parameter cannot be converted to objects of 

another parameter. Neither List nor List is a subtype of the other, even though Integer is a 

subtype of Number. So, code that deals with List does not work with List. If it did, it would be 

possible to insert a Number that is not a Integer into it, which violates type safety. Here is a sample code that 

explains the contradiction it brings if List is a subtype of List: 

List ints = new ArrayList(); 

ints.add(2); 

List nums = ints; //valid if List is a subtype of List accordin 

substitution rule. 

nums.add(3.14); 

Integer x=ints.get(1); // now 3.14 is assigned to an Integer variable! 

The solution with wildcards works because it disallows operations that would violate type safety. 

To specify the lower bounding class of a generic element, the super keyword is used. This keyword indicates that the 

aforementioned generic type is a super-type of said bounding class. So, List


Pair grade440 = new Pair("mike", "A"); 

Pair marks440 = new Pair("mike", 100); 

System.out.println("grade: " + grade440); 

System.out.println("marks: " + marks440); 

Generic method definitions 

Here is an example of a generic method using the generic class above: 

public Pair twice(T value) 

{ 

} 

return new Pair(value,value); 

In many cases the user of the method need not indicate the type parameters, as they can be inferred: 

Pair pair = twice("Hello"); 

The parameters can be explicitly added if needed: 

Pair pair = this.twice("Hello"); 

Note that you cannot use native types, ex: 

Pair pair; // this fails. You have to use Integer instead. 

Generics in throws clause 

Although exceptions themselves cannot be generic, generic parameters can appear in a throws clause: 

public void throwMeConditional 

{ 

} 

(boolean conditional, T exception) throws T 

if(conditional) 

throw exception; 

Type erasure 

Generics are checked at compile-time for type-correctness. The generic type information is then removed in a 

process called type erasure. For example, List will be converted to the non-generic type List, which can 

contain arbitrary objects. The compile-time check guarantees that the resulting code is type-correct. 

As a result of type erasure, type parameters cannot be determined at run-time. For example, when an ArrayList is 

examined at runtime, there is no general way to determine whether, before type erasure, it was an 

ArrayList or an ArrayList. Many people are dissatisfied with this restriction [5] . There are partial 

approaches. For example, individual elements may be examined to determine the type they belong to; for example, if 

an ArrayList contains an Integer, that ArrayList was presumably parameterized with Integer. Reflection can also 

determine the type parameter. However, no approach works in all cases. 

Demonstrating this point, the following code outputs "Equal": 

ArrayList li = new ArrayList(); 

ArrayList lf = new ArrayList(); 

if (li.getClass() == lf.getClass()) // evaluates to true


System.out.println("Equal"); 

Java generics differ from C++ templates. Java generics generate only one compiled version of a generic class or 

function regardless of the number of parameterizing types used. Furthermore, the Java run-time environment does 

not need to know which parameterized type is used because the type information is validated at compile-time and is 

not included in the compiled code. Consequently, instantiating a Java class of a parameterized type is impossible 

because instantiation requires a call to a constructor, which is unavailable if the type is unknown. 

For example, the following code will not compile: 

T instantiateElementType(List arg) 

{ 

} 

return new T(); //causes a compile error 

Because there is only one copy per generic class at runtime, static variables are shared among all the instances of the 

class, regardless of their type parameter. As a result, the type parameter cannot be used in the declaration of static 

variables or in static methods. Static variables and static methods are "outside" of the scope of the class's 

parameterized types. 

See also 

• Generic programming 

• Java 

• Comparison of C# and Java 



• Lesson: Generics [6] at The Java Tutorials 

• Generics [7] by Sun Microsystems 

• Wild FJ [8] by Mads Torgersen, Erik Ernst, and Christian Plesner Hansen 

• Java Generics FAQ [5] by Angelika Langer 

• JavaWorld Taming the Tiger [9] Excellent overview. 

• Java Generics Presentation [10] by DevelopIntelligence 

• Java Generics Tutorial [11] by Jakob Jenkov - jenkov.com 

References 

[1] Java Programming Language (http:/ / java. sun. com/ j2se/ 1. 5. 0/ docs/ guide/ language/ index. html) 

[2] Java Language Specification, Third Edition (http:/ / java. sun. com/ docs/ books/ jls/ third_edition/ html/ j3TOC. html) by James Gosling, Bill 

Joy, Guy Steele, Gilad Bracha - Prentice Hall PTR 2005 

[3] http:/ / java. sun. com/ j2se/ 1. 5/ pdf/ generics-tutorial. pdf - Generics in the Java Programming Language 

[4] http:/ / stackoverflow. com/ questions/ 156275/ what-is-the-equivalent-of-the-c-pairl-r-in-java 

[5] Gafter, Neal (2006-11-05). "Reified Generics for Java". 

[6] http:/ / java. sun. com/ docs/ books/ tutorial/ java/ generics/ index. html 

[7] http:/ / java. sun. com/ j2se/ 1. 5. 0/ docs/ guide/ language/ generics. html 

[8] http:/ / homepages. inf. ed. ac. uk/ wadler/ fool/ program/ 14. html 

[9] http:/ / www. javaworld. com/ javaworld/ jw-06-2004/ jw-0607-tiger2. html 

[10] http:/ / www. developintelligence. com/ learn/ tutorials. php 

[11] http:/ / tutorials. jenkov. com/ java-generics/ index. html

G-java 129 

G-java 

G-java 2.x was a cross-platform game/software Java-based compiler for G-Creator. It has since dissolved into 

various projects such as Pineapple and Dolphin, although downloads for it are still around, but unsupported. It ran on 

and created software for any Java supported operating systems such as Microsoft Windows 95+, Mac OS, Linux, 

Unix and Sun Solaris. G-java is made up of two components: the IDE and the API, both of which were originally 

based on Game Maker but have since been modified and became more close to Java's API. 

G-Java API 

The G-java API is a java API for creating games and other software based on the Game Maker Language used in 

Game Maker. This allows Game Maker developers to quickly learn Java, while also giving Java programmers a lot 

of useful functions for game or software development. So far, the G-java API is still in an alpha stage, but the 

JavaDocs can already be viewed: G-java API javadoc [1] 

History 

Originally G-java was a Game Maker to Java converter application written by TGMG(lead developer), IsmAvatar 

(optimization), and BZGaming (programmed some functions) in the Java programming language. It was first 

released in December 2004. It is designed to allow its users to easily develop multi-platform Java computer games 

without learning the Java language. However with the release of Game Maker 7 (G-java was at version 1.08 beta 8 

and supported many of GM's features), Mark Overmars, the creator of Game Maker, made a public announcement 

that G-Java was now officially disallowed by the new GM7 license agreement: [2], and has also encrypted the GMK 

files (Game Maker 7's saved file) to discourage similar projects. Although Game Maker was originally freeware, it 

switched to shareware by version 5. Conversely, TGMG hopes to improve on Game maker by making G-java2 open 

source. 

G-java used to use .gm6 files created in the Game Maker IDE, and converts them to .jar files which can be executed 

in any Java VM within most modern graphical web browsers. For experienced users, G-java contained a built-in 

scripting programming language called "EGML", or "Extended Game Maker Language". This allow users to create 

programs with Java functions not available in the Game Maker Language. 

G-Java 2.0 was initially supposed to implement the NetBeans source-code to save some work. However, this proved 

to be extremely limited and too big. 

G-Java 2.0 was then renamed to G-Creator, codenamed Aurora(Portuguese word for dawn), and started from the 

beginning - the core. G-java 2.0 became the main compiler of G-Creator, before both projects dissolved altogether. 

G-Java and LateralGM 

The G-Java project's ancestor, Dolphin, is currently being developed as a LateralGM plugin for the same purpose. 


• G-java site [3] - old G-Java website; This is outdated and may be removed soon. 

• G-Creator site [4] - Official G-Creator website. 

• G-java/G-Creator forums [5] - official forums. 

• LateralGM [6] - An open source project affiliated with and similar to G-Java, lead by IsmAvatar.

G-java 130 

References 

[1] http:/ / www. g-java. com/ javadoc/ 

[2] http:/ / forums. gamemaker. nl/ index. php?showtopic=266467& view=findpost& p=1882461 

[3] http:/ / www. g-java. com 

[4] http:/ / www. g-creator. org 

[5] http:/ / forums. g-creator. org/ 

[6] http:/ / www. ismavatar. com/ lgm/ 

GlassFish Metro 

Metro is an opensource web service stack that is a part of the GlassFish project, though it can also be used in a 

stand-alone configuration. [1] Components of metro include JAXB RI, JAX-WS RI, SAAJ RI, SJSXP, and WSIT. It 

is available under the CDDL and GPLv2 (with classpath exception.) [2] 

It is supported by Sun Microsystems. 

History 

Originally, the Glassfish project developed two semi-independent project : 

• JAX-WS RI, the Reference implementation of the JAX-WS specification 

• WSIT, a Java implementation of some of the WS-* and an enhanced support for interoperability with the .NET 

Framework. It is based on JAX-WS RI as "Web Service layer". 

In June 2007, it has been decided to bundle these two components as a single component named Metro[3]. 

Market share 

Metro is bundled with Java SE 6 in order to allow consumers of Java SE 6 to consume Web Services [4] 

Metro is bundled with numerous Application Servers [5] such as : 

• GlassFish 

• Sun Java System Application Server Platform Edition 9.x 

• Oracle WebLogic Server 

• JBoss (as of version 5.x) 

• TmaxSoft JEUS 6.x 

The JAXB reference implementation developed for Metro is used in virtually every Java Web Services framework 

(Apache Axis2, Codehaus XFire, Apache CXF) and Application Servers.

GlassFish Metro 131 

Features 

Metro compares well with other web service frameworks in terms of functionality. A comparison is provided by 

Codehaus at [6], which compares Apache Axis 1.x, Axis 2.x, Celtix, Glue, JBossWS, Xfire 1.2 and JAX-WS RI + 

WSIT (the bundle was not yet named Metro at this time). 

See also 

• Apache CXF 



References 

[1] "metro: Discover Metro" (https:/ / metro. dev. java. net/ discover/ ). . 

[2] "metro: Metro FAQ" (https:/ / metro. dev. java. net/ discover/ faq. html). . 

[3] http:/ / blogs. sun. com/ arungupta/ entry/ announcing_metro_naming_the_web 

[4] https:/ / jax-ws. dev. java. net/ faq/ index. html#different_versions 

[5] http:/ / blogs. sun. com/ theaquarium/ entry/ metro_now_on_tomcat_6 

[6] http:/ / xfire. codehaus. org/ Stack+ Comparison 

[7] https:/ / metro. dev. java. net/


James Gosling 

James Arthur Gosling 

Born May 19, 1955 

near Calgary, Alberta, Canada 

Residence United States 

Nationality Canada 

Alma mater Carnegie Mellon University, University of Calgary 

Occupation Computer Scientist 

Employer None [1] 

Known for Java programming language 

Awards Officer of the Order of Canada 

Website 

James Gosling's weblog [2] 

James A. Gosling, OC (born May 19, 1955 near Calgary, Alberta, Canada) is a software developer, best known as 

the father of the Java programming language. 

Education and career 

In 1977, James Gosling received a B.Sc in Computer Science from the University of Calgary. In 1983, he earned a 

Ph.D in Computer Science from Carnegie Mellon University, and his doctoral thesis was titled "The Algebraic 

Manipulation of Constraints". While working towards his doctorate, he wrote a version of emacs (gosmacs), and 

before joining Sun Microsystems he built a multi-processor version of Unix [3] while at Carnegie Mellon University, 

as well as several compilers and mail systems. 

Between 1984 and 2010, Gosling was with Sun Microsystems. He is known as the father of the Java programming 

language. 

[1] [4] 

On April 2, 2010, Gosling left Sun Microsystems which had recently been acquired by the Oracle Corporation. 

Regarding why he left, Gosling wrote on his blog that "Just about anything I could say that would be accurate and 

honest would do more harm than good."


Contributions 

He is generally credited as the inventor of the Java programming language in 1994. [5] He created the original design 

of Java and implemented its original compiler and virtual machine. For this achievement he was elected to the 

United States National Academy of Engineering. He has also made major contributions to several other software 

systems, such as NeWS and Gosling Emacs. He co-wrote the "bundle" program, a utility thoroughly detailed in 

Brian Kernighan and Rob Pike's book The Unix Programming Environment. 

Honors 

In 2007, he was made an Officer of the Order of Canada. [6] The Order is Canada's highest civilian honour. Officers 

are the second highest grade. 

Books 

• Ken Arnold, James Gosling, David Holmes, The Java Programming Language, Fourth Edition, Addison-Wesley 

Professional, 2005, ISBN 0-321-34980-6 

• James Gosling, Bill Joy, Guy L. Steele Jr., Gilad Bracha, The Java Language Specification, Third Edition, 

Addison-Wesley Professional, 2005, ISBN 0-321-24678-0 

• Ken Arnold, James Gosling, David Holmes, The Java Programming Language, Third Edition, Addison-Wesley 

Professional, 2000, ISBN 0-201-70433-1 

• James Gosling, Bill Joy, Guy L. Steele Jr., Gilad Bracha, The Java Language Specification, Second Edition, 

Addison-Wesley, 2000, ISBN 0-201-31008-2 

• Gregory Bollella (Editor), Benjamin Brosgol, James Gosling, Peter Dibble, Steve Furr, David Hardin, Mark 

Turnbull, The Real-Time Specification for Java, Addison Wesley Longman, 2000, ISBN 0-201-70323-8 

• Ken Arnold, James Gosling, The Java programming language Second Edition, Addison-Wesley, 1997, ISBN 

0-201-31006-6 

• Ken Arnold, James Gosling, The Java programming language, Addison-Wesley, 1996, ISBN 0-201-63455-4 

• James Gosling, Bill Joy, Guy L. Steele Jr., The Java Language Specification, Addison Wesley Publishing 

Company, 1996, ISBN 0-201-63451-1 

• James Gosling, Frank Yellin, The Java Team, The Java Application Programming Interface, Volume 2: Window 

Toolkit and Applets, Addison-Wesley, 1996, ISBN 0-201-63459-7 

• James Gosling, Frank Yellin, The Java Team, The Java Application Programming Interface, Volume 1: Core 

Packages, Addison-Wesley, 1996, ISBN 0-201-63453-8 

• James Gosling, Henry McGilton, The Java language Environment: A white paper [7] , Sun Microsystems, 1996 

• James Gosling, David S. H. Rosenthal, Michelle J. Arden, The NeWS Book : An Introduction to the 

Network/Extensible Window System (Sun Technical Reference Library), Springer, 1989, ISBN 0-387-96915-2



• James Gosling's personal weblog [8] 

• James Gosling's weblog at Sun [9] 

• Presentation [10] by James Gosling about the origins of Java, from the JVM Languages Summit 2008 

• slide show depicting Gosling's life [11] 

References 

[1] "Time to move on..." (http:/ / nighthacks. com/ roller/ jag/ entry/ time_to_move_on). James Gosling's personal blog. . 

[2] http:/ / nighthacks. com/ roller/ jag 

[3] James Gosling mentioned a multiprocessor Unix in his statement during the US vs Microsoft Antitrust DOJ trial in 1998 "DOJ/Antitrust" 

(http:/ / www. usdoj. gov/ atr/ cases/ f2000/ 2049. htm). Statement in MS Antitrust case. US DOJ. . Retrieved 2007-02. 

[4] Father of Java James Gosling quits Oracle (http:/ / opensource. cbronline. com/ news/ father_of_java_james_gosling_quits_oracle_120410) 

[5] "Sun Labs-The First Five Years: The First Fifty Technical Reports. A Commemorative Issue" (http:/ / portal. acm. org/ citation. 

cfm?id=974955& dl=GUIDE& coll=GUIDE& CFID=75229392& CFTOKEN=55758856). Ching-Chih Chang, Amy Hall, Jeanie Treichel. 

Sun Microsystems, Inc.. . Retrieved 2010-02-07. 

[6] Order of Canada announcement (http:/ / www. gg. ca/ media/ doc. asp?lang=e& DocID=4984) 

[7] http:/ / java. sun. com/ docs/ white/ langenv/ 

[8] http:/ / nighthacks. com/ roller/ jag/ 

[9] http:/ / blogs. sun. com/ jag/ 

[10] http:/ / www. infoq. com/ presentations/ gosling-jvm-lang-summit-keynote 

[11] http:/ / www. eweek. com/ c/ a/ Application-Development/ The-Life-and-Times-of-Java-and-James-Gosling-746438/ 

Gray Flimmer 

Gray flimmer(ing) - The constant flashing of a Java applet, usually in animation, with the refresh() method. This 

can usually be avoided by implementation of the update() method or by using the technique of double buffering. The 

singular term 'gray flimmer' refers to a single flash of an image in a Java applet. When gray flimmering occurs, the 

image flashes in such a way that it alternates rapidly between the actual image and a blank gray frame. This is where 

the term 'gray flimmering' originates.

Todd Greanier 135 

Todd Greanier 

Todd Greanier is an author and software architect, widely regarded as an expert in Java programming. [1] [2] He has 

written several books on the subject, including Java Foundations, which is used as a textbook in many college-level 

computer science programs. It has been translated into over forty languages and is the standard text for Java 

programmers in India, Russia, Germany, and South Africa. 

Once a popular instructor for Sun Microsystems, Greanier now works to develop and deliver online training 

programs. He was a frequent contributor to the now defunct New York Sun newspaper, [3] and was co-author (with 

sportswriter Sean Lahman) of three books on professional football. [4] 

Todd is currently working on a book on boxing history and is one of the founders (with Sean Lahman) of Bluebeard 

Publishing. [5] 


• Java Foundations [6] (at Google Books) 

• JavaWorld article on the Java Serialization API [7] 

References 

[1] From Sun Developer Network (http:/ / java. sun. com/ developer/ technicalArticles/ Programming/ serialization/ ) — "Greanier…has been 

teaching and developing Java since it was introduced publicly. An expert in distributed Java technologies, he teaches classes in a wide range 

of topics, including JDBC, RMI, CORBA, UML, Swing, servlets/JSP, security, JavaBeans, Enterprise Java Beans, and multithreading. He also 

creates custom seminars for corporations, slanted to their specific needs." 

[2] Review of Greanier's appearance at Java University. (http:/ / www. onjava. com/ pub/ a/ onjava/ 2002/ 04/ 10/ javau. html) — "Greanier, a 

longtime Java developer and trainer, is an engaging instructor…" 

[3] authors' archive at New York Sun website (http:/ / www. nysun. com/ authors/ Todd+ Greanier) 

[4] Listing of football books at Amazon (http:/ / www. amazon. com/ s/ ref=nb_ss_b?url=search-alias=stripbooks& field-keywords=todd+ 

greanier+ football). 

[5] Bluebeard Publishing website (http:/ / bluebeardpublishing. com/ ). 

[6] http:/ / books. google. com/ books?hl=en& id=vbBXKgDJun0C& dq=todd+ greanier& printsec=frontcover& source=web& 

ots=LeJJ2zpZFA& sig=N34M4CJjzy6bSwojv-Mr6qkppIE& sa=X& oi=book_result& resnum=3& ct=result 

[7] http:/ / www. javaworld. com/ javaworld/ jw-07-2000/ jw-0714-flatten. html


Head First (book series) 

Head First is a series of introductory instructional books to many topics, published by O'Reilly Media. It stresses an 

unorthodox, visually intensive, reader-involving combination of puzzles, jokes, nonstandard design and layout, and 

an engaging, conversational style to immerse the reader in a given topic. 

Originally, the series covered programming and software engineering, but is now expanding to other topics in 

science, mathematics and business, due to success[1]. The series was created by Bert Bates and Kathy Sierra, and 

began with Head First Java in 2003. 

Concept 

The main idea of the series is to effectively stimulate the brain by: [2] 

• Telling stories 

• Visualizing 

• Using attention-grabbing tactics: page layout, non-standard examples, puzzles, jokes, and other means. 

By using metacognition [3] the series' authors and editors try to employ varied methods to present information and 

accelerate the learning process. 

Books 

The official web site for the Head First series has forums for each book as well as code downloads and sample 

chapters. They include: 

• Head First Software Development (ISBN 0-596-52735-7) by Dan Pilone and Russ Miles 

• Head First PMP (ISBN 0-596-10234-8) by Jennifer Greene and Andrew Stellman 

• Head First Object-Oriented Analysis and Design (ISBN 0-596-00867-8) by Brett McLaughlin, Gary Pollice and 

David West 

• Head First Ajax (ISBN 0-596-51578-2) by Rebecca Riordan 

• Head First HTML with CSS & XHTML (ISBN 0-596-10197-X) by Elisabeth Freeman and Eric Freeman 

• Head First Java (ISBN 0-596-00920-8) by Kathy Sierra and Bert Bates 

• Head First Design Patterns (ISBN 0-596-00712-4) by Eric Freeman, Elisabeth Freeman, Kathy Sierra and Bert 

Bates 

• Head First SQL (ISBN 0-596-52684-9) by Lynn Beighley 

• Head First Rails (ISBN 0-596-51577-4) by David Griffiths 

• Head First Servlets & JSPs (ISBN 0-596-51668-1) by Bryan Basham, Kathy Sierra and Bert Bates 

• Head First JavaScript (ISBN 0-596-52774-8) by Michael Morrison 

• Head First PHP & MySQL (ISBN 0-596-00630-3) by Lynn Beighley and Michael Morrison 

• Head First Statistics (ISBN 0-596-52758-6) by Dawn Griffiths 

• Head First iPhone Development (ISBN 0-596-80354-0) by Dan Pilone and Tracey Pilone 

• Head First Programming (ISBN 0-596-80237-4) by Paul Barry and David Griffiths 

The offerings in the Head First series are quickly expanding and also delving into subjects that are not directly 

related to IT, such as Math (Head First Algebra, Head First Statistics), Science (Head First Physics) and project 

management (Head First PMP). The books are also gaining some popularity for classroom use because of their 

novel approach to their subject matters.


Head First Labs 

O'Reilly established Head First Labs, where books of the series are presented and the main idea behind the series is 

explained. The Labs also hosts blogs by some of their authors and hosts some applets that complement their books. 

Awards 

The books in the series have received three nominations for Product Excellence Jolt Awards, winning in 2005 for 

Head First Design Patterns, and were recognized on Amazon.com's yearly top 10 list for computer books from 2003 

to 2005. 


• Head First Labs [4] 

• Blog [5] and blog archive [6] of Head First Labs 

References 

[1] http:/ / www. headfirstlabs. com/ 

[2] "How Head First Helps You Learn" (http:/ / www. headfirstlabs. com/ about. php). . Retrieved 2008-06-08. 

[3] "The Head First Formula" (http:/ / www. headfirstlabs. com/ readme. php). . Retrieved 2008-06-08. 

[4] http:/ / www. headfirstlabs. com/ books/ 

[5] http:/ / feeds. feedburner. com/ headfirst-oreillymedia 

[6] http:/ / www. headfirstlabs. com/ archive. php 

Jim Hugunin 

Jim Hugunin is a software programmer who created the Python programming language extension Numeric 

(ancestor to NumPy), and later created Python implementations for the Java Platform (Jython) and for Microsoft 

.NET platform (IronPython); he has also co-designed the AspectJ extension for the Java programming language. 

Since 2004 he has been working for Microsoft, mainly on IronPython and Dynamic Language Runtime [1] . 

References 

[1] Jim Hugunin blog (http:/ / blogs. msdn. com/ hugunin/ ) at MSDN


Inner class 

In object-oriented programming, an inner class (aka nested class) is a class declared entirely within the body of 

another class or interface. It is distinguished from a subclass. 

Inner classes became a feature of the Java programming language starting with version 1.1. They are also a feature of 

the D programming language. 

In Python, it is possible to nest a class within another class, method or function. 

Overview 

An instance of a normal or top-level class can exist on its own. By contrast, an instance of an inner class cannot be 

instantiated without being bound to a top-level class. 

Let us take the abstract notion of a Car with four wheels. Our wheels have a specific feature that relies on being part 

of our Car. This notion does not represent the wheels as wheels in a more general form that could be part of vehicle. 

Instead it represents them as specific to this one. We can model this notion using inner classes as follows: 

We have the top-level class Car. Instances of Class Car are composed of four instances of the class Wheel. This 

particular implementation of Wheel is specific to the car, so the code does not model the general notion of a Wheel 

which would be better represented as a top-level class. Therefore, it is semantically connected to the class Car and 

the code of Wheel is in some way coupled to its outer class. 

Inner classes provide us with a mechanism to accurately model this connection. We say that our wheel class is 

Car.Wheel, Car being the top-level class and Wheel being the inner class. 

Inner classes therefore allow for the object orientation of certain parts of the program that would otherwise not be 

encapsulated into class. 

Larger segments of code within a class might be better modeled or refactored as a separate top-level class, rather 

than an inner class. This would make the code more general in its application and therefore more re-usable but 

potentially might be premature generalization. This may prove more effective if code has many inner classes with 

the shared functionality . 

Types of inner class 

In Java there are four types of nested class: 

• Static member class, also simply called nested class - They are declared static. Like other things in static scope, 

they do not have an enclosing instance, and cannot access instance variables and methods of the enclosing class. 

They are almost identical to non-nested classes except for scope details (they can refer to static variables and 

methods of the enclosing class without qualifying the name; other classes that are not one of its enclosing classes 

have to qualify its name with its enclosing class's name). Nested interfaces are implicitly static. 

• Inner class - The following categories are called inner classes. Each instance of these classes has a reference to an 

enclosing instance (i.e. an instance of the enclosing class), except for local and anonymous classes declared in 

static context. Hence, they can implicitly refer to instance variables and methods of the enclosing class. The 

enclosing instance reference can be explicitly obtained via EnclosingClassName.this. Inner classes may not have 

static variables or methods, except for compile-time constant variables. When they are created, they must have a 

reference to an instance of the enclosing class; which means they must either be created within an instance 

method or constructor of the enclosing class, or (for member and anonymous classes) be created using the syntax 

enclosingInstance.new InnerClass(). 

• Member class - They are declared outside a function (hence a "member") and not declared "static".


• Local class - These are classes which are declared in the body of a function. They can only be referred to in the 

rest of the function. They can use local variables and parameters of the function, but only ones which are 

declared "final". (This is because the local class instance must maintain a separate copy of the variable, as it 

may out-live the function; so as not to have the confusion of two modifiable variables with the same name in 

the same scope, the variable is forced to be non-modifiable.) 

• Anonymous class - These are local classes which are automatically declared and instantiated in the middle of 

an expression. They can only directly extend one class or implement one interface. They can specify 

arguments to the constructor of the superclass, but cannot otherwise have a constructor (however, this is not a 

limitation, since it can have an instance initializer block to perform any initialization). 

C++ has nested classes that are like Java's static member classes (first kind above), except that they are not declared 

with "static". 

GUI code 

Local inner classes are often used in Java to define callbacks for GUI code. Components can then share an object 

that implements an event handling interface or extends an abstract adapter class, containing the code to be executed 

when a given event is triggered. 

Anonymous inner classes are also used where the event handling code is only used by one component and therefore 

does not need a named reference. 

This avoids a large monolithic actionPerformed(ActionEvent) method with multiple if else branches to identify the 

source of the event. This type of code is often considered messy and the inner class variations are considered to be 

better in all regards. 


• So what are inner classes good for anyway? [1] 

• Nested classes in D [2] 

References 

[1] http:/ / www. javaworld. com/ javaworld/ javaqa/ 2000-03/ 02-qa-innerclass. html 

[2] http:/ / www. digitalmars. com/ d/ class. html#nested


Interface (Java) 

An interface in the Java programming language is an abstract type that is used to specify an interface (in the generic 

sense of the term) that classes must implement. Interfaces are declared using the interface keyword, and may only 

contain method signatures and constant declarations (variable declarations that are declared to be both static and 

final). An interface may never contain method definitions. 

As interfaces are implicitly abstract, they cannot be directly instantiated except when instantiated by a class that 

implements the said interface. The class must implement all of the methods described in the interface, or be an 

abstract class. Object references in Java may be specified to be of an interface type; in which case, they must either 

be null, or be bound to an object that implements the interface. 

One benefit of using interfaces is that they simulate multiple inheritance. All classes in Java (other than 

java.lang.Object, the root class of the Java type system) must have exactly one base class; multiple inheritance of 

classes is not allowed. Furthermore, a Java class may implement, and an interface may extend, any number of 

interfaces; however an interface may not implement an interface. 

Overview 

Interfaces are used to encode similarities which classes of various types share, but do not necessarily constitute a 

class relationship. For instance, a human and a parrot can both whistle; however, it would not make sense to 

represent Humans and Parrots as subclasses of a Whistler class. Rather they would most likely be subclasses of an 

Animal class (likely with intermediate classes), but both would implement the Whistler interface. 

Another use of interfaces is being able to use an object without knowing its type of class, but rather only that it 

implements a certain interface. For instance, if one were annoyed by a whistling noise, one may not know whether it 

is a human or a parrot, because all that could be determined is that a whistler is whistling. In a more practical 

example, a sorting algorithm may expect an object of type Comparable. Thus, it knows that the object's type can 

somehow be sorted, but it is irrelevant what the type of the object is. The call whistler.whistle() will call the 

implemented method whistle of object whistler no matter what class it has, provided it implements Whistler. 

For example: 

interface Bounceable 

{ 

void setBounce(); // Note the semicolon: 

implementations are allowed. 

} 

Usage 

Defining an interface 

// Interface methods are public and abstract. 

// Think of them as prototypes only; no 

Interfaces are defined with the following syntax (compare to Java's class definition): 

[visibility] interface InterfaceName [extends other interfaces] { 

} 

constant declarations 

member type declarations 

abstract method declarations


The body of the interface contains abstract methods, but since all methods in an interface are, by definition, abstract, 

the abstract keyword is not required. Since the interface specifies a set of exposed behaviors, all methods are 

implicitly public. 

Thus, a simple interface may be 

public interface Predator { 

} 

boolean chasePrey(Prey p); 

void eatPrey(Prey p); 

The member type declarations in an interface are implicitly static and public, but otherwise they can be any type of 

class or interface. [1] 

The syntax for implementing an interface uses this formula: 

... implements InterfaceName[, another interface, another, ...] ... 

Classes may implement an interface. For example, 

public class Lion implements Predator { 

} 

public boolean chasePrey(Prey p) { 

} 

// programming to chase prey p (specifically for a lion) 

public void eatPrey (Prey p) { 

} 

// programming to eat prey p (specifically for a lion) 

If a class implements an interface and does not implement all its methods, it must be marked as abstract. If a class is 

abstract, one of its subclasses is expected to implement its unimplemented methods. 

Classes can implement multiple interfaces 

public class Frog implements Predator, Prey { ... } 

Interfaces are commonly used in the Java language for callbacks. [2] Java does not allow the passing of methods 

(procedures) as arguments. Therefore, the practice is to define an interface and use it as the argument and use the 

method signature knowing that the signature will be later implemented. 

Subinterfaces 

Interfaces can extend several other interfaces, using the same formula as described above. For example 

public interface VenomousPredator extends Predator, Venomous { 

} 

//interface body 

is legal and defines a subinterface. Note how it allows multiple inheritance, unlike classes. Note also that Predator 

and Venomous may possibly define or inherit methods with the same signature, say kill(Prey prey). When a class 

implements VenomousPredator it will implement both methods simultaneously.


Examples 

Some common Java interfaces are: 

• Comparable has the method compareTo, which is used to describe two objects as equal, or to indicate one is 

greater than the other. Generics allow implementing classes to specify which class instances can be compared to 

them. 

• Serializable is a marker interface with no methods or fields - it has an empty body. It is used to indicate that a 

class can be serialized. Its Javadoc describes how it should function, although nothing is programmatically 

enforced. 

Java interface modifiers 

Access Modifier Interface Modifier 

public abstract 

strictfp 

Note that improper usage of modifiers of interfaces may result in unstable software behavior. 

See also 

• Mixin 


• What Is an Interface? [3] 

• Interfaces and Packages [4] 

• Difference between a Java interface and a Java abstract class [5] 

References 

[1] "The Java Language Specification" (http:/ / java. sun. com/ docs/ books/ jls/ third_edition/ html/ interfaces. html#9. 5). . 

[2] "Java World" (http:/ / www. javaworld. com/ javaworld/ javatips/ jw-javatip10. html). . 

[3] http:/ / java. sun. com/ docs/ books/ tutorial/ java/ concepts/ interface. html 

[4] http:/ / java. sun. com/ docs/ books/ tutorial/ java/ interpack/ index. html 

[5] http:/ / javapapers. com/ ?p=17


Internet Foundation Classes 

The Internet Foundation Classes (IFC) were a graphics library for Java originally developed by Netcode 

Corporation and first released by Netscape Corporation on December 16, 1996. 

History 

On April 2, 1997, Sun Microsystems and Netscape announced their intention to combine IFC with other 

technologies to form the Java Foundation Classes [1] . 

Ultimately, Sun merged the IFC with other technologies under the name "Swing", adding the capability for a 

pluggable look and feel of the widgets. 

Because its technology has been merged to constitute Swing and Java 2D, IFC is now no longer maintained. 

Differences with Swing 

Swing draw a lot of features from IFC: 

• contrary to AWT, IFC were written in pure Java, thus being (at the time) browser-independent. 

• IFC already provided two Layout managers, that would be later included in the standard JDK 

• some IFC components were able to read HTML content from URLs, but the implementation was still far from 

reliable. 

However, Swing also improved IFC in a lot of ways: 

• IFC did not have a Model-View architecture 

• contrary to Swing, the Look and feel of IFC components was written in the components themselves, making it 

impossible to change it easily. 

• IFC components were not JavaBeans. IFC had a specific persistence mechanism [2] , but it was a bit complex, and 

not compatible with the Java Serialization API. 

• event mechanism was still raw [3] , and the Event loop sometimes needed to be accessed directly. 

Examples 

Hello World 

This is the classic Hello world program in IFC: 

import netscape.application.*; 

import netscape.util.*; 

public class HelloWorld extends Application { 

public void init() { 

} 

super.init(); 

// Create a text field 

TextField textField = new TextField(100, 24, 128, 24); 

// Set the string to be displayed in the text field. 

textField.setStringValue("Hello World"); 

// Add the text field to the view hierarchy. 

mainRootView().addSubview(textField);


// This method allows HelloWorld to run as a stand alone 

application. 

} 

public static void main(String args[]) { 

} 

HelloWorld = new HelloWorld (); 

ExternalWindow mainWindow = new ExternalWindow(); 

Size size; 

app.setMainRootView(mainWindow.rootView()); 

size = mainWindow.windowSizeForContentSize(320, 200); 

mainWindow.sizeTo(size.width, size.height); 

mainWindow.show(); 

app.run(); 

To be compared with the equivalent Java Swing code: 

import javax.swing.*; 

public class HelloWorld extends JFrame { 

} 

public HelloWorld() { 

} 

setDefaultCloseOperation(DISPOSE_ON_CLOSE); 

add(new JLabel("Hello, World!")); 


} 

See also 

• Swing 

HelloWorld app = new HelloWorld(); 

app.pack(); 


• IFC presentation [4] 

app.setVisible(true); 

• IFC runtime download [5] 

• IFC programming guide [6] 

• IFC class hierarchy [7] 

• IFC tutorial [8] 

The last places, where to download the IFC: 

• ftp-Server 1 Uni-Potsdam [9] 

• ftp-Server 2 Uni-Potsdam [10] 

• ftp-Server 3 Uni-Potsdam [11]


• ftp-Server Uni-Bochum [12] 

• ftp-Server SunSite [13] 

All find from 

• FileSearching.com [14] 

The web-archive where is the last place to find really all files: 

• WebArchive of the IFC-side [15] 

References 

[1] "Sun and Netscape to jointly develop Java Foundation Classes" (http:/ / wp. netscape. com/ newsref/ pr/ newsrelease378. html). Netscape 

Communications Corporation. 1997-04-02. . Retrieved 2007-07-14. 

[2] "IFC 1.1 guide - Persistence" (http:/ / infodoc. unicaen. fr/ docs/ Java/ guide. IFC1. 1/ persist. mak. html#1004819). 2000-06-15. . Retrieved 

2007-07-15. 

[3] "IFC 1.1 guide - Targets and commands" (http:/ / infodoc. unicaen. fr/ docs/ Java/ guide. IFC1. 1/ targets. mak. html#100582). 2000-06-15. . 


[4] http:/ / www. phdcc. com/ javaart2. html 

[5] http:/ / wp. netscape. com/ eng/ ifc/ download. html 

[6] http:/ / infodoc. unicaen. fr/ docs/ Java/ guide. IFC1. 1/ 

[7] http:/ / infodoc. unicaen. fr/ docs/ Java/ Reference. IFC1. 1/ tree. html 

[8] http:/ / infodoc. unicaen. fr/ docs/ Java/ cookbook/ 

[9] ftp:/ / ftp. uni-potsdam. de/ pub/ WWW/ Netscape/ navigator/ plugins/ ifc/ 1. 0/ 

[10] ftp:/ / ftp. uni-potsdam. de/ pub/ WWW/ clients/ netscape/ plugins/ ifc/ 1. 0/ 

[11] ftp:/ / ftp. uni-potsdam. de/ pub/ WWW/ netscape/ navigator/ plugins/ ifc/ 1. 0/ 

[12] ftp:/ / ftp. ruhr-uni-bochum. de/ . subdisc1/ local/ jk. collection/ 

[13] ftp:/ / ftp. anu. edu. au/ sunsite/ mnt/ disk3/ WWW/ netscape/ navigator/ plugins/ ifc/ 1. 0/ 

[14] http:/ / www. filesearching. com/ cgi-bin/ s?q=nsifc10 

[15] http:/ / web. archive. org/ web/ 20001021124345/ developer. netscape. com/ docs/ manuals/ ifc/ downloads/ downloads. html

JAD (JAva Decompiler) 146 

JAD (JAva Decompiler) 

Developer(s) Pavel Kouznetsov 

Initial release Before 1999 

Written in C++ 

Operating 

system 


Available in English 

Type Software engineering 

License Free for non-commercial use (Copyright: Pavel Kouznetsov) 

Jad (JAva Decompiler) is a decompiler for the Java programming language. Jad provides a command-line user 

interface to extract source code from class files. The most popular GUI for Jad is DJ Java Decompiler http:/ / 

members. fortunecity. com/ neshkov/ dj. html. According to CNET.com, in the past 8 years the various versions of 

DJ Java Decompiler has been downloaded over 10 Million times. A graphical user interface for Jad is JadClipse 

which is a plugin to the Eclipse IDE. 

The domain name used by the official website expired on 02/25/2009. 

The most recent version of JAD says it supports only Java versions 45.3, 46.0 and 47.0, not Java 5. 

A similar alternative, JD-Core [1] , has emerged that supports JDK 1.1.8 to JDK 1.6.0, jrockit90_150, jikes-1.2.2, 

harmony-jdk. 

See also 

• Mocha (decompiler) 


• New download site [2] 

• JadClipse plugin for Eclipse IDE [3] 

• JadRetro decompiler helper for Jad [4] 

• uuDeJava decompiler helper for Jad [5] 

• Original Jad site, including downloads [6] at the Wayback Machine (archived February 14, 2008). 

• DJ Java Decompiler New homepage [7] 

References 

[1] http:/ / java. decompiler. free. fr/ 

[2] http:/ / www. varaneckas. com/ jad 

[3] http:/ / jadclipse. sf. net/ 

[4] http:/ / jadretro. sourceforge. net/ 

[5] http:/ / www. uuware. com/ uudejava_en. htm 

[6] http:/ / web. archive. org/ web/ 20080214075546/ http:/ / www. kpdus. com/ jad. html 

[7] http:/ / www. neshkov. com/ dj. html


JAD (file format) 

Filename extension .jad 

Internet media 

type 

text/vnd.sun.j2me.app-descriptor 

Developed by Sun Microsystems, Inc. 

Type of format Descriptor file 

Standard(s) Java application 

Java Application Descriptor (JAD) files describe the MIDlets (Java ME applications) that are distributed as JAR 

files. JAD files are commonly used to package Java applications or games that can be downloaded to mobile phones. 

Java applications enable Mobile phones to interact programmatically with online web services, such as the ability to 

send SMS messages via GSM mobile internet or interact in multiplayer games. Some BlackBerry devices use JAD 

files for themes. 

Recent midlets contain a manifest file in the JAR archive. This file contains much of the information stored in the 

JAD file, rendering it unnecessary in most cases. 

JAD files format 

MIDlet-1: , , 

MIDlet-Jar-Size: 

MIDlet-Jar-URL: 

MIDlet-Name: 

MIDlet-Vendor: 

MIDlet-Version: 

MicroEdition-Configuration: 

MicroEdition-Profile: 

JAD mime type 

The MIDP2 specification instructs that web servers should serve JAD files with a MIME type of 

"text/vnd.sun.j2me.app-descriptor". If this mime type is not correctly configured, many phones will 

fail to install the midlet. 

See also 

• .sis 

• Decompilation 

• Mobile development 

• Midp2



• JADs and JARs [1] 

• Retrieving MIDlet Attributes [2] 

• Online check of JAD file syntax and mime type [3] 

References 

[1] http:/ / developers. sun. com/ mobility/ learn/ midp/ lifecycle/ #jadsnjars 

[2] http:/ / developers. sun. com/ mobility/ midp/ ttips/ getAppProperty/ 

[3] http:/ / jadcheck. appspot. com

JAMWiki 149 

JAMWiki 

Developer(s) Ryan Holliday 

Initial release June 30, 2006 


Written in Java, servlets and JSP 

Operating 

system 


Type wiki software 

License GNU Lesser General Public License 

Website http:/ / www. jamwiki. org 

JAMWiki is wiki software built around the standard components of Java, servlets and JSP. It was written by Ryan 

Holliday and released under the LGPL. While for the user JAMWiki is highly similar to MediaWiki and even uses 

the same wiki syntax (including templates, etc), it is not a MediaWiki clone but independent implementation, written 

in a different language and using a different database schema. 

JAMWiki internally uses Spring framework and has two code generation layers: servlets (that can be mapped to the 

various special pages of the wiki) and JSP (for the final page generation). Servlet (that is similar to standard servlet 

but is not exactly the same class) receives HTTP request, does all processing and puts the name-value pairs into 

provided context data structure ("model"). On the next stage, JSP uses these values to build the final output. Search 

is implemented using Lucene. Build system is currently powered by Maven. 

JamWiki runs inside Tomcat, Glassfish or other similar server and supports a wide range of databases to store the 

data. 

History 

Ryan Holliday started developing JAMWiki in June 2006. [1] 

Features 

• Wikipedia style syntax - At the present time JAMWiki supports the majority of the Mediawiki syntax including: 

• User watchlists. 

• Mediawiki footnotes (references). 

• Mediawiki templates (recent releases also support conditional constructs) 

• Mediawiki categories. 

• Image support (including automatic image resizing). 

• Topic delete / undelete. 

• Topic versioning. 

• Searching (powered by Lucene) 

• Page move/redirect 

• Internationalization - JAMWiki uses UTF-8 unicode as its standard encoding, making it work in languages such 

as Japanese and Chinese. 

• XML import / export - JAMWiki can import and export topics in Mediawiki-compatible XML format.

JAMWiki 150 


• Official JAMWiki wiki [2] 

Sites using JAMWiki 

• MathEclipse.org [3] 

• linux.org.ru [4] 

• WingS Framework [5] 

• uniBlogger [6] 

• Ultrastudio.org [7] 

References 

[1] Ryan Holliday's blog 2006-06 (http:/ / www. mountaininterval. org/ journal-2006-06. html#20060623) 

[2] http:/ / www. jamwiki. org/ 

[3] http:/ / www. matheclipse. org 

[4] http:/ / www. linux. org. ru/ wiki/ 

[5] http:/ / wingsframework. org/ wiki/ 

[6] http:/ / www. uniblogger. com 

[7] http:/ / ultrastudio. org

JGroups 151 

JGroups 

Stable release 2.6.3 / June 30, 2008 




Type reliable multicast system 

License GNU Lesser General Public License 

Website http:/ / www. jgroups. org/ 

JGroups is a reliable multicast system that's written in the Java language. 

JGroups adds a "grouping" layer over a transport protocol, internally keeping a list of participants. This list is used 

to: 

• Make the application aware of the listeners 

• Make some or all transmissions reliable 

• Allow atomic (all or none) transmissions 

• Allow totally ordered transmissions 

JGroups is a toolkit for reliable multicast communication. It can be used to create groups of processes whose 

members can send messages to each other. JGroups enables developers to create reliable multipoint (multicast) 

applications where reliability is a deployment issue. JGroups also relieves the application developer from 

implementing this logic themselves. This saves significant development time and allows for the application to be 

deployed in different environments without having to change code. 

JGroups Features 

• Group creation and deletion. Group members can be spread across LANs or WANs 

• Joining and leaving of groups 

• Membership detection and notification about joined/left/crashed members 

• Detection and removal of crashed members 

• Sending and receiving of member-to-group messages (point-to-multipoint) 

• Sending and receiving of member-to-member messages (point-to-point) 

Flexible Protocol Stack 

The most powerful feature of JGroups is its flexible protocol stack, which allows developers to adapt it to exactly 

match their application requirements and network characteristics. The benefit of this is that you only pay for what 

you use. By mixing and matching protocols, various differing application requirements can be satisfied. JGroups 

comes with a number of protocols (but anyone can write their own), for example 

• Transport protocols: UDP (IP Multicast), TCP, JMS 

• Fragmentation of large messages 

• Reliable unicast and multicast message transmission. Lost messages are retransmitted 

• Failure detection: crashed members are excluded from the membership 

• Ordering protocols: Atomic (all-or-none message delivery), Fifo, Causal, Total Order (sequencer or token based) 

• Membership 

• Encryption

JGroups 152 


• The JGroups website [1] 

• A simple request distribution example in JGroups [2] 

• A slideshow presenting JGroups [3] 

References 

[1] http:/ / www. jgroups. org/ javagroupsnew/ docs/ index. html 

[2] http:/ / www. alishomepage. com/ Scholar/ Master/ JGroups/ RequestDistributor. java 

[3] http:/ / www. alishomepage. com/ Scholar/ Master/ JGroups/ Slideshow. pdf 

JPicus 

JPicus is a Java TM I/O analysis framework. It consists of the following major parts: 

• Agent - it plugs into the Java TM Virtual Machine and collects I/O analysis data, like open file handles, byte 

counters etc 

• User interface - Eclipse based user interface that lets the user take a snapshot and visualise it 

JPicus is similar to Java CPU and memory allocation profilers with the difference that it operates in the I/O domain. 


• Official site [1] 

References 

[1] http:/ / jpicus. com


Java Class Library 

The Java Class Library is a set of 

dynamically loadable libraries that 

Java applications can call at runtime. 

Because the Java Platform is not 

dependent on any specific operating 

system, applications cannot rely on any 

of the existing libraries. Instead, the 

Java Platform provides a 

comprehensive set of standard class 

libraries, containing much of the same 

reusable functions commonly found in 

modern operating systems. 

The Java class libraries serve three purposes within the Java Platform: 

Java Platform diagram 

• Like other standard code libraries, they provide the programmer a well-known set of functions to perform 

common tasks, such as maintaining lists of items or performing complex string parsing. 

• In addition, the class libraries provide an abstract interface to tasks that would normally depend heavily on the 

hardware and operating system. Tasks such as network access and file access are often heavily dependent on the 

native capabilities of the platform. 

• Finally, some underlying platforms may not support all of the features a Java application expects. In these cases, 

the class libraries can either emulate those features using whatever is available, or provide a consistent way to 

check for the presence of a specific feature. 

Architecture 

The Java Class Library is almost entirely written in Java itself, except for the parts that need direct access to the 

hardware and operating system (such as for I/O, or bitmap graphics). The classes that give access to these functions 

commonly use native interface wrappers to access the API of the operating system. 

Almost all of the Java Class Library is stored in a single Java archive file called "rt.jar", which is provided with JRE 

and JDK distributions. The Java Class Library (rt.jar) is located in the default bootstrap classpath [1] , and does not 

have to be found in the classpath declared for the application. 

Conformance 

Any Java implementation must pass the Java Technology Compatibility Kit tests for compliance. 

Main Features 

Features of the Class Library are accessed through classes grouped by packages. 

• java.lang contains fundamental classes and interfaces closely tied to the language and runtime system. 

• I/O and networking: access to the platform file system, and more generally to networks, is provided through the 

java.io, java.nio, and java.net packages. 

• Mathematics package: java.math provides regular mathematical expressions, as well as arbitrary-precision 

decimals and integers numbers. 

• Collections and Utilities : provide built-in Collection data structures, and various utility classes, for Regular 

expressions, Concurrency, logging and Data compression.


• GUI and 2D Graphics: the java.awt package supports basic GUI operations and binds to the underlying native 

system. It also contains the 2D Graphics API. The javax.swing package is built on AWT and provides a platform 

independent widget toolkit, as well as a Pluggable look and feel. It also deals with editable and non-editable text 

components. 

• Sound: provides interfaces and classes for reading, writing, sequencing, and synthesizing of sound data. 

• Text: the java.text package deals with text, dates, numbers, and messages. 

• Image package: java.awt.image and javax.imageio provide APIs to write, read, and modify images. 

• XML: built-in classes handle SAX, DOM, StAX, XSLT transforms, XPath, and various APIs for Web services, as 

SOAP protocol and JAX-WS. 

• CORBA and RMI APIs, including a built-in ORB 

• Security and Cryptography 

• Databases: access to SQL databases is provided through the java.sql package. 

• Access to Scripting engines: the javax.script package gives access any Scripting language that conforms to this 

API. 

• Applets: java.applet allows applications to be downloaded over a network and run within a guarded sandbox 

• Java Beans: java.beans provides ways to manipulate reusable components. 

Licensing 

Following their promise to release a fully buildable JDK based almost completely on free and open source code in 

the first half of 2007 [2] , Sun released the complete source code of the Class Library under the GPL on May 8, 2007, 

except some limited parts that were licensed by Sun from third parties who did not want their code to be released 

under a free and open-source license. [3] Sun's goal is to replace the parts that remain proprietary and closed source 

with alternative implementations and make the Class Library completely free and open source. [4] 

As of May 2008, the only part of the Class library that remain proprietary and closed-source (4% as of May 2007 for 

OpenJDK 7 [5] , and less than 1% as of May 2008 and OpenJDK 6 [6] [7] ) is [8] [9] : 

• The SNMP implementation [9] . 

Since the first May 2007 release, Sun Microsystems, with the help of the community, has released as Open-source or 

replaced with Open-source alternatives almost all the encumbered code: 

• All the audio engine code, including the software synthetizer, has been released as Open-source [9] [10] . The 

closed-source software synthesizer has been replaced by a new synthesizer developed specifically for OpenJDK 

called Gervill [11] , 

• All cryptography classes used in the Class library have been released as Open-source [12] , 

[13] [14] [15] 

• The code that scales and rasterizes fonts has been replaced by FreeType 

• The native color management system has been replaced by LittleCMS [14] . There is a pluggable layer in the JDK, 

so that the commercial version can use the old color management system and OpenJDK can use LittleCMS. 

• The anti-aliasing graphics rasterizer code has been replaced by the Open-sourced Pisces renderer used in the 

phoneME project [14] [16] [17] . This code is fully functional, but still needs some performance enhancements [18] , 

• The Javascript plugin has been open-sourced (the JavaScript engine itself was open-sourced from the 

beginning) [19] .


Alternative implementations 

GNU Classpath is the other main free software class library for Java. Contrary to other implementations, it only 

implements the Class Library, and is used by many free Java runtimes (like Kaffe, SableVM, JamVM, CACAO). 

Apache Harmony is another free software class library. Its aim is to also implement the other parts of the Java stack 

(Virtual Machine, Compiler, and other tools required for any Java implementation). 

See also 

• Java Platform, Standard Edition 

• List of Java APIs 

• OpenJDK 


• Standard library 

• Java applet 


• Java SE Main page [20] 


• Java SE API documentation [21] 

• Java software development kits (status as of August 2006): 

• 1.7 [22] (early development) 

• 1.6 [23] (stable, current) 

• 1.5 [24] (stable) 

• 1.4 [25] (stable) 

• 1.3 [26] (obsolete) 

References 

[1] How Classes are Found (http:/ / java. sun. com/ javase/ 6/ docs/ technotes/ tools/ findingclasses. html) 

[2] http:/ / www. sun. com/ software/ opensource/ java/ faq. jsp#b4 

[3] "Open JDK is here!" (http:/ / mail. openjdk. java. net/ pipermail/ announce/ 2007-May. txt). Sun Microsystems. 2007-05-08. . Retrieved 

2007-05-09. 

[4] Since there's some encumbered code in the JDK, Sun will continue to use that code in commercial releases until it is replaced by 

fully-functional free and open-source alternatives. 

[5] Fitzsimmons, Thomas (2007-05-18). "Plans for OpenJDK" (http:/ / fitzsim. org/ blog/ ?p=17). . Retrieved 2007-05-22. 

[6] Angel, Lillian (2008-03-13). "OpenJDK to replace IcedTea in Fedora 9" (http:/ / langel. wordpress. com/ 2008/ 03/ 13/ openjdk-in-fedora-9/ 

). . Retrieved 2008-04-05. 





[8] Herron, David (2007-10-04). "Plans for OpenJDK" (http:/ / weblogs. java. net/ blog/ robogeek/ archive/ 2007/ 10/ openjdk_encumbr. html). . 


[9] "OpenJDK 6 b10 source posted" (http:/ / mail. openjdk. java. net/ pipermail/ jdk6-dev/ 2008-May/ 000058. html). 2008-05-30. . Retrieved 

2008-06-01. 

[10] audio-engine project page (http:/ / openjdk. java. net/ projects/ audio-engine/ ) 

[11] "Gervill - Software Synthesizer" (https:/ / gervill. dev. java. net/ ). . Retrieved 2008-06-01. 

[12] "Crypto has been added to OpenJDK" (http:/ / mail. openjdk. java. net/ pipermail/ security-dev/ 2007-September/ 000015. html). 

2007-09-27. . Retrieved 2007-10-07. 

[13] font-scaler projectpage (http:/ / openjdk. java. net/ projects/ font-scaler/ ) 

[14] Java2D project page (http:/ / openjdk. java. net/ groups/ 2d/ )


[15] "Freetype font rasteriser" (http:/ / mail. openjdk. java. net/ pipermail/ font-scaler-dev/ 2007-August/ 000011. html). 2007-08-07. . Retrieved 

2007-11-24. 

[16] phoneme.dev.java.net/ (https:/ / phoneme. dev. java. net/ ) 

[17] graphics-rasterizer project page (http:/ / openjdk. java. net/ projects/ graphics-rasterizer/ ) 

[18] Graham, Jim (2007-10-03). "Open Source rasterizer" (http:/ / mail. openjdk. java. net/ pipermail/ 2d-dev/ 2007-October/ 000078. html). Sun 


[19] "Javascript is encumbered and there is no javascript plugin support." (http:/ / icedtea. classpath. org/ bugzilla/ show_bug. cgi?id=85). 

IcedTea. 2008-03-11. . Retrieved 2008-06-01. "Changing Summary. JavaScript is no longer encumbered, but we still need liveconnect 

support." 

[20] http:/ / java. sun. com/ j2se/ 

[21] http:/ / java. sun. com/ reference/ api/ index. html 

[22] https:/ / jdk7. dev. java. net/ 

[23] http:/ / java. sun. com/ javase/ 6/ 

[24] http:/ / java. sun. com/ j2se/ 1. 5. 0/ 

[25] http:/ / java. sun. com/ j2se/ 1. 4. 2/ 

[26] http:/ / java. sun. com/ j2se/ 1. 3/ 

Java Classloader 

The Java Classloader is a part of the Java Runtime Environment that dynamically loads Java classes into the Java 

Virtual Machine [1] . Usually classes are only loaded on demand. The Java run time system does not need to know 

about files and file systems because of class loaders. Delegation is an important concept to understand when learning 

about class loaders. 

A software library is a collection of more or less related object code. In the Java language, libraries are typically 

packaged in Jar files. Libraries can contain objects of different types. The most important type of object contained in 

a Jar file is a Java class. A class can be thought of as a named unit of code. The class loader is responsible for 

locating libraries, reading their contents, and loading the classes contained within the libraries. This loading is 

typically done "on demand", in that it does not occur until the class is actually used by the program. A class with a 

given name can only be loaded once by a given classloader. 

Class loading process 

Each Java class must be loaded by a class loader [2] . Furthermore, Java programs may make use of external libraries 

(that is, libraries written and provided by someone other than the author of the program) or may itself be composed, 

at least in part, by a number of libraries. 

When the JVM is started, three class loaders are used [3] [4] : 

1. Bootstrap class loader 

2. Extensions class loader 

3. System class loader 

The bootstrap class loader loads the core Java libraries [5] (/lib directory). This class loader, which 

is part of the core JVM, is written in native code. 

The extensions class loader loads the code in the extensions directories (/lib/ext or any other 

directory specified by the java.ext.dirs system property). It is implemented by the 

sun.misc.Launcher$ExtClassLoader class. 

The system class loader loads code found on java.class.path, which maps to the system CLASSPATH variable. This 

is implemented by the sun.misc.Launcher$AppClassLoader class.


User-defined class loaders 

By default, all user classes are loaded by the default system class loader, but it is possible to replace it by a 

user-defined ClassLoader (which defaults to the original root system class loader), and even to chain class loaders 

as desired. 

This makes it possible (for example): 

• to load or unload classes at runtime (for example to load libraries dynamically at runtime, even from a HTTP 

resource). This is an important feature for: 

• implementing scripting languages, 

• using bean builders, 

• allowing user-defined extensibility 

• allowing multiple namespaces to communicate. This is one of the foundations of CORBA / RMI protocols, for 

example. 

• to change the way the bytecode is loaded (for example, it is possible to use encrypted Java class bytecode [6] ). 

• to modify the loaded bytecode (for example, for load-time weaving of aspects when using Aspect Oriented 

Programming). 

Class Loaders in JEE 

Java Platform, Enterprise Edition (JEE) application servers typically load classes from a deployed WAR or EAR 

archive by a tree of Classloaders, isolating the application from other applications, but sharing classes between 

[2] [7] 

deployed modules. So-called "servlet containers" are typically implemented in terms of multiple classloaders 

JAR hell 

JAR hell is a term similar to DLL hell used to describe all the various ways in which the classloading process can 

end up not working. [8] Three ways JAR hell can occur are explained below: 

• The first case is when a developer or deployer of a Java application has accidentally made two different versions 

of a library available to the system. This will not be considered an error by the system. Rather, the system will 

load classes from one or the other library. Adding the new library to the list of available libraries instead of 

replacing it, may see the application still behaving as though the old library is in use, which it may well be. 

• Another version of the problem arises when two libraries (or a library and the application) require different 

versions of the same third library. If both versions of the third library use the same class names, there is no way to 

load both versions of the third library with the same classloader. 

• The most complex JAR hell problems arise in circumstances that take advantage of the full complexity of the 

classloading system. A Java program is not required to use only a single "flat" classloader, but instead may be 

composed of several (or, in fact, an indefinite number of) nested, cooperating classloaders. Classes loaded by 

different classloaders may interact in complex ways not fully comprehended by a developer, leading to 

inexplicable errors or bugs. 

The OSGi Alliance specified (starting as JSR 8 in 1998) a modularity framework that solved JAR hell for current 

and future VMs both in ME, SE, and EE that is widely adopted. Using metadata in the JAR manifest, JAR files 

(called bundles) are wired on a per-package basis. Bundles can export packages, import packages and keep packages 

private, providing the basic constructs of modularity and versioned dependency management. 

To remedy the JAR hell problems a Java Community Process — JSR 277 was initiated in 2005. The resolution — 

Java Module System — intended to introduce a new distribution format, modules versioning scheme and a common 

modules repository (similar in purpose to Microsoft .NET's Global Assembly Cache). In December 2008 Sun 

announced that JSR 277 was put on hold [9] .


See also 

• Loader (computing) 

• Dynamic loading 

• DLL hell 

• OSGi 

• Apache Maven, automated software build tool with dependency management 


• Brandon E. Taylor, "Java Class Loading: The Basics [10] ", 2003 

• Jeff Hanson, "Take Control of Class Loading in Java [11] ", 2006-06-01 

• Andreas Schaefer, "Inside Class Loaders [12] ", 2003-11-12 

• Sheng Liang and Gilad Bracha, "Dynamic class loading in the Java virtual machine [13] ", In Proceedings of the 

13 th ACM Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA'98), 

ACM SIGPLAN Notices, vol. 33, no. 10, ACM Press, 1998, pp. 36–44 

• Dr. Christoph G. Jung, "Classloaders Revisited Hotdeploy [14] ", Java Specialist Newsletter, 2001-06-07 

• Don Schwarz, "Managing Component Dependencies Using ClassLoaders [15] ", 2005-04-13 

References 

[1] "The basics of Java class loaders" (http:/ / www. javaworld. com/ javaworld/ jw-10-1996/ jw-10-indepth. html). JavaWorld. 1996-10-01. . 


[2] Christudas, Binildas (2005-01-26). "Internals of Java Class Loading" (http:/ / www. onjava. com/ pub/ a/ onjava/ 2005/ 01/ 26/ classloading. 

html). onjava.com. . Retrieved 2009-10-02. 

[3] "Understanding Extension Class Loading" (http:/ / java. sun. com/ docs/ books/ tutorial/ ext/ basics/ load. html). java.sun.com. 2008-02-14. . 


[4] Sosnoski, Dennis (2003-04-29). "Classes and class loading" (http:/ / www. ibm. com/ developerworks/ java/ library/ j-dyn0429/ ). ibm.com. . 


[5] These libraries are stored in Jar files called rt.jar, core.jar, server.jar, etc. 

[6] Roubtsov, Vladimir (2003-05-09). "Cracking Java byte-code encryption" (http:/ / www. javaworld. com/ javaworld/ javaqa/ 2003-05/ 

01-qa-0509-jcrypt. html?page=1). javaworld.com. . Retrieved 2008-01-26. 

[7] deBoer, Tim; Karasiuk, Gary (2002-08-21). "J2EE Class Loading Demystified" (http:/ / www-128. ibm. com/ developerworks/ websphere/ 

library/ techarticles/ 0112_deboer/ deboer. html). ibm.com. . Retrieved 2008-01-26. 

[8] http:/ / incubator. apache. org/ depot/ version/ jar-hell. html 

[9] http:/ / www. osgi. org/ News/ 20081217 

[10] http:/ / www. developer. com/ java/ other/ article. php/ 2248831 

[11] http:/ / www. devx. com/ Java/ Article/ 31614 

[12] http:/ / www. onjava. com/ pub/ a/ onjava/ 2003/ 11/ 12/ classloader. html 

[13] http:/ / citeseer. ist. psu. edu/ liang98dynamic. html 

[14] http:/ / www. roseindia. net/ javatutorials/ hotdeploy. shtml 

[15] http:/ / www. onjava. com/ pub/ a/ onjava/ 2005/ 04/ 13/ dependencies. html?page=1

Java compiler 159 

Java compiler 

A Java compiler is a compiler for the Java programming language. The most common form of output from a Java 

compiler are Java class files containing platform-neutral Java bytecode. There exist also compilers emitting 

optimized native machine code for a particular hardware/operating system combination. 

Most Java-to-bytecode compilers, Jikes being a well known exception, do virtually no optimization, leaving this 

until runtime to be done by the JRE. 

The Java Virtual Machine (JVM) loads the class files and either interprets the bytecode or just-in-time compiles it to 

machine code and then possibly optimizes it using dynamic compilation. 

The very first Java compiler developed by Sun Microsystems was written in C using some libraries from C++. 

Major Java compilers 

As of 2010, the following are major Java compilers: 

• javac, included in JDK from Sun Microsystems, open-sourced since 13 November 2006. 

• GCJ, a part of gcc which compiles C, Fortran, Pascal and other programming languages besides Java. It can also 

generate native code using the back-end of gcc. 

• ECJ, the Eclipse Compiler for Java, is an open source incremental compiler used by the Eclipse JDT. 

Java decompilers 

A Java decompiler tries to reverse the process of compiling, that is it tries to decompile Java bytecode files (*.class) 

back to Java source files (*.java). 

• DJ Java Decompiler [1] (Uses JAD) 10 use trial version 

• JAD, written in C++, free for non-commercial use. 

• JD [1], younger project, includes GUI, optional Eclipse-plugin. 

• JODE [2], decompiler and optimizer, open-source. 

• Mocha, one of the first decompilers for Java. 


• Sun's OpenJDK javac page [3] 

• Jikes homepage [4] 

• JSR 199 [5] Java Compiler API Java Specification Request for invoking the Java compiler from a Java program 

References 

[1] http:/ / www. neshkov. com/ 

[2] http:/ / jode. sourceforge. net/ 

[3] http:/ / openjdk. java. net/ groups/ compiler/ 

[4] http:/ / jikes. sourceforge. net/ 

[5] http:/ / www. jcp. org/ en/ jsr/ detail?id=199


Java Development Kit 

Developer(s) Sun Microsystems (Owned by Oracle Corporation) 

Stable release 

Preview release 

Operating 

system 

6 Update 21 [1] / July 7, 2010 

JDK 7 Preview Release, Build b101 / July 15, 2010 [2] 


Type Software development kit 

License Sun License (most of it also under GPL) 

Website http:/ / java. sun. com/ javase/ 

The Java Development Kit (JDK) is a Sun Microsystems product aimed at Java developers. Since the introduction 

of Java, it has been by far the most widely used Java SDK. On 17 November 2006, Sun announced that it would be 

released under the GNU General Public License (GPL), thus making it free software. This happened in large part on 

8 May 2007 [3] ; Sun contributed the source code to the OpenJDK. 

JDK contents 

The JDK has as its primary components a collection of programming tools, including: 

• java – the loader for Java applications. This tool is an interpreter and can interpret the class files generated by the 

javac compiler. Now a single launcher is used for both development and deployment. The old deployment 

launcher, jre, no longer comes with Sun JDK. 

• javac – the compiler, which converts source code into Java bytecode 

• jar – the archiver, which packages related class libraries into a single JAR file. This tool also helps manage JAR 

files. 

• javadoc – the documentation generator, which automatically generates documentation from source code 

comments 

• jdb – the debugger 

• jps – the process status tool, which displays process information for current Java processes 

• javap – the class file disassembler 

• appletviewer – this tool can be used to run and debug Java applets without a web browser. 

• javah – the C header and stub generator, used to write native methods 

• javaws – the Java Web Start launcher for JNLP applications 

• extcheck – a utility which can detect JAR-file conflicts. 

• apt – the annotation-processing tool 

• jhat – (experimental) Java heap analysis tool


• jstack – (experimental) utility which prints Java stack traces of Java threads 

• jstat – (experimental) Java Virtual Machine statistics monitoring tool 

• jstatd – (experimental) jstat daemon 

• jinfo – (experimental) This utility gets configuration information from a running Java process or crash dump. 

• jmap – (experimental) This utility outputs the memory map for Java and can print shared object memory maps or 

heap memory details of a given process or core dump. 

• idlj – the IDL-to-Java compiler. This utility generates Java bindings from a given IDL file. 

• policytool – the policy creation and management tool, which can determine policy for a Java runtime, specifying 

which permissions are available for code from various sources 

• VisualVM – visual tool integrating several commandline JDK tools and lightweight performance and memory 

profiling capabilities 

• wsimport – generates portable JAX-WS artifacts for invoking a web service. 

• jrunscript – Java command-line script shell. 

The JDK also comes with a complete Java Runtime Environment, usually called a private runtime. It consists of a 

Java Virtual Machine and all of the class libraries present in the production environment, as well as additional 

libraries only useful to developers, such as the internationalization libraries and the IDL libraries. 

Copies of the JDK also include a wide selection of example programs demonstrating the use of almost all portions of 

the Java API. 

Ambiguity between a JDK and an SDK 

The JDK forms an extended subset of a software development kit (SDK). In the descriptions which accompany its 

recent releases for Java SE, EE, and ME, Sun acknowledges that under its terminology, the JDK forms the subset of 

the SDK which has the responsibility for the writing and running of Java programs. The remainder of the SDK 

comprises extra software, such as application servers, debuggers, and documentation. 

Other JDKs 

There are other JDKs commonly available for a variety of platforms, some of which started from the Sun JDK 

source and some which did not. All of them adhere to the basic Java specifications, but they often differ in explicitly 

unspecified areas, such as garbage collection, compilation strategies, and optimization techniques. They include: 

• GNU's GCJ (The GNU Compiler for Java) 

• IBM's J9 JDK, for AIX, Linux, Windows, MVS, OS/400, Pocket PC, z/OS [4] 

• Oracle Corporation's JRockit JDK, for Windows, Linux and Solaris [5] 

• Blackdown Java – The Blackdown Group's port of Sun's JDK for Linux 

• Apple's Mac OS Runtime for Java JVM/JDK for Mac OS [6]


See also 

• Classpath (Java) 

• Java platform 



• Sun Java SE [7] – Sun's current stable release (6). 

• IBM Java technology JDK [8] 

• Oracle's JRockit JDK [5] 

• Open source JDK 7 project [22] 

• Open source JDK project [9] 

• Community support [10] 

• GNU Classpath [11] – a Free software JDK alternative 

• Apache Harmony [38] – an Open source JDK alternative 

• Javadoc Developer Kit (JDK) Search Engine [12] 

• Developer Support Services from Sun Microsystems [13] 

References 

[1] "Java SE Downloads - Sun Developer Network (SDN)" (http:/ / java. sun. com/ javase/ downloads/ widget/ jdk6. jsp). . 

[2] http:/ / dlc. sun. com. edgesuite. net/ jdk7/ binaries/ index. html 

[3] "Sun's May 8th announcement of source code for JDK" (http:/ / www. prnewswire. com/ cgi-bin/ stories. pl?ACCT=104& STORY=/ www/ 

story/ 05-08-2007/ 0004583482). . 

[4] http:/ / www-128. ibm. com/ developerworks/ java/ jdk/ 

[5] http:/ / www. oracle. com/ appserver/ jrockit/ index. html 

[6] http:/ / docs. info. apple. com/ article. html?artnum=120209 

[7] http:/ / java. sun. com/ javase/ 

[8] http:/ / www. ibm. com/ developerworks/ java/ jdk/ 

[9] http:/ / openjdk. java. net/ 

[10] http:/ / community. java. net/ jdk/ 

[11] http:/ / www. gnu. org/ software/ classpath/ 

[12] http:/ / javadoc. ankerl. com/ 

[13] http:/ / www. sun. com/ service/ developer/ index. jsp

Java Interface Definition Language 163 

Java Interface Definition Language 

In software development, Java Interface Definition Language, or Java IDL, is an implementation of the CORBA 

specification and enables interoperability and connectivity with heterogeneous objects. It is basically an Object 

Request Broker provided with JDK. The Java IDL enables distributed Web applications to transparently invoke 

operations on remote network services using the industry standards IDL and IIOP from OMG. 


• Sun Developer Network: Core Java: Java IDL [1] 

References 

[1] http:/ / java. sun. com/ products/ jdk/ idl/ 

Java resource bundle 

A resource bundle is a Java .properties file that contains locale-specific data [1] . It is a way of internationalising a 

Java application by making the code locale-independent. 

Naming a resource bundle 

Resource bundles have a naming convention to identify them when they deal with different languages. The file name 

is followed by an underscore and a two-letter language code (ISO 639-2 code) that specifies the language that the 

resource bundle deals with. So, for example, an application that supports Spanish and French can have these resource 

bundles, respectively: 

resbund_es.properties 

resbund_fr.properties 

This can also be followed by another underscore and a two-letter country code (ISO 3166-1). In this case, an 

application that supports British English and US English respectively will have the following files: 

resbund_en_GB.properties 

resbund_en_US.properties 

Content of a resource bundle 

Resource bundles are essentially text files. The most common type of content in a resource bundle is a list of strings. 

Each string has a “key” to identify it, which is the same in all the different resource bundles. When writing the code 

for the application, only the key is mentioned (this is why we say that the code is locale-independent). Using the 

methods provided in the Java API for the ResourceBundle class [2] , we can access the string (i.e. the "value") 

associated with the key. Depending on which locale the application is handling, it will call the adequate resource 

bundle at runtime [3] . 

For instance, our resource bundle for the UK English locale can contain “firstKey = Localisation” and our US 

English one can contain “firstKey = Localization”. We will refer only to “firstKey” in the code and, according to the 

current locale settings, the application will use either “Localization” or “Localisation”.

Java resource bundle 164 

Benefits of using resource bundles 

Extracting locale-sensitive objects such as strings from the code (as opposed to hard-coding them) means that the 

application can handle multiple locales without having to write different code for each locale. It also means that 

translators can deal with just the translatable text and not the programming code. Therefore, using resource bundles 

improves the internationalisation and the localisation process of a software product. 

Translating a resource bundle 

Some CAT tools like OmegaT, OmegaT+ [4] or Sun's Open language tools can specifically handle resource bundles. 

In addition to these, translators can use any text editor to create new resource bundles or to modify existing ones. 

References 

[1] O'Conner, B. Java Internationalization: Localization with ResourceBundles, Sun Developer Network. (http:/ / java. sun. com/ developer/ 

technicalArticles/ Intl/ ResourceBundles/ ) 

[2] Java API ResourceBundle Class (http:/ / java. sun. com/ j2se/ 1. 5. 0/ docs/ api/ ) 

[3] Esselink, B. A Practical Guide to Software Localisation, John Benjamins Publishing (1998). 

[4] OmegaT+ (http:/ / omegatplus. sourceforge. net/ ) 

Java TV 

Java TV is a Java-based software framework designed for use on TV set-top boxes, based around components called 

Xlets. It is currently used only on the Connected Device Configuration, specifically for iTV applications 

development. 

The API includes the Xlet classes in the package javax.tv.xlet. Other packages of the public API include 

1. javax.tv.graphics - provides a simple rendering canvas 

2. javax.tv.locator - provides a locator in the style of a URL for services and media, such as service:/SERV1 

3. javax.tv.service - defines a mechanism for service information (SI) databases and APIs representing the SI 

elements, such as the TV channels and media available for playback. 

Criticisms 

While the framework is general, Sun currently provides support only on Java ME. For some subjects, such as media 

locators, it is in effect superseded by other locator standards on platforms such as BD-J. 

A point of confusion is that in platforms supported as of 2008, examples such as the SvcDispXlet example from the 

introduction to the API, written circa 2001, are not deployable because it uses AWT widgets such as java.awt.Button 

[1] . Most iTV platforms, along with BD-J, implement Personal Basis Profile with no AWT widgets, as opposed to 

Personal Profile which includes the widgets. [2] 

Sun's reference implementation for Java TV attempts to limit its exposure to support issues to the full Java Media 

Framework by having its own small version of JMF that is internally referred to as "jmflite". As with the limitations 

of the MIDP emulators that Sun provides, the Java TV reference implementation provided by Sun has not been 

updated to make provisions for later JDK's such as removing calls to Thread.stop(). The Thread.stop() method was 

made a "final" method in Java 1.5 (meaning that classes which extend Thread and override stop() will fail at runtime 

under JRE 1.5 when the class is loaded). This implies that Sun has not yet committed to public plans or a roadmap 

for taking Java ME beyond JRE 1.3. If such an upgrade were to take place, it would require significant work on the 

[3] [4] 

part of all vendors of Java ME-enabled devices.

Java TV 165 

See also 

• Xlet 


• Java ME Technology - Java TV API [5] - includes Sun's Reference Implementation 

• Java TV API 1.1 (JSR-927) online Javadocs [6] 

• The JavaTV tutorial [7] 

References 

[1] http:/ / java. sun. com/ javase/ 6/ docs/ api/ java/ awt/ Button. html 

[2] Introduction to Digital TV Applications Programming (http:/ / java. sun. com/ developer/ technicalArticles/ javatv/ apiintro/ ) By Monica 

Pawlan, February 2001 

[3] JRE 1.5 Thread.stop() javadoc (http:/ / java. sun. com/ j2se/ 1. 5. 0/ docs/ api/ java/ lang/ Thread. html#stop()) 

[4] Why Are Thread.stop, Thread.suspend, Thread.resume and Runtime.runFinalizersOnExit Deprecated? (http:/ / java. sun. com/ j2se/ 1. 5. 0/ 

docs/ guide/ misc/ threadPrimitiveDeprecation. html) 

[5] http:/ / java. sun. com/ javame/ technology/ javatv/ 

[6] http:/ / java. sun. com/ javame/ reference/ apis/ jsr927/ 

[7] http:/ / www. mhp-interactive. org/ tutorials/ javatv/


Java Work Framework 

Stable release 1.0.1 / February 18, 2009 

Operating 

system 


Type Java Network Framework 

License MIT license 

Website http:/ / javawork. org/ 

Java Work Framework is a simple, but powerful Java framework providing Network(New I/O Socket), Database, 

Exception handling and System functionality. It is open source, object-oriented and event driven. 

History 

It was originally designed and implemented by Ivan Penev back in 2005 as a network layer capable to handle around 

10,000 socket connections. Then it gradually included the most common functionality a programmer may need - 

socket communication, simple database access, reading external resources as files, URLs, etc. 

Features 

Its main focus is to hide behind simple wrappers existing Java functionality and to provide general application 

exception handling mechanism. In short it supports: 

• Java NIO Socket Framework 

• 15,000+ socket connections. Sending/receiving 5000 java objects per second between 2 computers works great. 

• Multicast 

• Unicast(UDP) support 

• Pluggable protocols through in and out filters 

• Easy-to-use database layer 

• Custom JAR files loader 

Security 

• Securing socket communication through SSL 

• Exchanging data encrypted through XXTEA, XOR algorithms 

Code snippets 

Multicast: 

Multicast.listen( "230.0.0.1", 35098, new IEventListener() { public void onEvent( IEvent evt ) { 

} } ); 

MulticastDataEvent dataEvt = (MulticastDataEvent)evt; 

System.out.println( "data-bytes:" + DebugUtil.toString(dataEvt.asByteArray()) ); 

Multicast.send( "Lorem ipsum dolor ...", "230.0.0.1", 35098 ); 

Database:


Database db = Database.createInstance(); 

db.setUrl("jdbc:postgresql://localhost/testdb"); 

db.setUsername("testuser"); 

db.setPassword("test123"); 

SQLInsert insertOp = new SQLInsert("persons"); 

insertOp.addData("person_fname", "Mike", 

"person_lname", "Johnson", 

"birthday", Convert.toDate("1971-08-01"), 

"country_id", "de", 

"single", true); 

int affectedRows = insertOp.execute(); 

System.out.println("Affected rows = " + affectedRows); 

Requirements 

• JDK 1.6 (Mustang) 



• Demo [2] 

References 

[1] http:/ / javawork. org/ 

[2] http:/ / javawork. org/ examples/


Java annotation 

An annotation, in the Java computer programming language, is a special form of syntactic metadata that can be 

added to Java source code. [1] Classes, methods, variables, parameters and packages may be annotated. Unlike 

Javadoc tags, Java annotations can be reflective in that they can be embedded in class files generated by the compiler 

and may be retained by the Java VM to be made retrievable at run-time. [2] 

Examples 

// @Twizzle is an annotation to method toggle(). 

@Twizzle 

public void toggle() { 

} 

// Declares the annotation Twizzle. 

public @interface Twizzle { 

} 

Annotations may include an optional list of key-value pairs: 

// Same as: @Edible(value = true) 

@Edible(true) 

Item item = new Carrot(); 

public @interface Edible { 

} 

boolean value() default false; 

@Author(first = "Oompah", last = "Loompah") 

Book book = new Book(); 

public @interface Author { 

} 

String first(); 

String last(); 

Annotations themselves may be annotated to indicate where and when they can be used: 

@Retention(RetentionPolicy.RUNTIME) // Make this annotation 

accessible at runtime via reflection. 

@Target({ElementType.METHOD}) // This annotation can only be 

applied to class methods. 

public @interface Tweezable { 

} 

The compiler reserves a set of special annotations (including @Deprecated, @Override and 

@SuppressWarnings) for syntactic purposes. 

Annotations are often used by frameworks as a way of conveniently applying behaviours to user-defined classes and 

methods that must otherwise be declared in some external source (such as an XML configuration file) or


programmatically (with API calls). The following, for example, is an annotated EJB 3.0 data class: 

@Entity // Declares this an 

entity bean 

@Table(name = "people") // Maps the bean to 

SQL table "people" 

class Person implements Serializable { 

@Id // Map this to the 

primary key column. 

@GeneratedValue(strategy = GenerationType.AUTO) // Database will 

generate new primary keys, not us. 

private Integer id; 

@Column(length = 32) // Truncate column 

values to 32 characters. 

} 

private String name; 

public Integer getId() { 

} 

return id; 

public void setId(Integer id) { 

} 

this.id = id; 

public String getName() { 

} 

return name; 

public void setName(String name) { 

} 

this.name = name; 

A complete example is given below: 

package com.annotation; 

import java.lang.annotation.Documented; 

import java.lang.annotation.ElementType; 

import java.lang.annotation.Inherited; 

import java.lang.annotation.Retention; 

import java.lang.annotation.RetentionPolicy; 

import java.lang.annotation.Target; 

@Documented 

@Retention(RetentionPolicy.RUNTIME) 

@Target({ElementType.TYPE,ElementType.METHOD,


ElementType.CONSTRUCTOR,ElementType.ANNOTATION_TYPE, 

ElementType.PACKAGE,ElementType.FIELD,ElementType.LOCAL_VARIABLE}) 

@Inherited 

public @interface Unfinished { 

} 

public enum Priority { LOW, MEDIUM, HIGH } 

String value(); 

String[] changedBy() default ""; 

String[] lastChangedBy() default ""; 

Priority priority() default Priority.MEDIUM; 

String createdBy() default "prabir karmakar"; 

String lastChanged() default "01/01/2009"; 

package com.annotation; 

public @interface UnderConstruction { 

} 

String owner() default "PrabirK"; 

String value() default "Object is Under Construction."; 

String createdBy() default "Prabir Karmakar"; 

String lastChanged() default "01/01/2009"; 

package com.validators; 

import javax.faces.application.FacesMessage; 

import javax.faces.component.UIComponent; 

import javax.faces.context.FacesContext; 

import javax.faces.validator.Validator; 

import javax.faces.validator.ValidatorException; 

import com.annotation.UnderConstruction; 

import com.annotation.Unfinished; 

import com.annotation.Unfinished.Priority; 

import com.util.Util; 

@UnderConstruction(owner="Prabir Karmakar") 

public class DateValidator implements Validator{ 

public void validate(FacesContext context, UIComponent component, 

Object value) 

{ 

throws ValidatorException 

String date = (String) value; 

String errorLabel = "Please enter a valid date."; 

if(!component.getAttributes().isEmpty()) 

{ 

errorLabel = (String)


component.getAttributes().get("errordisplayval"); 

} 

if(!Util.validateAGivenDate(date)) 

{ 

not, confirm" 

} 

} 

} 

@Unfinished(changedBy = "prabirk" 

) 

,value="whether to add message to context or 

,priority=Priority.HIGH 

FacesMessage message = new FacesMessage(); 

message.setSeverity(FacesMessage.SEVERITY_ERROR); 

message.setSummary(errorLabel); 

message.setDetail(errorLabel); 

throw new ValidatorException(message); 

The annotations are not method calls and will not, by themselves, do anything. Rather, the class object is passed to 

the EJB implementation at run-time, which then extracts the annotations to generate an ORM. 

Processing 

When Java source code is compiled, annotations can be processed by compiler plug-ins called annotation processors. 

Processors can produce informational messages or create additional Java source files or resources, which in turn may 

be compiled and processed, but annotation processors cannot modify the annotated code itself. The Java compiler 

conditionally stores annotation metadata in the class files if the annotation has a RetentionPolicy of CLASS or 

RUNTIME. Later, the JVM or other programs can look for the metadata to determine how to interact with the 

program elements or change their behavior. 

History 

The Java platform has had various ad-hoc annotation mechanisms—for example, the transient modifier, or the 

@deprecated javadoc tag. The general purpose annotation (also known as metadata) facility was introduced to the 

Java Community Process as JSR-175 in 2002 and approved in September 2004. [3] Annotations became available in 

the language itself beginning with version 1.5 of the JDK. A provisional interface for compile-time annotation 

processing was provided by the apt tool in JDK version 1.5, and was formalized through JSR-269 and integrated into 

the javac compiler in version 1.6.


See also 

• Java programming 

• Model-driven architecture 

• Java virtual machine 

• .NET Attributes 


• Introduction to Java 5.0 Annotations by Joy Christy [4] 

• Of Java Annotations by John Hunt [5] 

• An Introduction to Java Annotations by M. M. Islam Chisty [6] 

• Introduction to Java 6 Annotations at Sun Developer Network Site [7] 

References 

[1] "JDK 5.0 Developer's Guide: Annotations" (http:/ / java. sun. com/ j2se/ 1. 5. 0/ docs/ guide/ language/ annotations. html). Sun Microsystems. 

2007-12-18. . Retrieved 2008-03-05.. 

[2] Sun Microsystems (2005). Java(TM) Language Specification (http:/ / java. sun. com/ docs/ books/ jls/ third_edition/ html/ j3TOC. html) (3rd 

ed.). Prentice Hall. ISBN 0321246780. . 

[3] Coward, Danny (2006-11-02). "JSR 175: A Metadata Facility for the JavaTM Programming Language" (http:/ / www. jcp. org/ en/ jsr/ 

detail?id=175#2). Java Community Process. . Retrieved 2008-03-05. 

[4] http:/ / www. javabeat. net/ articles/ java-5-0/ 2007/ 08/ annotations/ 

[5] http:/ / www. regdeveloper. co. uk/ 2006/ 02/ 24/ java_annotations/ 

[6] http:/ / www. developer. com/ java/ other/ article. php/ 3556176 

[7] http:/ / java. sun. com/ javase/ 6/ docs/ technotes/ guides/ language/ annotations. html 

Java collections framework 

JCF redirects here and can also stand for Jordan canonical form in Linear Algebra or Juan Carlos Ferrero, the 

Spanish tennis player 

The Java collections framework is a coupled set of classes and interfaces that implement commonly reusable 

collection data structures. It was designed and developed primarily by Joshua Bloch. 

Although it is a framework, it works in a manner of a library. 

See also 

• Container (data structure) 

• Standard Template Library 


• 'The Java Tutorials - Collections' by Josh Bloch [1] 

• 'The Collections Framework' [2] (Sun Java SE 6 documentation) 

• Generic Types [3] 

• Java Generics and Collections [4] 

• Taming Tiger: The Collections Framework [5] 

• Collections Lessons [6] 

• CollectionSpy [7] — A profiler for Java's Collections Framework. 

• Java 6 Collection Tutorial [8] — By Jakob Jenkov, Kadafi Kamphulusa

Java collections framework 173 

References 

[1] http:/ / java. sun. com/ docs/ books/ tutorial/ collections/ 

[2] http:/ / java. sun. com/ javase/ 6/ docs/ technotes/ guides/ collections/ index. html 

[3] http:/ / www. onjava. com/ pub/ a/ onjava/ excerpt/ javaian5_chap04/ 

[4] http:/ / www. onjava. com/ pub/ a/ onjava/ excerpt/ javagenerics_chap05/ 

[5] http:/ / www-128. ibm. com/ developerworks/ java/ library/ j-tiger07195/ 

[6] http:/ / javalessons. com/ cgi-bin/ fun/ java-tutorials-main. cgi?sub=adv& ses=ao789 

[7] http:/ / www. collectionspy. com 

[8] http:/ / tutorials. jenkov. com/ java-collections/ index. html 

Java concurrency 

Java is a programming language (and API) which has been designed to support concurrent programming, and all 

execution in the language takes place in the context of a thread. It is important for a Java programmer to understand 

both the power and limitations of Java threads. 

In the JVM (Java Virtual Machine), objects and resources can be accessed by many separate threads; each thread has 

its own path of execution but can potentially access any object in the program. The programmer must ensure that 

threads do not interfere with each other, and that resources are properly coordinated (or "synchronized") during both 

read and write access. The Java language has built-in constructs to support this coordination. 

The Java Language Specification does not say how the JVM designer should implement the multithreading 

primitives specified, because there is so much variation among the various operating systems and hardware on which 

the JVM is expected to run. 

Monitor synchronization in Java 

The key synchronization concept in Java is the monitor. Every object in a JVM has a monitor associated with it. 

Such monitor-based concurrency was originally introduced with the Mesa programming language. 

Changes in Java 5 

Java 5 incorporated many additions and clarifications to the Java concurrency model. JSR 133 provided support for 

well-defined atomic operations in a multithreaded/multiprocessor environment, opening the door to JSR 166, a large 

battery of concurrent programming APIs. 

See also 

• Monitor (synchronization) 

• Concurrency (computer science) 

• Concurrency pattern 

• Doug Lea 

• Thread (computer science)

Java concurrency 174 

References 

• Goetz, Brian; Joshua Bloch, Joseph Bowbeer, Doug Lea, David Holmes, Tim Peierls (2006). Java Concurrency 

in Practice. Addison Wesley. ISBN 0-321-34960-1. 

• Lea, Doug (1999). Concurrent Programming in Java: Design Principles and Patterns. Addison Wesley. 

ISBN 0-201-31009-0. 


• JDK 5.0 concurrency utilities [1] 

• Podcast from JavaPolis - 'Concurrency Utilities in JDK 5.0 by Brian Goetz' [2] 

• JavaOne 2005 - Concurrency Utilities in Practice [3] 

• JavaOne 2005 - Brian Goetz - Simpler, Faster, Better: Concurrency Utilities in JDK Software Version 5.0 [4] 

• Podcast from JavaPosse - Interview with Brian Goetz on Concurrency in Java 5 [5] 

• William Pugh's Java Memory Model page [6] 

• Java Concurrency Tutorial by Jakob Jenkov [7] 

• Thread Safe Java Programming by Vadym Ustymenko [8] 

References 

[1] http:/ / java. sun. com/ j2se/ 1. 5. 0/ docs/ guide/ concurrency/ index. html 

[2] http:/ / www. javapolis. com/ confluence/ display/ JP05/ 2006/ 05/ 23/ Concurrency+ Utilities+ in+ JDK+ 5. 0+ talk+ by+ Brian+ Goetz 

[3] http:/ / developers. sun. com/ learning/ javaoneonline/ 2005/ coreplatform/ TS-3423. pdf 

[4] http:/ / developers. sun. com/ learning/ javaoneonline/ 2005/ coreplatform/ TS-5807. pdf 

[5] http:/ / javaposse. com/ index. php?post_id=95780 

[6] http:/ / www. cs. umd. edu/ ~pugh/ java/ memoryModel/ 

[7] http:/ / tutorials. jenkov. com/ java-concurrency/ index. html 

[8] http:/ / javatip. com/ 2010/ 07/ core-java/ concurrency/ thread-safe-without-synchronization/


Java syntax 

The syntax of the Java programming language 

is a set of rules which defines how a Java 

program is written and interpreted. 

The syntax is mostly derived from C and C++. 

Unlike C++, Java is almost exclusively an 

object-oriented language. There are no global 

functions or variables, all code belongs to 

classes and all values are objects. The only 

exception is the primitive types, which are not 

represented by a class instance due to 

performance reasons (though can be 

automatically converted to objects and 

vice-versa via autoboxing). Some features like 

operator overloading or unsigned integer types 

are omitted to simplify the language and to 

avoid possible programming mistakes. 

A snippet of Java code with keywords highlighted in blue and bold font 

Java syntax is constantly improved in major JDK releases. The last significant addition happened in J2SE 5.0, 

which introduced such features as generics and annotations. 

Basics 

Identifier 

An identifier is the name of an element in the code. There are certain standard naming conventions to follow when 

selecting names for elements. Identifiers in Java are case-sensitive. 

An identifier can contain: 

• Any Unicode character that is a letter (including numeric letters like Roman numerals) or digit. 

• Currency sign (such as $). 

• Connecting punctuation character (such as _). 

An identifier cannot: 

• start with a digit. 

• be equal to a reserved keyword, null literal or boolean literal. 

Keywords


[1] Keyword was introduced in J2SE 1.4 

[2] Keyword is not used 



Literals 

abstract continue for new switch 

assert [1] default 

goto [2] package synchronized 

boolean do if private this 

break double implements protected throw 

byte else import public throws 

case 

enum [3] instanceof return transient 

catch extends int short try 

char final interface static void 

class finally long 

strictfp [4] volatile 

const [2] float native super while 

octal 0365, 0[0..7]* 

Integers 

hexadecimal 0xF5, 0x[0..9, A..F, a..f]* 

decimal 245, [1..9][0..9]* 

Floating-point values 

float 23.5F, 23.5f; 1.72E3F, 1.72E3f, 1.72e3F, 1.72e3f 

double 23.5, 23.5D, 23.5d; 1.72E3, 1.72E3D, ... 

Character literals 

char 'a', 'Z', '\u0231' 

boolean true, false 

null reference null 

String "Hello, world" 

Boolean literals 

null literal 

String literals 

Characters escapes in strings 

Unicode character \u followed by the hexadecimal unicode code point (up to \uFFFF) 

Octal escape Octal number not exceeding 377, preceded by backslash (e.g. \352) 

Line feed \n 

Carriage return \r 

Form feed \f 

Backslash \\ 

Single quote \'


Double quote \" 

Tab \t 

Backspace \b 

Integer literals are of int type by default unless long type is specified by appending L or l suffix to the literal, e.g. 

367L. 

Variables 

Variables are identifiers associated with values. They are declared by writing the variable's type and name, and are 

optionally initialized in the same statement by assigning a value. 

int myInt; /* Declaring an uninitialized variable called 'myInt', 

of type 'int' */ 

myInt = 35; // Initializing the variable 

int myInt = 35; // Declaring and initializing the variable at the same time 

Multiple variables of the same type can be declared and initialized in one statement using comma as a delimiter. 

int a, b; // Declaring multiple variable of the same type 

int a = 2, b = 3; // Declaring and initializing multiple variables of the same type 

Code blocks 

The operators { ... } are used to signify a code block and a new scope. Class members and the body of a method are 

examples of what can live inside these braces in various contexts. 

Inside of method bodies you can use the braces to create new scopes like so: 

void doSomething() { 

} 

int a; 

{ 

} 

a = 2; 

int b; 

a = 1; 

b = 3; // Will fail because the variable is declared in an inner scope. 

Comments 

Java has three kinds of comments: traditional comments, end-of-line comments and documentation comments. 

Traditional comments start with /* and end with */, they may span across multiple lines. This type of comments was 

derived from C and C++. 

/* This is a multi-line comment. 

It may occupy more than one line. */ 

End-of-line comments start with // and extend to the end of the current line. This comment type is also present in 

C++ and in modern C.


// This is an end-of-line comment 

Documentation comments are processed by Javadoc tool to generate documentation from source files. This type of 

comments is identical to traditional comments, except it starts with /** and follows conventions defined by the 

Javadoc tool. Technically these comments are a special kind of traditional comments and they are not specifically 

defined in the language specification. 

/** 

* This is a documentation comment. 

* 

* @author John Doe 

*/ 

Program structure 

A Java application consists of classes and their members. Classes exist in packages but can also be nested inside 

other classes. 

main method 

Whether it is a console or a graphical interface application the program must have an entrypoint of some sort. The 

entrypoint of the Java application is the main method. There can be more than one class with main method, but the 

main class is always defined externally (e.g. in a manifest file). The method must be static and is passed 

command-line arguments as an array of strings. Unlike C++ or C# it never returns a value and must return void. 


} 

Packages 

Packages are a part of a class name and they are used to group and/or distinguish named entities from other ones. 

Another purpose of packages is to govern code access together with access modifiers. 

java.lang.InputStream // InputStream is a class in java.lang package 

A package is declared at the start of the file like this: 

package myapplication.mylibrary; 

public class MyClass { 

} 

Classes must be placed in the files with the same name and java extension and put into nested folders 

corresponding to the package name. The above class myapplication.mylibrary.MyClass will have the following path: 

"myapplication/mylibrary/MyClass.java".


import statement 

The import statement loads a specific class or classes from a referenced package. It must be placed at the top of a 

code file after the package declaration. 

import java.io.InputStream; /*Now it is allowed to use InputStream 

class without referencing its full name including the package*/ 

import java.util.*; /*This is a star import which loads all 

classes contained in java.util package*/ 

Since J2SE 5.0 it is allowed to do static imports, which allows to access members (fields and methods) defined in the 

imported class as public static without specifying the class name: 

import static java.lang.System.out; 


} 


} 

Operators 

out.println("Hello World!"); /*Without the static import it would 

be required to write "System.out" instead of just "out".*/ 

Operators in Java are mostly similar to those in C++. There's no delete operator due to garbage collection 

mechanisms in Java and no operations on pointers since Java does not support them, another difference is that Java 

has unsigned right shift operator (>>>). Operators in Java cannot be overloaded. 

Precedence Operator Description Associativity 

1 () Method invocation Left-to-right 

[] Array access 

. Class member selection 

2 ++ -- Postfix increment and decrement 

3 ++ -- Prefix increment and decrement Right-to-left 

+ - Unary plus and minus 

! ~ Logical NOT and bitwise NOT 

(type) Type cast 

new Class instance or array creation


Control structures 

4 * / % Multiplication, division, and modulus (remainder) Left-to-right 

5 + - Addition and subtraction 

+ String concatenation 

6 > >>> Bitwise left shift, signed right shift and unsigned right shift 

7 < >= Relational “greater than” and “greater than or equal to” 

instanceof Type comparison 

8 == != Relational “equal to” and “not equal to” 

9 & Bitwise and logical AND 

10 ^ Bitwise and logical XOR (exclusive or) 

11 | Bitwise and logical OR (inclusive or) 

12 && Logical conditional-AND 

13 || Logical conditional-OR 

14 c ? t : f Ternary conditional (see ?:) Right-to-left 

15 = Simple assignment 

Conditional statements 

if statement 

+= -= Assignment by sum and difference 

*= /= %= Assignment by product, quotient, and remainder 

= >>>= Assignment by bitwise left shift, signed right shift and unsigned right shift 

&= ^= |= Assignment by bitwise AND, XOR, and OR 

if statements in Java are similar to those in C and use the same syntax: 

if (i == 3) doSomething(); 

if statement may include optional else block, in which case it becomes an if-then-else statement: 

if (i == 2) 

else 

doSomething(); 

doSomethingElse(); 

Like C, else-if construction does not involve any special keywords, it is formed as a sequence of separate if-then-else 

statements: 

if (i == 3) { 


} else if (i == 2) { 

doSomethingElse(); 

} else { 

} 

doSomethingDifferent();


switch statement 

Switch statements in Java can use byte, short, char, and int primitive data types or their corresponding wrapper types. 

It is also possible to use enum types. Strings or other objects cannot be used in switch statements. 

Possible values are listed using case labels. These labels in Java may contain only constants (including enum 

constants). Execution will start after the label corresponding to the expression inside the brackets. An optional 

default label may be present to declare that the following it code will be executed if none of the case labels 

correspond to the expression. 

Code for each label ends with the break keyword. It is possible to omit it causing the execution to proceed to the next 

label, however, a warning will be usually reported during compilation. 

switch (ch) { 

} 

case 'A': 

doSomething(); // Triggered if ch == 'A' 

break; 

case 'B': 

case 'C': 

doSomethingElse(); // Triggered if ch == 'B' or ch == 'C' 

break; 

default: 

doSomethingDifferent(); // Triggered in any other case 

break; 

Iteration statements 

Iteration statements are statements that are repeatedly executed when a given condition is evaluated as true. Since 

J2SE 5.0 Java has four forms of such statements. 

while loop 

In the while loop the test is done before each iteration. 

while (i < 10) { 

} 


do ... while loop 

In the do ... while loop the test is done after each iteration. Consequently, the code is always executed at least once. 

// doSomething() is called at least once 

do { 


} while (i < 10);


for loop 

for loops in Java include an initializer, a condition and a counter expression. It is possible to include several 

expressions of the same kind using comma as delimiter. However, unlike C, comma is just a delimiter and not an 

operator. 

for (int i = 0; i < 10; i++) { 

} 


// A more complex loop using two variables 

for (int i = 0, j = 9; i < 10; i++, j -= 3) { 

} 


Like C, all three expressions are optional, the following loop will be infinite: 

for (;;) { 

} 


Enhanced for loop 

Enhanced for loops have been available since J2SE 5.0. This type of loop uses built-in iterators over arrays and 

collections to return each item in the given collection. Every element will be returned and reachable in the context of 

the code block. When the block has been executed the next item will be returned until there are no items remaining. 

Unlike C# this kind of loop does not involve a special keyword but instead uses a different notation style. 

for (int i : intArray) { 

} 

doSomething(i); 

Jump statements 

Labels 

Labels are given points in code used by break and continue statements. Despite the presence of the goto keyword, it 

cannot be used to jump to specific points in the code. 

start: 

someMethod(); 

break statement 

The break statement breaks out of the closest loop or switch statement. Execution continues in the statement after the 

terminated statement, if any. 

for (int i = 0; i < 10; i++) { 

} 

while (true) { 

} 

break; 

// Will break to this point 

It is possible to break out of the outer loop using labels:


outer: 

for (int i = 0; i < 10; i++) { 

} 

while (true) { 

} 

break outer; 

// Will break to this point 

continue statement 

The continue statement discontinues the current iteration of the current control statement and begins the next 

iteration. The following while loop in the code above reads characters by calling getChar(), skipping the statements 

in the body of the loop if the characters are spaces: 

int ch; 

while (ch = getChar()) { 

} 

if (ch == ' ') 

continue; // Skips the rest of the while-loop 

// Rest of the while-loop, will not be reached if ch == ' ' 


Labels can be specified in continue statements, as they can in break statements: 

outer: 

for (String str : stringsArr) { 

} 

char[] strChars = str.toCharArray(); 

for (char ch : strChars) { 

} 

if (ch == ' ') { 

} 

return statement 

/* Continues the outer cycle and the next 

string is retrieved from stringsArr */ 

continue outer; 

doSomething(ch); 

The return statement is used to end method execution and to return a value. A value returned by the method is 

written after the return keyword. If the method returns anything but void, it must use the return statement to return 

some value. 

void doSomething(boolean streamClosed) { 

} 

// If streamClosed is true, execution is stopped 

if (streamClosed) { 

} 

return; 

readFromStream();


int calculateSum(int a, int b) { 

} 

int result = a + b; 

return result; 

return statement ends execution immediately, except for one case: if the statement is encountered within a try block 

and it is complemented by a finally, control is passed to the finally block. 

void doSomething(boolean streamClosed) { 

} 

try { 

if (streamClosed) { 

} 

return; 

readFromStream(); 

} finally { 

} 

/* Will be called last even if 

readFromStream() was not called */ 

freeResources(); 

Exception handling statements 

try ... catch ... finally statements 

Exceptions are managed within try ... catch blocks. 

try { 

// Statements which may throw exceptions 

methodThrowingExceptions(); 

} catch (Exception ex) { 

// Exception caught and handled here 

reportException(ex); 

} finally { 

} 

// Statements always executed after the try/catch blocks 

freeResources(); 

The statements within the try block are executed, and if any of them throws an exception, execution of the block is 

discontinued and the exception is handled by the catch block. There may be multiple catch blocks, in which case the 

first block with an exception variable whose type matches the type of the thrown exception is executed. 

If no catch block matches the type of the thrown exception, the execution of the outer block (or method) containing 

the try ... catch statement is discontinued, and the exception is passed up and outside the containing block (or 

method). The exception is propagated upwards through the call stack until a matching catch block is found within 

one of the currently active methods. If the exception propagates all the way up to the top-most main method without 

a matching catch block being found, a textual description of the exception is written to the standard output stream. 

The statements within the finally block are always executed after the try and catch blocks, whether or not an 

exception was thrown and even if a return statement was reached. Such blocks are useful for providing clean-up code 

that is guaranteed to always be executed.


The catch and finally blocks are optional, but at least one or the other must be present following the try block. 

throw statement 

throw statement is used to throw an exception and end method execution. Thrown exception instance is written after 

the throw statement. 

void methodThrowingExceptions(Object obj) { 

} 

if (obj == null) { 

} 

// Throws exception of NullPointerException type 

throw new NullPointerException(); 

// Will not be called if obj was null 

doSomethingWithObject(obj); 

Thread concurrency control 

Unlike C++, Java has built-in tools for multi-thread programming. For the purposes of thread synchronization the 

synchronized statement is included in Java language. 

To make a code block synchronized, it is preceded by the synchronized keyword followed by the lock object inside 

the brackets. When the executing thread reaches the synchronized block, it acquires a mutual exclusion lock, 

executes the block, then releases the lock. No threads may enter this block until the lock is released. Any non-null 

reference type may be used as the lock. 

/* Acquires lock on someObject. It must be of 

a reference type and must be non-null */ 

synchronized(someObject) { 

} 

// Synchronized statements 

assert statement 

assert statements have been available since J2SE 1.4. This type of statements is used to make assertions in the source 

code, which can be turned on and off during execution for specific classes or packages. To declare an assertion the 

assert keyword is used followed by a conditional expression. If it evaluates to false during when the statement is 

executed, an exception is thrown. This statement may include a colon followed by another expression, which will act 

as the exception's detail message. 

// If n equals 0, AssertionError is thrown 

assert n != 0; 

/* If n equals 0, AssertionError will be thrown 

with the message after the colon */ 

assert n != 0 : "n was equal to zero";


Primitive types 

Primitive types in Java include integer types, floating-point numbers, UTF-16 code units and a boolean type. There 

are no unsigned types in Java except char type, which is used to represent UTF-16 code units. The lack of unsigned 

types is offset by introducing unsigned right shift operation (>>>), which is not present in C++. Nevertheless, 

criticisms have been levelled about the lack of compatibility with C and C++ this causes. [1] 

Primitive Types 

Type Name Wrapper class Value Range Size Default 

byte java.lang.Byte integer −128 through +127 8-bit (1-byte) 0 

short java.lang.Short integer −32,768 through +32,767 16-bit 

int java.lang.Integer integer −2,147,483,648 through +2,147,483,647 32-bit 

long java.lang.Long integer −9,223,372,036,854,775,808 through 

+9,223,372,036,854,775,807 

float java.lang.Float floating point number ±1.401298E−45 through ±3.402823E+38 32-bit 

double java.lang.Double floating point number ±4.94065645841246E−324 through 

±1.79769313486232E+308 

(2-byte) 

(4-byte) 

64-bit 

(8-byte) 

(4-byte) 

64-bit 

(8-byte) 

boolean java.lang.Boolean Boolean true or false 8-bit (1-byte) false 

char java.lang.Character UTF-16 code unit (BMP 

character 

or a part of a surrogate pair) 

'\u0000' through '\uFFFF' 16-bit 

(2-byte) 

0 

0 

0 

0.0 

0.0 

Value 

'\u0000' 

char does not necessarily correspond to a single character. It may represent a part of a surrogate pair, in which case 

Unicode code point is represented by a sequence of two char values. 

Boxing and unboxing 

This language feature was introduced in J2SE 5.0. Boxing is the operation of converting a value of a primitive type 

into a value of a corresponding reference type, which serves as a wrapper for this particular primitive type. Unboxing 

is the reverse operation of converting a value of a reference type (previously boxed) into a value of a corresponding 

primitive type. Neither operation requires an explicit type cast. 

Example: 

int foo = 42; // Primitive type 

Integer bar = foo; /* foo is boxed to bar, bar is of Integer type, 

which serves as a wrapper for int */ 

int foo2 = bar; // Unboxed back to primitive type


Reference types 

Reference types include class types, interface types, and array types. When the constructor is called an object is 

created on the heap and a reference is assigned to the variable. When a variable of an object gets out of scope the 

reference is broken and when there are no references left the object gets marked as garbage. The garbage collector 

will then soon collect and destroy it. 

A reference variable is null when it does not reference any object. 

Arrays 

Arrays in Java are created at runtime, just like class instances. Array length is defined at creation and cannot be 

changed. 

int[] numbers = new int[5]; 

numbers[0] = 2; 

numbers[1] = 5; 

int x = numbers[0]; 

Initializers 

// Long syntax 

int[] numbers = new int[5] {20, 1, 42, 15, 34}; 

// Short syntax 

int[] numbers2 = {20, 1, 42, 15, 34}; 

Multi-dimensional arrays 

In Java multi-dimensional arrays are represented as arrays of arrays. Technically they are represented by arrays of 

references to another arrays. 

int[][] numbers = new int[3][3]; 

number[1][2] = 2; 

int[][] numbers2 = {{2, 3, 2}, {1, 2, 6}, {2, 4, 5}}; 

Due to the nature of the multi-dimensional arrays, sub-arrays may vary in length, so multi-dimensional arrays are not 

bound to be rectangular unlike C: 

int[][] numbers = new int[2][]; //Initialization of the first dimension 

only 

numbers[0] = new int[3]; 

numbers[1] = new int[2];


Classes 

Classes are fundamentals of an object-oriented language such as Java. They contain members that store and 

manipulate data in real-life-like way. Classes are divided into top-level and nested. Nested classes include member 

classes, local classes and anonymous classes. 

Declaration 

Top-level class class Foo { 

// Class members 

} 

Member class class Foo { // Top-level class 

Local class class Foo { 

} 

class Bar { // Nested class 

} 

void bar() { 

Anonymous class class Foo { 

Initialization 

} 

} 

} 

class Foobar {// Local class within a method 

} 

void bar() { 

} 

new Object() {// Creation of a new anonymous class extending Object 

}; 

To use non-static members of the class it must be instantiated. It is done by using the new keyword and calling the 

class constructor. 

Foo foo = new Foo(); 

Accessing members 

Members of both instances and static classes are accessed with the . operator. 

Accessing an instance member 

Instance members can be accessed through the name of a variable. 

String foo = "Hello"; 

String bar = foo.toUpperCase(); 

Accessing a static class member 

Static members are accessed by using the name of the class or any other type. This does not require the creation of a 

class instance. Static members are declared using the static modifier. 

public class Foo { 

} 

public static void doSomething() { 

} 

// Calling the static method


Foo.doSomething(); 

Modifiers 

Modifiers are keywords used to modify declarations of types and type members. Most notably there is a sub-group 

containing the access modifiers. 

• abstract - Specifies that a class only serves as a base class and cannot be instantiated. 

• static - Used only for member classes, specifies that the member class does not belong to a specific instance of 

the containing class. 

• final - Classes marked as final cannot be extended from and cannot have any subclasses. 

• strictfp - Specifies that all floating-point operations must be carried out conforming to IEEE 754 and forbids 

using enhanced precision to store intermediate results. 

Access modifiers 

The access modifiers, or inheritance modifiers, set the accessibility of classes, methods, and other members. 

Members marked as public can be reached from anywhere. If a class or its member does not have any modifiers, 

default access is assumed. 

public class Foo { 

} 

int do() { 

} 

return 0; 

private class Bar { 

} 

The following table shows whether code within a class has access to the class or method depending on the accessing 

class location and the modifier for the accessed class or class member: 

Modifier Same 

class 

Other class inside the same 

package 

Subclass inside another 

package 

Non-subclass inside another 

private yes no no no 

default (package 

private) 

package 

yes yes no no 

protected yes yes yes no 

public yes yes yes yes 

Constructors 

A constructor is a special method that is called when an object is initialized. Its purpose is to initialize the members 

of the object. The main differences between constructors and ordinary methods are that constructors are named after 

the class and never return anything. They may take parameters as any common method. 

class Foo { 

} 

Foo() { 

} 

//Initialization


There are also static constructors, whose purpose is to initialize static fields when the class is initialized. They are 

declared using static keyword: 

class Foo { 

} 

static { 

} 

//Initialization 

Since Java has a garbage collection mechanism, there are no destructors. However, every object has a finalize() 

method called prior to garbage collection which could be overridden to implement finalization. 

Methods 

All the statements in Java must reside within methods. Methods are similar to functions except they belong to 

classes. A method has a return value, a name and usually some parameters initialized when it is called with some 

arguments. Similar to C++, methods which return nothing have return type declared as void. Unlike in C++, methods 

in Java are not allowed to have default argument values and methods are usually overloaded instead. 

class Foo { 

} 

int bar(int a, int b) { 

} 

return (a * 2) + b; 

int bar(int a) { /* Overloaded method with the same name but 

} 

return a * 2; 

different set of arguments */ 

A method is called using . notation on a specific variable, or as in the case of static methods, the name of a type. 

Foo foo = new Foo(); 

int result = foo.bar(7, 2); // Non-static method is called on foo 

int finalResult = Math.abs(result); // Static method call 

Methods throwing exceptions use throws keyword to indicate that. All checked exceptions are mandatory to be 

declared. 

void openStream() throws IOException { // Indicates that IOException may be thrown 

}


Modifiers 

• abstract - Abstract methods can be present only in abstract classes, such methods have no body and must be 

overridden in a subclass unless it is abstract itself. 

• static - Makes the method static and accessible without creation of a class instance. However static methods 

cannot access non-static members in the same class. 

• final - Declares that the method cannot be overridden in a subclass. 

• native - Indicates that this method is implemented through JNI in platform-dependent code. Actual 

implementation happens outside Java code, and such methods have no body. 

• strictfp - Declares strict conformance to IEEE 754 in carrying out floating-point operations. 

• synchronized - Declares that a thread executing this method must acquire monitor. For synchronized methods the 

monitor is the class instance or java.lang.Class if the method is static. 

• Access modifiers - Identical to those used with classes. 

Varargs 

This language feature was introduced in J2SE 5.0. The last argument of the method may be declared as a variable 

arity parameter, in which case the method becomes a variable arity method (as opposed to fixed arity methods) or 

simply varargs method. This allows to pass a variable number of value of declared type to the method as parameters. 

These values will be available inside the method as an array. 

void printReport(String header, int... numbers) { //numbers represents varargs 

} 

System.out.println(header); 

for (int num : numbers) { 

} 

System.out.println(num); 

// Calling varargs method 

printReport("Report data", 74, 83, 25, 96); 

Fields 

Fields, or class variables, can be declared inside the class body to store data. 

class Foo { 

} 

double bar; 

Fields can be initialized directly when declared. 

class Foo { 

} 

double bar = 2.3;


Modifiers 

• static - Makes the field a static member. 

• final - Allows the field to be initialized only once in a constructor. 

• transient - Indicates that this field will not be stored during serialization. 

• volatile - If a field is declared volatile, it is ensured that all threads see a consistent value for the variable. 

• Access modifiers - Identical to those used with classes 

Inheritance 

Classes in Java may only inherit from one class. A class may derive from any class that is not marked as final. 

Inheritance is declared using extends keyword. A class may reference itself using this keyword and its direct 

superclass using super keyword. 

class Foo { 

} 

class Foobar extends Foo { 

} 

If a class does not specify the superclass, it implicitly inherits from java.lang.Object class. Thus all classes in Java 

are subclasses of Object class. 

Overriding methods 

Unlike C++, all non-final methods in Java are virtual and can be overridden by the inheriting classes. 

class Operation { 

} 

public int do() { 

} 

return 0; 

class NewOperation extends Operation { 

} 

public int do() { 

} 

Abstract classes 

return 1; 

Abstract classes are classes that only serve as templates and cannot be instantiated. Otherwise it is just like an 

ordinary class. 

Only abstract classes are allowed to have abstract methods. Abstract methods do not have any implementation and 

must be overridden by a subclass unless it is not abstract itself. 

abstract class Mammal { 

} 

public abstract void walk(); 

class Human extends Mammal {


} 

public void walk() { 

} 

final classes 

The final modifier can be an optional modifier for classes to make them uninheritable. 

final class Foo { // This class cannot be extended by any other class 

} 

Enumerations 

This language feature was introduced in J2SE 5.0. Technically enumerations are a kind of class which contains enum 

constants in its body. Each enum constant defines an instance of the enum type. Enumeration classes cannot be 

instantiated anywhere except in the enumeration class itself. 

enum Season { 

} 

WINTER, SPRING, SUMMER, AUTUMN 

Enum constants are allowed to have constructors, which are called when the class is loaded: 

public enum Season { 

} 

WINTER("Cold"), SPRING("Warmer"), SUMMER("Hot"), AUTUMN("Cooler"); 

Season(String description) { 

} 

this.description = description; 

private final String description; 

public String getDescription() { 

} 

return description; 

Enumerations can have class bodies, in which case they are treated like anonymous classes extending the enum 

class: 

public enum Season { 

WINTER { 

}, 

String getDescription() {return "cold";} 

SPRING { 

}, 

String getDescription() {return "warmer";} 

SUMMER { 

}, 

String getDescription() {return "hot";}


} 

AUTUMN { 

}; 

Interfaces 

String getDescription() {return "cooler";} 

Interfaces are data structures that contain member definitions and not actual implementation. They are useful to 

define a contract between members in different types that have different implementations. Every interface is 

implicitly abstract. The only modifier allowed to use with interfaces apart from access modifiers is strictfp, which 

has the same effect as for classes. 

interface ActionListener { 

} 

int ACTION_ADD = 0; 

int ACTION_REMOVE = 1; 

void actionSelected(int action); 

Implementing an interface 

An interface is implemented by a class using the implements keyword. It is allowed to implement more than one 

interface, in which case they are written after implements keyword in a comma-separated list. Class implementing an 

interface must override all its methods, otherwise it must be declared as abstract. 

interface RequestListener { 

} 

int requestReceived(); 

class ActionHandler implements ActionListener, RequestListener { 

} 

void actionSelected(int action) { 

} 

public int requestReceived() { 

} 

//Calling method defined by interface 

RequestListener listener = new ActionHandler(); /*ActionHandler can be 

represented as RequestListener...*/ 

listener.requestReceived(); /*...and thus is known to implement 

requestReceived() method*/


Inheritance 

Interfaces can inherit from other interfaces just like classes. Unlike classes it is allowed to inherit from multiple 

interfaces. However, it is possible that several interfaces have a field with the same name, in which case it becomes a 

single ambiguous member, which cannot be accessed. 

/* Class implementing this interface must implement methods of both 

ActionListener and RequestListener */ 

interface EventListener extends ActionListener, RequestListener { 

} 

Annotations 

Annotations in Java are a way to embed metadata into code. This language feature was introduced in J2SE 5.0. 

Annotation types 

Java has a set of predefined annotation types, but it is allowed to define new ones. An annotation type declaration is 

a special type of an interface declaration. They are declared in the same way as the interfaces, except the interface 

keyword is preceded by the @ sign. All annotations are implicitly extended from java.lang.annotation.Annotation 

and cannot be extended from anything else. 

@interface BlockingOperations { 

} 

Annotations may have the same declarations in the body as the common interfaces, in addition they are allowed to 

include enums and annotations. The main difference is that abstract methods declarations must not have any 

parameters or throw any exceptions. Also they may have a default value, which is declared using the default 

keyword after the method name: 

@interface BlockingOperations { 

} 

boolean fileSystemOperations(); 

boolean networkOperations() default false; 

Usage of annotations 

Annotations may be used in any kind of declaration, whether it is package, class (including enums), interface 

(including annotations), field, method, parameter, constructor, or local variable. Also they can be used with enum 

constants. Annotations are declared using the @ sign preceding annotation type name, after which element-value 

pairs are written inside brackets. All elements with no default value must be assigned a value. 

@BlockingOperations(/*mandatory*/ fileSystemOperations = true, 

/*optional*/ networkOperationsPresent = true) 

void openOutputStream() { //Annotated method 

} 

Besides the generic form, there are two other forms to declare an annotation, which are shorthands. Marker 

annotation is a short form, it is used when no values are assigned to elements: 

@Unused // Shorthand for @Unused() 

void travelToJupiter() { 

}


The other short form is called single element annotation. It is used with annotations types containing only one 

element or in the case when multiple elements are present, but only one elements lacks a default value. In single 

element annotation form the element name is omitted and only value is written instead: 

/* Equivalent for @BlockingOperations(fileSystemOperations = true). 

networkOperations has a default value and 

does not have to be assigned a value */ 

@BlockingOperations(true) 

void openOutputStream() { 

} 

Generics 

Generics, or parameterized types, or parametric polymorphism is one of the major features introduced in J2SE 5.0. 

Before generics were introduced, it was required to declare all the types explicitly. With generics it became possible 

to work in a similar manner with different types without declaring the exact types. The main purpose of generics is to 

ensure type safety and to detect runtime errors during compilation. Unlike C#, information on the used parameters is 

not available at runtime due to type erasure. 

Generic classes 

Classes can be parameterized by adding a type variable inside angle brackets (< and >) following the class name. It 

makes possible the use of this type variable in class members instead of actual types. There can be more than one 

type variable, in which case they are declared in a comma-separated list. 

It is possible to limit a type variable to a subtype of some specific class or declare an interface that must be 

implemented by the type. In this case the type variable is appended by the extends keyword followed by a name of 

the class or the interface. If the variable is constrained by both class and interface or if there are several interfaces, 

the class name is written first, followed by interface names with & sign used as the delimiter. 

/* This class has two type variables, T and V. T must be 

a subtype of ArrayList and implement Formattable interface */ 

public class Mapper { 

} 

public void add(T array, V item) { 

} 

// array has add method because it is an ArrayList subclass 

array.add(item); 

When a variable of a parametrized type is declared or an instance is created, its type is written exactly in the same 

format as in the class header, except actual type is written in the place of the type variable declaration. 

/* Mapper is created for CustomList as T and Integer as V. 

CustomList must be a subclass of ArrayList and implement Formattable */ 

Mapper mapper = new Mapper(); 

When declaring a variable for a parametrized type, it is possible to use wildcards instead of explicit type names. 

Wildcards are expressed by writing ? sign instead of the actual type. It is possible to limit possible types to the 

subclasses or superclasses of some specific class by writing the extends keyword or the super keyword 

correspondingly followed by the class name.


/* Any Mapper instance with CustomList as the first parameter 

may be used regardless of the second one.*/ 

Mapper mapper; 

mapper = new Mapper(); 

mapper = new Mapper(); 

/* Will not accept types that use anything but 

a subclass of Number as the second parameter */ 

void addMapper(Mapper


} 

void addItem(Integer item) { 

} 

See also 


References 

[1] Owens, Sean. "Java and unsigned int, unsigned short, unsigned byte, unsigned long, etc. (Or rather, the lack thereof)" (http:/ / darksleep. com/ 

player/ JavaAndUnsignedTypes. html). . 

• Patrick Naughton, Herbert Schildt. Java 2: The Complete Reference, third edition. The McGraw-Hill Companies, 

1999. ISBN 0-07-211976-4 

• Vermeulen, Ambler, Bumgardner, Metz, Misfeldt, Shur, Thompson. The Elements of Java Style. Cambridge 

University Press, 2000. ISBN 0-521-77768-2 

• Gosling, James; Joy Bill; Steele, Guy; and Bracha, Gillad (2005). Java Language Specification (http:/ / java. sun. 

com/ docs/ books/ jls/ index. html) (3rd ed.). Addison-Wesley Professional. Retrieved 2008-12-03. 


• The Java Language Specification, Third edition (http:/ / java. sun. com/ docs/ books/ jls/ ) Authoritative 

description of the Java language 


Java: View Technologies and Frameworks 

Various Java Web frameworks have appeared in recent years. Some of them are in direct competition, while others 

are complementary technologies. It is therefore necessary to understand where exactly each technology/framework 

fits into the J2EE scheme of things. This page lists the View technologies. These are the frameworks which are used 

for defining the web pages and the server-side programs which handle the requests (clicks) generated by the web 

pages. 

At a glance 

HTTP Paradigm Component Paradigm Templating 

Struts Wicket Tiles 

Tapestry SiteMesh 

JSF Facelets 

• Struts is relatively easier to use for beginners because it contains the familiar HTTP paradigm of 

Request/Response. However, the Component based frameworks are architecturally superior, and usually 

recommended for creating more complex web applications. 

• Wicket, Tapestry and JSF are competing technologies. 

• Tiles is a templating framework which is designed to work with Struts. 

• SiteMesh can be used with any JSP. 

Click


• Facelets is designed to work with JSF. 

• Wicket and Tapestry have their own native templating. 

• Click uses HTML based velocity templates and plain old Java objects. JSP is optional. 

Servlet API 

• This is the foundation of almost all Java View technologies. 

• It provides the basic framework for writing Java classes, called 'Servlets' that can respond to HTTP Requests, 

JSP 

create Cookies and maintain Sessions. 

• Built on top of the Servlet API, JSP provides for a HTML centric Server programming model. 

• Java code is embedded in the JSP files and is executed when a request is received. 

Struts 

• Built on top of the Servlet API, Struts provides for decoupling between the Controller and the View. 

• Requests are received by a Java Class (Controller) which can decide which View to display. 

• The actual View is written as a JSP page. 

• An XML configuration file is used to specify the "Page Navigation", i.e. the flow of the request to the appropriate 

Controller, and which View to display based on the outcome of the Controller. 

• Competitor: Though Struts does not have any direct competitor in its league, Component View Technologies 

(like Wicket, Tapestry) are generally accepted as superior. 

Tiles 

• This is a HTML templating framework based on the "Composite" model. 

• It allows for the HTML page to be broken up into multiple pagelets, called Templates, Definitions and 

Composing pages. 

• At run time the pagelets are stitched together to generate the final HTML. Pages are written in JSP. 

• Competitor: SiteMesh 

SiteMesh 

• SiteMesh is a HTML templating framework based on the "Decoration" model. 

• It allows for the creation of a 'decoration' template which is then applied to any other HTML to generate a new 

HTML. 

• The newly generated HTML contains elements from the original HTML blended into the template. 

• This allows for the original HTML to be very simple and devoid of any formatting or layout specification. The 

template, in turn, is devoid of any actual information. 

• Blending the two allows for a consistent look and feel for all web pages. 

• Competitor: Tiles


Wicket 

• Wicket provides a 'Component' view technology - meaning the Request-Response Stateless paradigm of HTTP is 

abstracted away to give rise to an Object Oriented Stateful paradigm. 

• Pages now directly interact with Stateful Java Components on the server. 

• Components and their State are managed by the Wicket framework, freeing the application developer from having 

to use HttpSession directly to manage state themselves. 

• Further, Wicket provides for a clear separation of HTML markup from code, and there are no XML configuration 

files to manage. 

• Web page components are 'pushed' into the HTML markup from the code. 

• Competitor: Tapestry, JSF 

Tapestry 

• Tapestry provides a 'Component' view technology. 

• Classes are written as POJOs and Annotations are used to configure them as Tapestry components. 

• HTML components can directly refer to the component methods and attributes. 

• Competitor: Wicket, JSF 

References 

• Java Servlet Technology (http:/ / java. sun. com/ products/ servlet/ ) 

• JavaServer Pages Technology (http:/ / java. sun. com/ products/ jsp/ ) 

• Apache Struts 2 Documentation (http:/ / struts. apache. org/ 2. 1. 6/ docs/ home. html) 

• Apache Struts Tiles (http:/ / struts. apache. org/ 1. x/ struts-tiles/ ) 

• Click Framework Project Documentation (http:/ / incubator. apache. org/ click/ )

JavaBeans Activation Framework 201 

JavaBeans Activation Framework 

JavaBeans Activation Framework, or JAF, enables developers to: [1] 

determine the type of an arbitrary piece of data; encapsulate access to it; discover the operations available on 

it; and instantiate the appropriate bean to perform the operation(s). 

It also enables you to dynamically register types of arbitrary data and actions associated with particular kinds of data. 

Additionally, it enables a program to dynamically provide or retrieve JavaBeans that implement actions associated 

with some kind of data. 


• Java Technologies [2] 

References 

[1] JavaBeans Activation Framework (http:/ / java. sun. com/ javase/ technologies/ desktop/ javabeans/ jaf/ ). Retrieved 2010-07-06. 

[2] http:/ / java. sun. com/ javase/ technologies/ desktop/ javabeans/ jaf/ downloads/ index. html 

JavaThreads 

Simply put, a thread is a program's path of execution. Most programs written today run as a single thread, causing 

problems when multiple events or actions need to occur at the same time. Let's say, for example, a program is not 

capable of drawing pictures while reading keystrokes. The program must give its full attention to the keyboard input 

lacking the ability to handle more than one event at a time. The ideal solution to this problem is the seamless 

execution of two or more sections of a program at the same time. Threads allows us to do this. 

Multithreaded applications deliver their potent power by running many threads concurrently within a single program. 

From a logical point of view, multithreading means multiple lines of a single program can be executed at the same 

time, however, it is not the same as starting a program twice and saying that there are multiple lines of a program 

being executed at the same time. In this case, the operating system is treating the programs as two separate and 

distinct processes. Under Unix, forking a process creates a child process with a different address space for both code 

and data. However, fork() creates a lot of overhead for the operating system, making it a very CPU-intensive 

operation. By starting a thread instead, an efficient path of execution is created while still sharing the original data 

area from the parent. The idea of sharing the data area is very beneficial, but brings up some areas of concern that 

we'll discuss later. 

Creating threads 

Java's creators have graciously designed two ways of creating threads: implementing an interface and extending a 

class. Extending a class is the way Java inherits methods and variables from a parent class. In this case, one can only 

extend or inherit from a single parent class. This limitation within Java can be overcome by implementing interfaces, 

which is the most common way to create threads. (Note that the act of inheriting merely allows the class to be run as 

a thread. It is up to the class to start() execution, etc.) 

Interfaces provide a way for programmers to lay the groundwork of a class. They are used to design the requirements 

for a set of classes to implement. The interface sets everything up, and the class or classes that implement the 

interface do all the work. The different set of classes that implement the interface have to follow the same rules. 

There are a few differences between a class and an interface. First, an interface can only contain abstract methods 

and/or static final variables (constants). Classes, on the other hand, can implement methods and contain variables

JavaThreads 202 

that are not constants. Second, an interface cannot implement any methods. A class that implements an interface 

must implement all methods defined in that interface. An interface has the ability to extend from other interfaces, 

and (unlike classes) can extend from multiple interfaces. Furthermore, an interface cannot be instantiated with the 

new operator; for example, Runnable a=new Runnable(); is not allowed. 

javac 

Developer(s) Sun Microsystems 

Stable release 1.6.0_14 / May 28, 2009 

Operating 

system 


Type Compiler 

License GNU General Public License 

Website [1] 

javac (pronounced "java-see") is the primary Java compiler, included in the Java Development Kit (JDK) from Sun 

Microsystems. 

The compiler accepts source code conforming to the Java language specification (JLS) and produces bytecode 

conforming to the Java Virtual Machine Specification (JVMS). 

javac is itself written in Java. The compiler can also be invoked programmatically. [2] 

History 

On 13 November 2006, Sun's Java Virtual Machine (JVM) and Java Development Kit (JDK) were made available [3] 

under the GPL license (see Sun's OpenJDK Hotspot page [4] ). 

Since version 0.95, GNU Classpath, a free implementation of the standard class library for Java, supports compiling 

and running javac using the Classpath runtime (GIJ) and compiler (GCJ), and also allows one to compile the GNU 

Classpath class library, tools and examples with javac itself [5] . 

See also 

• Java compiler for a general presentation of Java compilers, and a list of other existing alternative compilers. 

• Java (programming language) 

• Java Platform 

• OpenJDK 


• Sun's OpenJDK javac page [6] 

• The Java Virtual Machine Specification [7] 

• JSR 199 [5] Java Compiler API Java Specification Request for invoking the Java compiler from a Java program

javac 203 

References 

[1] http:/ / java. sun. com/ javase/ downloads/ index. jsp 

[2] "[...]an application can access javac programmatically." Shawn Silverman (2002-08-30). JavaWorld - Java tip 131 "Java Tip 131: Make a 

statement with javac!" (http:/ / www. javaworld. com/ javatips/ jw-javatip131. html?page=1). JavaWorld.com. JavaWorld - Java tip 131. 


[3] Sun opens Java (feature story) (http:/ / www. sun. com/ 2006-1113/ feature/ story. jsp) 

[4] https:/ / openjdk. dev. java. net/ hotspot/ 

[5] "This release supports compiling and running the GPL OpenJDK javac compiler lala kamina[...]" "GNU Classpath 0.95 Announcement" 

(http:/ / www. gnu. org/ software/ classpath/ announce/ 20070423. html). . 

[6] https:/ / openjdk. dev. java. net/ compiler/ 

[7] http:/ / java. sun. com/ docs/ books/ vmspec/

JavaFX 204 

JavaFX 


Stable release 1.3 / April 22, 2010 

Operating 

system 

Java Runtime Environment 

Platform Cross-platform 

Available in JavaFX Script 

Type Rich Internet applications 

License EULA 

Website http:/ / javafx. com/ 

JavaFX is a Java platform for creating and delivering rich Internet applications that can run across a wide variety of 

connected devices. The current release (JavaFX 1.3, April 2010) enables building applications for desktop, browser 

and mobile phones. TV set-top boxes, gaming consoles, Blu-ray players and other platforms are planned. 

JavaFX builds on Java technology. To build JavaFX apps developers use a statically typed, declarative language 

called JavaFX Script; Java code can be integrated into JavaFX programs. JavaFX is compiled to Java bytecode, so 

JavaFX applications run on any desktop and browser that runs the Java Runtime Environment (JRE) and on top of 

mobile phones running Java ME. 

On desktop, the current release supports Windows XP, Windows Vista and Mac OS X operating systems. Beginning 

with JavaFX 1.2 Sun has released beta-releases for Linux and OpenSolaris. [1] 

On mobile, JavaFX is capable of running on multiple mobile operating systems, including Symbian OS, Windows 

Mobile, and proprietary real-time operating systems. 

Current release of JavaFX platform includes the following components: 

1. The JavaFX SDK: JavaFX compiler and runtime tools. Graphics, media web services, and rich text libraries 

2. NetBeans IDE for JavaFX: NetBeans with drag-and-drop palette to add objects with transformations, effects and 

animations plus set of samples and best practices. For Eclipse users there is a community-supported plugin hosted 

on Project Kenai 

3. Tools and plugins for creative tools (a.k.a. Production Suite): Plugins for Adobe Photoshop and Adobe Illustrator 

that can export graphics assets to JavaFX Script code, tools to convert SVG graphics into JavaFX Script code and 

preview assets converted to JavaFX from other tools 

Commentators have speculated JavaFX will compete on the desktop with Adobe Flash Player, Adobe AIR, 

OpenLaszlo, and Microsoft Silverlight. 

Technical highlights 

Common profile. JavaFX is based on the concept of a “Common profile” that is intended to span across all devices 

supported by JavaFX. This approach makes it possible for developers to use a common programming model while 

building an application targeted for both desktop and mobile devices and to share much of the code, graphics assets 

and content between desktop and mobile versions. To address the need for tuning applications on a specific class of 

devices, the JavaFX 1.1 platform includes APIs that are desktop or mobile-specific. For example JavaFX Desktop

JavaFX 205 

profile includes Swing and advanced visual effects. 

Drag-to-Install. From the point of view of the end user “Drag-to-Install” allows them to drag a JavaFX widget (or 

application residing in a website and is visible within the browser window) and drop it onto their desktop. The 

application will not lose its state or context even after the browser is closed. An application can also be re-launched 

by clicking on a shortcut that gets created automatically on the user's desktop. This behavior is enabled 

out-of-the-box by the Java applet mechanism and is leveraged by JavaFX from the underlying Java layer. Sun touts 

“Drag-to-Install” as opening up of a new distribution model and allowing developers to “break away from the 

browser”. 

Integrating graphics created with third-party tools. JavaFX includes a set of plug-ins for Adobe Photoshop and 

Illustrator that enable advanced graphics to be integrated directly into JavaFX applications. The plug-ins generate 

JavaFX Script code that preserves layers and structure of the graphics. Developers can then easily add animation or 

effects to the static graphics imported. There is also an SVG graphics converter tool (a.k.a. Media Factory) that 

allows for importing graphics and previewing assets after the conversion to JavaFX format. 

History 

JavaFX Script, the scripting component of JavaFX, began life as a project by Chris Oliver called F3. [2] 

Sun Microsystems first announced JavaFX at the JavaOne Worldwide Java Developer conference on May 2007. 

In May 2008 Sun Microsystems announced plans to deliver JavaFX for the browser and desktop by the third quarter 

of 2008, and JavaFX for mobile devices in the second quarter of 2009. Sun also announced a multi-year agreement 

with On2 Technologies to bring comprehensive video capabilities to the JavaFX product family using the company's 

TrueMotion Video codec. 

Since end of July 2008, developers could download a preview of the JavaFX SDK for Windows and Macintosh, as 

well as the JavaFX plugin for NetBeans 6.1. On December 4, 2008 Sun released JavaFX 1.0. 

JavaFX 1.1 

JavaFX for mobile development was finally made available as part of the JavaFX 1.1 release announced officially on 

February 12, 2009. 

JavaFX 1.2 

JavaFX 1.2 was released at JavaOne on June 2, 2009. This release introduced: [3] 

• Beta support for Linux and Solaris, 

• Built-in controls and layouts, 

• Skinnable CSS controls, 

• Built-in chart widgets, 

• JavaFX I/O management, masking differences between desktop and mobile devices, 

• Speed improvements.

JavaFX 206 

JavaFX 1.3 

JavaFX 1.3 was released on April 22, 2010. This release introduces [4] : 

• Performance improvements 

• Support of additional platforms 

• Improved support for user interface controls 

License 

There are currently various licenses for the modules that compose the JavaFX runtime: 

• The core JavaFX runtime is still proprietary software and its code has not yet been released to the public, [5] 

• The JavaFX compiler [6] and an older version of the 2D Scene graph [7] are released under a GPL v2 license, 

• The NetBeans plugin for JavaFX is dual licensed under GPL v2 and CDDL. [5] 

During development, Sun explained they will roll out their strategy for the JavaFX licensing model for JavaFX first 

release. [8] After the release, Jeet Kaul, Sun's Vice president for Client Software, explained that they will soon publish 

a specification for JavaFX and its associated file formats, and will continue to open source the JavaFX runtime, and 

decouple this core from the proprietary parts licensed by external parties. [9] 

See also 

• JavaFX Script 

• JavaFX Mobile 

• Lobo Web Browser, with JavaFX support 

• Curl RIA platform, a declarative programming language for web applications 

• UltraLightClient, a Java based approach for Rich Internet Applications 

Bibliography 

• Weaver, James L.; Gao, Weiqi; Chin, Stephen; Iverson, Dean (January 11, 2010). Pro JavaFX 2 Platform: A 

Definitive Guide to Script, Desktop, and Mobile RIA with Java Technology [10] . Apress. pp. 500. 

ISBN 1430268727. 

• Jordan, Lucas (December 17, 2009). JavaFX Special Effects: Taking Java RIA to the Extreme with Animation, 

Multimedia, and Game Elements [11] . Apress. pp. 300. ISBN 1430226234. 

• Morris, Simon (November 23, 2009). JavaFX in Action [12] . Manning. pp. 375. ISBN 1933988991. 

• Topley, Kim (October 12, 2009). JavaFX Developer's Guide [13] . Addison-Wesley Professional. pp. 640. 

ISBN 0321601653. 

• Weaver, James L.; Gao, Weiqi; Chin, Stephen; Iverson, Dean (June 22, 2009). Pro JavaFX Platform: Script, 

Desktop and Mobile RIA with Java Technology [14] . Apress. pp. 500. ISBN 1430218754. 

• Clarke, Jim; Connors, Jim; J. Bruno, Eric (June 15, 2009). JavaFX: Developing Rich Internet Applications [15] . 

Prentice Hall. pp. 384. ISBN 013701287X. 

• Anderson, Gail; Anderson, Paul (June 15, 2009). Essential JavaFX [16] . Prentice Hall. pp. 360. 

ISBN 0137042795. 

• Weaver, James L. (May 4, 2009). JavaFX Script: Dynamic Java Scripting for Rich Internet/Client-side 

Applications [17] . Apress. pp. 200. ISBN 1590599454.

JavaFX 207 



• Official JavaFX blog website [19] 

• java.sun.com website [20] 

• Sun.com - JavaFX [21] 

• OpenJFX website [22] 

• Sun.com - Learning JavaFX Script: An Introduction for Java Programmers [23] 

• Crash Course in Next-Gen RIA: AIR, Silverlight, and JavaFX [24] 

• Ellison at JavaOne: Myths About JavaFX, Android, and J2ME [25] 

• James Weaver's JavaFX blog [26] 

• A JavaOne 2009 talk about JavaFx + Groovy [27] 

• fxexperience.com - A blog on JavaFX with insights from core engineers on the JavaFX team and weekly news 

posts [28] 

• javaontop.com - JavaFx code examples [29] 

References 

[1] "Software and System Requirements for JavaFX Technology" (http:/ / java. sun. com/ javafx/ 1/ reference/ system-requirements-1-2. 

html#javafxsdk). . 

[2] Project name F3 (http:/ / blogs. sun. com/ chrisoliver/ entry/ f3) 

[3] Marinacci, Joshua (2009-06-09). "Top 5 Most Important Features in JavaFX 1.2" (http:/ / weblogs. java. net/ blog/ joshy/ archive/ 2009/ 06/ 

top_5_most_impo. html). . Retrieved 2009-06-12. 

[4] "JavaFX 1.3 Released, Improves User Experiences" (http:/ / blogs. sun. com/ javafx/ entry/ javafx_1_3_released_delivers). 2010-04-22. . 


[5] "JavaFX Downloads" (https:/ / openjfx. dev. java. net/ downloads. html). . Retrieved 2008-06-07. 

[6] "OpenJFX Compiler Project" (https:/ / openjfx-compiler. dev. java. net/ ). . Retrieved 2008-06-07. 

[7] "Project Scene Graph home" (https:/ / scenegraph. dev. java. net/ ). . Retrieved 2008-06-07. 

[8] "Will JavaFX technology be released in open source?" (http:/ / java. sun. com/ javafx/ faqs. jsp#2). . Retrieved 2008-06-07. "Sun will continue 

to engage the OpenJFX community as we release JavaFX products. This fall we will be rolling out our open source strategy for JavaFX 

technology concurrent with the release of version 1 of JavaFX Desktop" 

[9] Kaul, Jeet (2008-12-16). "JavaFX - the road ahead" (http:/ / blogs. sun. com/ meetjeet/ entry/ javafx_the_road_ahead). . Retrieved 

2009-01-03. "Sun is committed to open standards and open source, and specifications are coming soon(...)There are some dependencies on 

licensed code that cannot be open sourced. We are working towards decoupling the dependencies so that the non-proprietary portions can be 

open sourced. Currently the JavaFX compiler, Netbeans JavaFX plugin and Eclipse JavaFX plugin are already being developed in the open 

source. The scene graph is out in the open. We will put the core runtime out in the open over time." 



[12] http:/ / www. manning. com/ morris 

[13] http:/ / www. informit. com/ store/ product. aspx?isbn=0321648978 





[18] http:/ / www. javafx. com/ 

[19] http:/ / blogs. sun. com/ javafx 

[20] http:/ / java. sun. com/ javafx/ index. jsp 

[21] http:/ / www. sun. com/ software/ javafx/ 

[22] https:/ / openjfx. dev. java. net/ 

[23] http:/ / java. sun. com/ developer/ technicalArticles/ scripting/ javafxpart1/ 

[24] http:/ / www. devx. com/ RichInternetApps/ Article/ 35208/ 1954?pf=true 

[25] http:/ / java. sys-con. com/ node/ 994363 

[26] http:/ / learnjavafx. typepad. com/ 

[27] http:/ / canoo. com/ blog/ 2009/ 06/ 04/ dierks-talk-at-j1-javafx-groovy-beauty-productivity/ 

[28] http:/ / fxexperience. com/ 

[29] http:/ / www. javaontop. com/ index. php?option=com_content& view=article& id=66& Itemid=17/

Jawin 208 

Jawin 

Jawin is the abbreviation for the Java/Win32 integration project. It is a free, open source architecture for 

interoperation between Java and components exposed through Microsoft's Component Object Model (COM) or 

through Win32 Dynamic Link Libraries (DLLs). 

Jawin includes a code generator, Jawin Type Browser, supporting generation of stub code for scriptable as well as 

non-scriptable COM components. The code generator reads one or more type libraries, and automatically emits the 

Java stubs needed to call the component(s). The Jawin Type Browser is not (yet) able to generate code for DLL entry 

points, and not all parameter types are supported for COM components.

JExamples 209 

JExamples 

Industry Computer 

software 

Headquarters Oakland, CA 

Key people Pete Eakle 

Chris Webster 

Website 

jexamples.com [1] 

JExamples is a web-based, source code search engine for the Java language. It provides the ability to search the 

JExamples database for Java examples. The JExamples database contains the source code of Java open source 

projects. The search engine understands the semantics of Java, so the search yields more accurate results than a text 

search. JExamples also provides the ability to rate examples and the highest rated examples are shown first. 

Available since March, 2005, JExamples was the first public web site to allow searching of open source code. 

Products & services 

In addition to the web-based search engine, JExamples provides a plug-in for the firefox web browser. 

References 

• List of search engines 

• The JExamples About [2] page describes other advantages of JExamples compared to other source code search 

engines. 


• JExamples.com [3] 

References 

[1] http:/ / jexamples. com/ 

[2] http:/ / www. jexamples. com/ about. html 

[3] http:/ / www. jexamples. com

Jfig 210 

Jfig 

Developer(s) The jfig Team 

Operating 

system 


Type Vector graphics 

editor 

License shareware 

Website [1] 

Jfig is a 2D graphics and diagram editor based on the FIG file format. The user-interface of jfig is based on xfig, a 

popular graphics editor for the X11 window system. 

The jfig software is written in the Java programming language and can be used on notebooks, PCs, and workstations 

running Windows 2000/XP, Mac OS X, OS/2, and most versions of Linux and Unix. Due to the support of 

LaTeX-formatted text objects, jfig and xfig are often used to create diagrams for LaTeX and pdflatex documents. 

See also 

• List of vector graphics editors 

• Comparison of vector graphics editors 

• xfig 


• JFig homepage [1] 

• Fig file format [2] 

References 

[1] http:/ / tams-www. informatik. uni-hamburg. de/ applets/ jfig/ 

[2] http:/ / epb. lbl. gov/ xfig/ fig-format. html

Jikes 211 

Jikes 

Developer(s) IBM 

Stable release 1.22 / October 3, 2004 

Development status Unmaintained 


Type Java compiler 

License IBM Public License 

Website http:/ / jikes. sourceforge. 

net 

Jikes is an open source Java compiler written in C++. It is no longer being updated. 

The original version was developed by David L. "Dave" Shields and Philippe Charles at IBM but was quickly 

transformed into an open source project contributed to by an active community of developers. Initially hosted by 

IBM, the project has subsequently been transferred to SourceForge. Among its accomplishments, it was much faster 

in compiling small projects than Sun's own compiler, and provided more helpful warnings and errors. 

While the free software community needed free Java implementations, the GNU Compiler for Java became the most 

commonly used compiler. 

Project Status 

As of 2010 the project is no longer being actively developed [1] . The last 1.22 version was released in October 2004 

and partially supports Java 5.0 (with respect to new classes, but not new language features) [2] [3] . As no further 

versions were released since, Java SE 6 is not supported. 

See also 

• JikesRVM 


• Java compiler 


• Jikes Homepage [4] 

• Jikes RVM Homepage [4] 

• Jikes Archives, hosted by David Shields [5] 

References 

[1] No project CVS writes for the last 12 months (http:/ / sourceforge. net/ project/ stats/ detail. php?group_id=128803& ugn=jikes& type=cvs& 

mode=12months) 

[2] http:/ / sourceforge. net/ forum/ forum. php?forum_id=446830 

[3] http:/ / sourceforge. net/ project/ showfiles. php?group_id=128803 

[4] http:/ / jikesrvm. sourceforge. net/ 

[5] http:/ / daveshields. wordpress. com/ jikes-archives/

jnSynch 212 

jnSynch 

jnSynch is a light-weight file synchronization engine written in Java, and released as open source through GPL 

license. 

jnSynch was inspired in rsync and aims to provide an easy way to perform incremental/differential backups that are 

gentle to computer resources such as CPU usage, memory footprint and network bandwidth usage. 

As in PGP (Pretty Good Privacy) toolset, jnSynch can be thought as a Pretty Good Incremental File Sychronization 

Solution. 

It recursively synchronizes a source folder to a target folder. For that, it uses a very simple algorithm of comparing 

file's "last change date" attribute, between source and target folders, when the attribute is different between source 

and target, the engine replaces the target file with a fresh copy from the source and updates its "last changed date" 

attribute to exactly that of the source file. 

It was first released to public on September 6, 2008. It is actively hosted in SourceForge.net and code.google.com. It 

was later scheduled for deletion in code.google.com, so that it is centralized hosted in Sourceforge.Net. 


• jnSynch @ Sourceforge.Net [1] 

References 

[1] http:/ / sourceforge. net/ projects/ jnsynch/ 

Michael Kölling 

Michael Kölling is a professor and software developer currently with the Department of Computer Science at the 

University of Kent. Originally from Bremen, Germany, he is also a key member of the team that developed the BlueJ 

and Greenfoot Java learning environments. BlueJ is used in over 780 institutions world wide. [1] Kölling was also 

involved in the development of the Blue programming language [2] which was an object-oriented programming 

language that was developed especially for teaching. This lead on to what is now BlueJ. [3] BlueJ is currently being 

maintained by a joint team at the University of Kent at Canterbury and Deakin University in Melbourne, Australia. 

Launched in 2006, Greenfoot is an environment created for teaching programming and computer science concepts 

and is targeted for a demographic of 15 years old and up. The software is available in both English and German. 

Kölling co-wrote Objects First with Java (4th edition), with David J. Barnes, which has been translated into six 

languages, including German, Italian, French and Dutch. BlueJ is available in over a dozen languages. 

At the Association of Computing Machinery (ACM) Special Interest Group of Computer Science Education 

(SIGCSE) 2010 conference, held in Milwaukee, WI, his work was referenced as one of the most influential tools in 

the history of computer science education. This paper described Kölling's work on the Blue programming language, 

which preceded BlueJ. [4]


Microsoft Patent issue 

On the 22nd May 2005 Kölling made an entry to the BlueJ website [5] in response to a post on Dan Fernandez's blog 

(Lead Product Manager - Visual Studio Express). Fernandez described a new feature of Visual Studio 2005 that 

"helps you understand objects at Design Time, rather than runtime." [6] This feature had striking similarities to the 

way the object test bench functions within BlueJ. 

Kölling did not act on the discovery. However, on May 11, 2006 Microsoft attempted to patent [7] the idea. As the 

object test bench is essential to the way it functions, had Microsoft's patent been granted, it was likely that BlueJ 

would have had to have been discontinued. 

Kölling spoke to Microsoft, namely Jane Prey, and eventually the patent was dropped. [8] 

Fernandez posted a response on his blog where he says "the patent application was a mistake and one that should not 

have happened. To fix this, Microsoft will be removing the patent application in question. Our sincere apologies to 

Michael Kölling and the BlueJ community." [9] 

Miscellany 

• Kölling received a "Best PhD Thesis Award" in 2000 from The Computing Research and Education Association 

of Australasia [10] 

• Kölling was awarded the first Victorian Pearcey Award for his development of BlueJ. [11] 

• Kölling holds an honorary research position at Deakin University. 

• Kölling took part in a debate titled "Resolved: Objects First has failed" at SIGCSE in 2005. He believes that 

"Objects First has not failed. We have failed to do it". [12] 

Books 

• Michael Kölling, Introduction to Programming with Greenfoot: Object-Oriented Programming in Java with 

Games and Simulations, Pearson Education, August 2009, ISBN 978-0-13-603753-8. 

• David J. Barnes & Michael Kölling, Objects First with Java: A Practical Introduction using BlueJ, Prentice Hall / 

Pearson Education, 2008, ISBN 0-13-606086-2. 

• Bennedsen, Jens; Caspersen, Michael E.; Kölling, Michael (Eds.), Reflections on the Teaching of Programming 

Series: Lecture Notes in Computer Science , Vol. 4821. Springer, 2008, ISBN 978-3-540-77933-9. 

See also 

• BlueJ 

• Greenfoot 

• Blue programming language 


• Michael Kölling Professor of Computer Science [13] University of Kent 

References 

[1] "List of BlueJ users" (http:/ / www. bluej. org/ about/ users. html). . 

[2] "Blue website" (http:/ / www. cs. kent. ac. uk/ people/ staff/ mik/ blue/ ). . 

[3] "Blue status page (19 March 1999)" (http:/ / www. cs. kent. ac. uk/ people/ staff/ mik/ blue/ status. html). . 

[4] "SIGCSE2010 Influential Papers website" (http:/ / www. ics. uci. edu/ ~kay/ SIGCSE/ influential/ / ). . 

[5] "Comparison between VS and BlueJ's implementation of the object bench concept" (http:/ / www. bluej. org/ vs/ vs-bj. html). . 

[6] "Fernandez blog entry on the VS object test bench" (http:/ / blogs. msdn. com/ danielfe/ archive/ 2005/ 01/ 26/ 361375. aspx). .


[7] "Microsoft patent request" (http:/ / appft1. uspto. gov/ netacgi/ nph-Parser?Sect1=PTO2& Sect2=HITOFF& p=1& u=/ netahtml/ PTO/ 

search-bool. html& r=1& f=G& l=50& co1=AND& d=PG01& s1=20060101406. PGNR. & OS=DN/ 20060101406& RS=DN/ 

20060101406). . 

[8] "Blog article on Microsoft retraction of the patent" (http:/ / www. bluej. org/ mrt/ ?p=23). . 

[9] "Fernandez blog apology" (http:/ / blogs. msdn. com/ danielfe/ archive/ 2007/ 01/ 28/ update-response-to-bluej-patent-issues. aspx). . 

[10] "Best PhD Thesis Award" (http:/ / www. core. edu. au/ awards/ Prize Winners. html). . 

[11] "Victorian Pearcey Award" (http:/ / www. pearcey. org. au/ index. php/ 1999_Winner_Michael_Kolling). . 

[12] "Position summary from SIGCSE debate" (http:/ / www. cs. kent. ac. uk/ people/ staff/ mik/ presentations/ 

2005-SIGCSE-debate-position-summary. pdf) (PDF). . 

[13] http:/ / www. cs. kent. ac. uk/ people/ staff/ mik/ 

List of Java keywords 

In the Java programming language, a keyword is one of 50 reserved 

words [1] which have a predefined meaning in the language; because of 

this, programmers cannot use keywords as names for variables, 

methods, classes, or as any other identifier [2] . Due to their special 

functions in the language, most integrated development environments 

for Java use syntax highlighting to display keywords in a different 

color for easy identification. 

List 

The following is a list of the keywords in Java, along with brief 

descriptions of their functions: [2] 

abstract 

assert 

boolean 

break 

byte 

A snippet of Java code with keywords 

highlighted in blue and bold font 

The abstract keyword is used to declare a class or method to be abstract [3] . An abstract method has no 

implementation; all classes containing abstract methods must themselves be abstract, although not all abstract 

classes have abstract methods. Objects of a class which is abstract cannot be instantiated, but can be extended 

by other classes. All subclasses of an abstract class must either provide implementations for all abstract 

methods, or must also be abstract [4] . 

The assert keyword, which was added in J2SE 1.4 [2] [1] , is used to make an assertion—a statement which the 

programmer believes is always true at that point in the program. If assertions are enabled when the program is 

run and it turns out that an assertion is false, an AssertionError is thrown and the program terminates. This 

keyword is intended to aid in debugging [5] [6] . 

The boolean keyword is used to declare a field that can store a boolean value; that is, either true or false [7] [8] . 

This keyword is also used to declare that a method returns a value of type boolean [9] [3] . 

Used to resume program execution at the statement immediately following the current enclosing block or 

statement. If followed by a label, the program resumes execution at the statement immediately following the 

enclosing labeled statement or block. 

The byte keyword is used to declare a field that can store an 8-bit signed two's complement integer. [7] [8] This 

keyword is also used to declare that a method returns a value of type byte [9] [3] .


case 

catch 

char 

class 

const 

continue 

default 

do 

double 

else 

The case keyword is used to create individual cases in a switch statement; see switch [10] [11] . 

Defines an exception handler—a group of statements that are executed if an exception is thrown in the block 

defined by a preceding try keyword. The code is executed only if the class of the thrown exception is 

assignment compatible with the exception class declared by the catch clause. 

The char keyword is used to declare a field that can store a 16-bit Unicode character [7] [8] . This keyword is 

also used to declare that a method returns a value of type char [9] [3] . 

A type that defines the implementation of a particular kind of object. A class definition defines instance and 

class fields, methods, and inner classes as well as specifying the interfaces the class implements and the 

immediate superclass of the class. If the superclass is not explicitly specified, the superclass is implicitly 

Object. 

Although reserved as a keyword in Java, const is not used and has no function [2] [1] . 

Used to resume program execution at the end of the current loop body. If followed by a label, continue 

resumes execution at the end of the enclosing labeled loop body. 

The default can optionally be used in a switch statement to label a block of statements to be executed if no 

case matches the specified value; see switch [10] [11] . 

The do keyword is used in conjunction with while to create a do-while loop, which executes a block of 

statements associated with the loop and then tests a boolean expression associated with the while. If the 

expression evaluates to true, the block is executed again; this continues until the expression evaluates to 

false [12] [13] . 

The double keyword is used to declare a field that can hold a 64-bit double precision IEEE 754 floating-point 

number. [7] [8] This keyword is also used to declare that a method returns a value of type double [9] [3] . 

The else keyword is used in conjunction with if to create an if-else statement, which tests a boolean 

expression; if the expression evaluates to true, the block of statements associated with the if are evaluated; if it 

evaluates to false, the block of statements associated with the else are evaluated [14] [15] . 

enum (as of J2SE 5.0) 

extends 

A Java keyword used to declare an enumerated type. Enumerations extend the base class Enum. 

Used in a class declaration to specify the superclass; used in an interface declaration to specify one or more 

superinterfaces. Class X extends class Y to add functionality, either by adding fields or methods to class Y, or 

by overriding methods of class Y. An interface Z extends one or more interfaces by adding methods. Class X 

is said to be a subclass of class Y; Interface Z is said to be a subinterface of the interfaces it extends. 

Also used to specify an upper bound on a type parameter in Generics.


final 

finally 

float 

for 

goto 

if 

implements 

import 

instanceof 

int 

interface 

Define an entity once that cannot be changed nor derived from later. More specifically: a final class cannot be 

subclassed, a final method cannot be overridden, and a final variable can occur at most once as a left-hand 

expression. All methods in a final class are implicitly final. 

Used to define a block of statements for a block defined previously by the try keyword. The finally block is 

executed after execution exits the try block and any associated catch clauses regardless of whether an 

exception was thrown or caught, or execution left method in the middle of the try or catch blocks using the 

return keyword. 

The float keyword is used to declare a field that can hold a 32-bit single precision IEEE 754 floating-point 

number. [7] [8] This keyword is also used to declare that a method returns a value of type float [9] [3] . 

The for keyword is used to create a for loop, which specifies a variable initialization, a boolean expression, 

and an incrementation. The variable initialization is performed first, and then the boolean expression is 

evaluated. If the expression evaluates to true, the block of statements associated with the loop are executed, 

and then the incrementation is performed. The boolean expression is then evaluated again; this continues until 

the expression evaluates to false [16] . 

As of J2SE 5.0, the for keyword can also be used to create a so-called "enhanced for loop" [17] , which specifies 

an array or Iterable object; each iteration of the loop executes the associated block of statements using a 

different element in the array or Iterable [16] . 

Although reserved as a keyword in Java, goto is not used and has no function [2] [1] . 

The if keyword is used to create an if statement, which tests a boolean expression; if the expression evaluates 

to true, the block of statements associated with the if statement is executed. This keyword can also be used to 

create an if-else statement; see else [14] [15] . 

Included in a class declaration to specify one or more interfaces that are implemented by the current class. A 

class inherits the types and abstract methods declared by the interfaces. 

Used at the beginning of a source file to specify classes or entire Java packages to be referred to later without 

including their package names in the reference. Since J2SE 5.0, import statements can import static members 

of a class. 

A binary operator that takes an object reference as its first operand and a class or interface as its second 

operand and produces a boolean result. The instanceof operator evaluates to true if and only if the runtime type 

of the object is assignment compatible with the class or interface. 

The int keyword is used to declare a field that can hold a 32-bit signed two's complement integer [7] [8] . This 

keyword is also used to declare that a method returns a value of type int [9] [3] .


long 

native 

new 

package 

private 

protected 

public 

return 

short 

static 

Used to declare a special type of class that only contains abstract methods, constant (static final) fields and 

static interfaces. It can later be implemented by classes that declare the interface with the implements 

keyword. 

The long keyword is used to declare a field that can hold a 64-bit signed two's complement integer [7] [8] . This 

keyword is also used to declare that a method returns a value of type long [9] [3] . 

Used in method declarations to specify that the method is not implemented in the same Java source file, but 

rather in another language [3] . 

Used to create an instance of a class or array. 

A group of types. Packages are declared with the package keyword. 

The private keyword is used in the declaration of a method, field, or inner class; private members can only be 

accessed by other members of their own class [18] . 

The protected keyword is used in the declaration of a method, field, or inner class; protected members can 

only be accessed by members of their own class, that class's subclasses or classes from the same package [18] . 

The public keyword is used in the declaration of a class, method, or field; public classes, methods, and fields 

can be accessed by the members of any class [18] . 

Used to finish the execution of a method. It can be followed by a value required by the method definition that 

is returned to the caller. 

The short keyword is used to declare a field that can hold a 16-bit signed two's complement integer [7] [8] . This 

keyword is also used to declare that a method returns a value of type short [9] [3] . 

Used to declare a field, method or inner class as a class field. Classes maintain one copy of class fields 

regardless of how many instances exist of that class. static also is used to define a method as a class method. 

Class methods are bound to the class instead of to a specific instance, and can only operate on class fields. 

(Classes and interfaces declared as static members of another class or interface are actually top-level classes 

and are not inner classes.) 

strictfp (as of J2SE 1.2) 

super 

A Java keyword used to restrict the precision and rounding of floating point calculations to ensure 

portability [3] . 

Used to access members of a class inherited by the class in which it appears. Allows a subclass to access 

overridden methods and hidden members of its superclass. The super keyword is also used to forward a call 

from a constructor to a constructor in the superclass. 

Also used to specify a lower bound on a type parameter in Generics.


switch 

The switch keyword is used in conjunction with case and default to create a switch statement, which evaluates 

a variable, matches its value to a specific case, and executes the block of statements associated with that case. 

If no case matches the value, the optional block labelled by default is executed, if included [10] [11] . 

synchronized 

this 

throw 

throws 

transient 

try 

void 

volatile 

while 

Used in the declaration of a method or code block to acquire the mutex lock for an object while the current 

thread executes the code [3] . For static methods, the object locked is the class' Class. Guarantees that at most 

one thread at a time operating on the same object executes that code. The mutex lock is automatically released 

when execution exits the synchronized code. Fields, classes and interfaces cannot be declared as synchronized. 

Used to represent an instance of the class in which it appears. this can be used to access class members and as 

a reference to the current instance. The this keyword is also used to forward a call from one constructor in a 

class to another constructor in the same class. 

Causes the declared exception instance to be thrown. This causes execution to continue with the first enclosing 

exception handler declared by the catch keyword to handle an assignment compatible exception type. If no 

such exception handler is found in the current method, then the method returns and the process is repeated in 

the calling method. If no exception handler is found in any method call on the stack, then the exception is 

passed to the thread's uncaught exception handler. 

Used in method declarations to specify which exceptions are not handled within the method but rather passed 

to the next higher level of the program. All uncaught exceptions in a method that are not instances of 

RuntimeException must be declared using the throws keyword. 

Declares that an instance field is not part of the default serialized form of an object. When an object is 

serialized, only the values of its non-transient instance fields are included in the default serial representation. 

When an object is deserialized, transient fields are initialized only to their default value. 

Defines a block of statements that have exception handling. If an exception is thrown inside the try block, an 

optional catch block can handle declared exception types. Also, an optional finally block can be declared that 

will be executed when execution exits the try block and catch clauses, regardless of whether an exception is 

thrown or not. A try block must have at least one catch clause or a finally block. 

The void keyword is used to declare that a method does not return any value [9] . 

Used in field declarations to specify that the variable is modified asynchronously by concurrently running 

threads. Methods, classes and interfaces thus cannot be declared volatile. 

The while keyword is used to create a while loop, which tests a boolean expression and executes the block of 

statements associated with the loop if the expression evaluates to true; this continues until the expression 

evaluates to false. This keyword can also be used to create a do-while loop; see do [12] [13] .


Reserved words for literal values 

false 

null 

true 

See also 

A boolean literal value. 

A reference literal value. 

A boolean literal value. 

• Java annotation 

References 

• Gosling, James; Joy, Bill; Steele, Guy; and Bracha, Gillad (June 2005). Java Language Specification [47] (Third 

ed.). Addison-Wesley Professional. ISBN 978-0321246783. Retrieved 2008-12-03. 

• Flanagan, David (March 2005). Java in a Nutshell [19] (Fifth ed.). O'Reilly Media. ISBN 978-0-596-00773-7. 


References 

[1] Flanagan 2005, p. 20. 

[2] "Java Language Keywords" (http:/ / java. sun. com/ docs/ books/ tutorial/ java/ nutsandbolts/ _keywords. html). The Java Tutorials. Sun 

Microsystems, Inc.. February 14, 2008. . Retrieved 2008-12-02. 

[3] Flanagan 2005, pp. 66-67. 

[4] "Abstract Methods and Classes" (http:/ / java. sun. com/ docs/ books/ tutorial/ java/ IandI/ abstract. html). The Java Tutorials. Sun 


[5] "Programming With Assertions" (http:/ / java. sun. com/ j2se/ 1. 4. 2/ docs/ guide/ lang/ assert. html). Java 2 SDK, Standard Edition 

Documentation. Sun Microsystems, Inc.. 2002. . Retrieved 2008-12-06. 

[6] Flanagan 2005, pp. 60-64. 

[7] "Primitive Data Types" (http:/ / java. sun. com/ docs/ books/ tutorial/ java/ nutsandbolts/ datatypes. html). The Java Tutorials. Sun 


[8] Flanagan 2005, p. 22. 

[9] "Returning a Value from a Method" (http:/ / java. sun. com/ docs/ books/ tutorial/ java/ javaOO/ returnvalue. html). The Java Tutorials. Sun 


[10] "The switch Statement" (http:/ / java. sun. com/ docs/ books/ tutorial/ java/ nutsandbolts/ switch. html). The Java Tutorials. Sun 


[11] Flanagan 2005, pp. 46-48. 

[12] "The while and do-while Statements" (http:/ / java. sun. com/ docs/ books/ tutorial/ java/ nutsandbolts/ while. html). The Java Tutorials. Sun 


[13] Flanagan 2005, pp. 48-49. 

[14] "The if-then and if-then-else Statements" (http:/ / java. sun. com/ docs/ books/ tutorial/ java/ nutsandbolts/ if. html). The Java Tutorials. Sun 


[15] Flanagan 2005, pp. 44-46. 

[16] "The for Statement" (http:/ / java. sun. com/ docs/ books/ tutorial/ java/ nutsandbolts/ for. html). The Java Tutorials. Sun Microsystems, Inc.. 

February 14, 2008. . Retrieved 2008-12-03. 

[17] Flanagan 2005, pp. 50-54. 

[18] "Controlling Access to Members of a Class" (http:/ / java. sun. com/ docs/ books/ tutorial/ java/ javaOO/ accesscontrol. html). The Java 

Tutorials. Sun Microsystems, Inc.. February 14, 2008. . Retrieved 2008-12-03. 

[19] http:/ / oreilly. com/ catalog/ 9780596007737

Marker interface pattern 220 

Marker interface pattern 

The marker interface pattern is a design pattern in computer science, used with languages that provide run-time 

type information about objects. It provides a means to associate metadata with a class where the language does not 

have explicit support for such metadata. 

To use this pattern, a class implements a marker interface, and methods that interact with instances of that class test 

for the existence of the interface. Whereas a typical interface specifies functionality (in the form of method 

declarations) that an implementing class must support, a marker interface need not do so. The mere presence of such 

an interface indicates specific behavior on the part of the implementing class. Hybrid interfaces, which both act as 

markers and specify required methods, are possible but may prove confusing if improperly used. 

An example of the application of marker interfaces from the Java programming language is the Serializable 

interface. A class implements this interface to indicate that its non-transient data members can be written to an 

ObjectOutputStream. The ObjectOutputStream private method writeObject() contains a series of instanceof tests to 

determine writeability, one of which looks for the Serializable interface. If none of these tests pass, the method 

throws a NotSerializableException. 

Critique 

A major problem with marker interfaces is that an interface defines a contract for implementing classes, and that 

contract is inherited by all subclasses. This means that you cannot "unimplement" a marker. In the example given, if 

you create a subclass that you do not want to serialize (perhaps because it depends on transient state), you must 

resort to explicitly throwing NotSerializableException (per ObjectOutputStream docs). 

A better solution is for the language to support metadata directly: 

• Both the .NET framework and Java (as of Java 5 (1.5)) provide support for such metadata. In .NET, they are 

called "custom attributes", in Java they are called "annotations". Despite the different name, they are conceptually 

the same thing. They can be defined on classes, member variables, methods, and method parameters and may be 

accessed using reflection. 

• In Python, the term "marker interface" is common in Zope and Plone. Interfaces are declared as metadata and 

subclasses can use implementsOnly to declare they do not implement everything from their super classes. 

See also 

• Design markers for an expansion of this pattern.


Name mangling 

In software compiler engineering, name mangling (sometimes called name decoration) is a technique used to solve 

various problems caused by the need to resolve unique names for programming entities in many modern 

programming languages. 

It provides a way of encoding additional information in the name of a function, structure, class or another datatype in 

order to pass more semantic information from the compilers to linkers. 

The need arises where the language allows different entities to be named with the same identifier as long as they 

occupy a different namespace (where a namespace is typically defined by a module, class, or explicit namespace 

directive). 

Any object code produced by compilers is usually linked with other pieces of object code (produced by the same or 

another compiler) by a type of program called a linker. The linker needs a great deal of information on each program 

entity. For example, to correctly link a function it needs its name, the number of arguments and their types, and so 

on. 

C name decoration in Microsoft Windows 

Although name mangling is not generally required or used by languages that do not support function overloading 

(such as C and classic Pascal), they use it in some cases to provide additional information about a function. For 

example, compilers targeted at Microsoft Windows platforms support a variety of calling conventions, which 

determine the manner in which parameters are sent to subroutines and results returned. Because the different calling 

conventions are not compatible with one another, compilers mangle symbols with codes detailing which convention 

should be used. 

The mangling scheme was established by Microsoft, and has been informally followed by other compilers including 

Digital Mars, Borland, and GNU gcc, when compiling code for the Windows platforms. The scheme even applies to 

other languages, such as Pascal, D, Delphi, Fortran, and C#. This allows subroutines written in those languages to 

call, or be called by, existing Windows libraries using a calling convention different from their default. 

When compiling the following C examples: 

int _cdecl f (int x) { return 0; } 

int _stdcall g (int y) { return 0; } 

int _fastcall h (int z) { return 0; } 

32 bit compilers emit, respectively: 

_f 

_g@4 

@h@4 

In the stdcall and fastcall mangling schemes, the function is encoded as _name@X and @name@X 

respectively, where X is the number of bytes, in decimal, of the argument(s) in the parameter list (including those 

passed in registers, for fastcall). In the case of cdecl, the function name is merely prefixed by an underscore.


Name mangling in C++ 

C++ compilers are the most widespread and yet least standard users of name mangling. The first C++ compilers 

were implemented as translators to C source code, which would then be compiled by a C compiler to object code; 

because of this, symbol names had to conform to C identifier rules. Even later, with the emergence of compilers 

which produced machine code or assembly directly, the system's linker generally did not support C++ symbols, and 

mangling was still required. 

The C++ language does not define a standard decoration scheme, so each compiler uses its own. C++ also has 

complex language features, such as classes, templates, namespaces, and operator overloading, that alter the meaning 

of specific symbols based on context or usage. Meta-data about these features can be disambiguated by mangling 

(decorating) the name of a symbol. Because the name-mangling systems for such features are not standardized across 

compilers, few linkers can link object code that was produced by different compilers. 

Simple example 

Consider the following two definitions of f() in a C++ program: 

int f (void) { return 1; } 

int f (int) { return 0; } 

void g (void) { int i = f(), j = f(0); } 

These are distinct functions, with no relation to each other apart from the name. If they were natively translated into 

C with no changes, the result would be an error — C does not permit two functions with the same name. The C++ 

compiler therefore will encode the type information in the symbol name, the result being something resembling: 

int __f_v (void) { return 1; } 

int __f_i (int) { return 0; } 

void __g_v (void) { int i = __f_v(), j = __f_i(0); } 

Notice that g() is mangled even though there is no conflict; name mangling applies to all symbols. 

Complex example 

For a more complex example, we'll consider an example of a real-world name mangling implementation: that used 

by GNU GCC 3.x, and how it mangles the following example class. The mangled symbol is shown below the 

respective identifier name. 

namespace wikipedia 

{ 

class article 

{ 

public: 

std::string format (void); 

/* = _ZN9wikipedia7article6formatEv */ 

bool print_to (std::ostream&); 

/* = _ZN9wikipedia7article8print_toERSo */ 

class wikilink 

{ 

public: 

wikilink (std::string const& name);


} 

}; 

}; 

/* = _ZN9wikipedia7article8wikilinkC1ERKSs */ 

All mangled symbols begin with _Z (note that an underscore followed by a capital is a reserved identifier in C and 

C++, so conflict with user identifiers is avoided); for nested names (including both namespaces and classes), this is 

followed by N, then a series of pairs (the length being the length of the next identifier), and finally E. 

For example, wikipedia::article::format becomes 

_ZN·9wikipedia·7article·6format·E 

For functions, this is then followed by the type information; as format() is a void function, this is simply v; 

hence: 

_ZN·9wikipedia·7article·6format·E·v 

For print_to, a standard type std::ostream (or more properly std::basic_ostream) is used, which has the special alias So; a reference to this type is therefore RSo, with 

the complete name for the function being: 

_ZN·9wikipedia·7article·8print_to·E·RSo 

How different compilers mangle the same functions 

There isn't a standard scheme by which even trivial C++ identifiers are mangled, and consequently different 

compiler vendors (or even different versions of the same compiler, or the same compiler on different platforms) 

mangle public symbols in radically different (and thus totally incompatible) ways. Consider how different C++ 

compilers mangle the same functions: 

Notes: 

Compiler void h(int) void h(int, char) void h(void) 

Intel C++ 8.0 for Linux _Z1hi _Z1hic _Z1hv 

HP aC++ A.05.55 IA-64 _Z1hi _Z1hic _Z1hv 

GNU GCC 3.x and 4.x _Z1hi _Z1hic _Z1hv 

HP aC++ A.03.45 PA-RISC h__Fi h__Fic h__Fv 

GNU GCC 2.9x h__Fi h__Fic h__Fv 

Microsoft VC++ v6/v7 ?h@@YAXH@Z ?h@@YAXHD@Z ?h@@YAXXZ 

Digital Mars C++ ?h@@YAXH@Z ?h@@YAXHD@Z ?h@@YAXXZ 

Borland C++ v3.1 @h$qi @h$qizc @h$qv 

OpenVMS C++ V6.5 (ARM mode) H__XI H__XIC H__XV 

OpenVMS C++ V6.5 (ANSI 

mode) 

CXX$__7H__FI0ARG51T CXX$__7H__FIC26CDH77 CXX$__7H__FV2CB06E8 

OpenVMS C++ X7.1 IA-64 CXX$_Z1HI2DSQ26A CXX$_Z1HIC2NP3LI4 CXX$_Z1HV0BCA19V 

SunPro CC __1cBh6Fi_v_ __1cBh6Fic_v_ __1cBh6F_v_ 

Tru64 C++ V6.5 (ARM mode) h__Xi h__Xic h__Xv 

Tru64 C++ V6.5 (ANSI mode) __7h__Fi __7h__Fic __7h__Fv 

Watcom C++ 10.6 W?h$n(i)v W?h$n(ia)v W?h$n()v


• The Compaq C++ compiler on OpenVMS VAX and Alpha (but not IA-64) and Tru64 has two name mangling 

schemes. The original, pre-standard scheme is known as ARM model, and is based on the name mangling 

described in the C++ Annotated Reference Manual (ARM). With the advent of new features in standard C++, 

particularly templates, the ARM scheme became more and more unsuitable — it could not encode certain 

function types, or produced identical mangled names for different functions. It was therefore replaced by the 

newer "ANSI" model, which supported all ANSI template features, but was not backwards compatible. 

• On IA-64, a standard ABI exists (see external links), which defines (among other things) a standard 

name-mangling scheme, and which is used by all the IA-64 compilers. GNU GCC 3.x, in addition, has adopted 

the name mangling scheme defined in this standard for use on other, non-Intel platforms. 

Handling of C symbols when linking from C++ 

The job of the common C++ idiom: 

#ifdef __cplusplus 

extern "C" { 

#endif 

/* ... */ 


} 

#endif 

is to ensure that the symbols following are "unmangled" – that the compiler emits a binary file with their names 

undecorated, as a C compiler would do. As C language definitions are unmangled, the C++ compiler needs to avoid 

mangling references to these identifiers. 

For example, the standard strings library, usually contains something resembling: 


extern "C" { 

#endif 

void *memset (void *, int, size_t); 

char *strcat (char *, const char *); 

int strcmp (const char *, const char *); 

char *strcpy (char *, const char *); 


} 

#endif 

Thus, code such as: 

if (strcmp(argv[1], "-x") == 0) 

else 

strcpy(a, argv[2]); 

memset (a, 0, sizeof(a)); 

uses the correct, unmangled strcmp and memset. If the extern had not been used, the (SunPro) C++ compiler 

would produce code equivalent to:


if (__1cGstrcmp6Fpkc1_i_(argv[1], "-x") == 0) 

else 

__1cGstrcpy6Fpcpkc_0_(a, argv[2]); 

__1cGmemset6FpviI_0_ (a, 0, sizeof(a)); 

Since those symbols do not exist in the C runtime library (e.g. libc), link errors would result. 

Standardised name mangling in C++ 

While it is a relatively common belief that standardised name mangling in the C++ language would lead to greater 

interoperability between implementations, this is not really the case. Name mangling is only one of several 

application binary interface issues in a C++ implementation. Other ABI issues like exception handling, virtual table 

layout, structure padding, etc. cause differing C++ implementations to be incompatible. Further, requiring a 

particular form of mangling would cause issues for systems where implementation limits (e.g. length of symbols) 

dictate a particular mangling scheme. A standardised requirement for name mangling would also prevent an 

implementation where mangling was not required at all — for example, a linker which understood the C++ 

language. 

The C++ standard therefore does not attempt to standardise name mangling. On the contrary, the Annotated C++ 

Reference Manual (also known as ARM, ISBN 0-201-51459-1, section 7.2.1c) actively encourages the use of 

different mangling schemes to prevent linking when other aspects of the ABI, such as exception handling and virtual 

table layout, are incompatible. 

Real-world effects of C++ name mangling 

Because C++ symbols are routinely exported from DLL and shared object files, the name mangling scheme is not 

merely a compiler-internal matter. Different compilers (or different versions of the same compiler, in many cases) 

produce such binaries under different name decoration schemes, meaning that symbols are frequently unresolved if 

the compilers used to create the library and the program using it employed different schemes. For example, if a 

system with multiple C++ compilers installed (e.g. GNU GCC and the OS vendor's compiler) wished to install the 

Boost library, it would have to be compiled twice — once for the vendor compiler and once for GCC. 

It is good for safety purposes that compilers producing incompatible object codes (codes based on different ABIs, 

regarding e.g. classes and exceptions) use different name mangling schemes. This guarantees that these 

incompatibilities are detected at the linking phase, not when executing the software. 

For this reason name decoration is an important aspect of any C++-related ABI. 

Name mangling in Java 

The language, compiler, and .class file format were all designed together (and had object-orientation in mind from 

the start), so the primary problem solved by name mangling doesn't exist in implementations of the Java runtime. 

There are, however, cases where an analogous transformation and qualification of names is necessary. 

Creating unique names for inner and anonymous classes 

The scope of anonymous classes is confined to their parent class, so the compiler must produce a "qualified" public 

name for the inner class, to avoid conflict where other classes (inner or not) exist in the same namespace. Similarly, 

anonymous classes must have "fake" public names generated for them (as the concept of anonymous classes exists 

only in the compiler, not the runtime). So, compiling the following java program 

public class foo { 

class bar {


} 

} 

public int x; 

public void zark () { 

} 

Object f = new Object () { 

}; 

will produce three .class files: 

public String toString() { 

} 

return "hello"; 

• foo.class, containing the main (outer) class foo 

• foo$bar.class, containing the named inner class foo.bar 

• foo$1.class, containing the anonymous inner class (local to method foo.zark) 

All of these class names are valid (as $ symbols are permitted in the JVM specification) and these names are "safe" 

for the compiler to generate, as the Java language definition prohibits $ symbols in normal java class definitions. 

Name resolution in Java is further complicated at runtime, as fully qualified class names are unique only inside a 

specific classloader instance. Classloaders are ordered hierarchically and each Thread in the JVM has a so called 

context class loader, so in cases where two different classloader instances contain classes with the same name, the 

system first tries to load the class using the root (or system) classloader and then goes down the hierarchy to the 

context class loader. 

Handling issues with the java to native interface 

Java's native method support allows java language programs to call out to programs written in another language 

(generally either C or C++). There are two name-resolution concerns here, neither of which is implemented in a 

particularly standard manner. 

Name mangling in Python 

A Python programmer can explicitly designate that an identifier is a "private name" (its scope is confined to the 

class) by setting the first two characters of the identifier to be underscores. Mangling will not be performed if the 

identifier ends with more than one underscore, for example, __thing will be mangled, as will ___thing and __thing_, 

but __thing__ and __thing___ will not. On encountering these, the Python compiler or interpreter turns these private 

names into global symbols by prepending a string consisting of a single underscore and the name of the enclosing 

class. 

So, for example, 

class Test: 

def __private_symbol(self): 

pass 

def normal_symbol(self): 

pass 

print dir(Test) 

will output:


['_Test__private_symbol', 

'__doc__', 

'__module__', 

'normal_symbol'] 

Name mangling in Borland's Turbo Pascal / Delphi range 

To avoid name mangling in Pascal, use: 

exports 

myFunc name 'myFunc', myProc name 'myProc'; 

Name mangling in Objective-C 

Essentially two forms of method exist in Objective-C, the class ("static") method, and the instance method. A 

method declaration in Objective-C is of the following form 

+ method name: argument name 1 :parameter 1 ... 

- method name: argument name 1 :parameter 1 ... 

Class methods are signified by +, instance methods use -. A typical class method declaration may then look like: 

+ (id) initWithX: (int) number andY: (int) number; 

+ (id) new; 

with instance methods looking like 

- (id) value; 

- (id) setValue: (id) new_value; 

Each of these method declarations have a specific internal representation. When compiled, each method is named 

according to the following scheme for class methods: 

_c_Class_methodname_name 1 _name 2 _ ... 

and this for instance methods: 

_i_Class_methodname_name 1 _name 2 _ ... 

The colons in the Objective-C syntax are translated to underscores. So, the Objective-C class method + (id) 

initWithX: (int) number andY: (int) number;, if belonging to the Point class would translate as 

_c_Point_initWithX_andY_, and the instance method (belonging to the same class) - (id) value; 

would translate to _i_Point_value. 

Each of the methods of a class are labeled in this way. However, in order to look up a method that a class may 

respond to would be tedious if all methods are represented in this fashion. Each of the methods is assigned a unique 

symbol (such as an integer). Such a symbol is known as a selector. In Objective-C, one can manage selectors directly 

— they have a specific type in Objective-C — SEL. 

During compilation, a table is built that maps the textual representation (such as _i_Point_value) to selectors 

(which are given a type SEL). Managing selectors is more efficient than manipulating the textual representation of a 

method. Note that a selector only matches a method's name, not the class it belongs to — different classes can have 

different implementations of a method with the same name. Because of this, implementations of a method are given 

a specific identifier too — these are known as implementation pointers, and are given a type also, IMP.


Message sends are encoded by the compiler as calls to the id objc_msgSend (id receiver, SEL 

selector, ...) function, or one of its cousins, where receiver is the receiver of the message, and SEL 

determines the method to call. Each class has its own table that maps selectors to their implementations — the 

implementation pointer specifies where in memory the actual implementation of the method resides. There are 

separate tables for class and instance methods. Apart from being stored in the SEL to IMP lookup tables, the 

functions are essentially anonymous. 

The SEL value for a selector does not vary between classes. This enables polymorphism. 

The Objective-C runtime maintains information about the argument and return types of methods. However, this 

information is not part of the name of the method, and can vary from class to class. 

Since Objective-C does not support namespaces, there is no need for mangling of class names (that do appear as 

symbols in generated binaries). 

Name mangling in Fortran 

Name mangling is also necessary in Fortran compilers, originally because the language is case insensitive. Further 

mangling requirements were imposed later in the evolution of the language because of the addition of modules and 

other features in the Fortran 90 standard. The case mangling, especially, is a common issue that must be dealt with in 

order to call Fortran libraries (such as LAPACK) from other languages (such as C). 

Because of the case insensitivity, the name of a subroutine or function "FOO" must be converted to a canonical case 

and format by the Fortran compiler so that it will be linked in the same way regardless of case. Different compilers 

have implemented this in various ways, and no standardization has occurred. The AIX and HP-UX Fortran compilers 

convert all identifiers to lower case ("foo"), while the Cray Unicos Fortran compilers converted identifiers all upper 

case ("FOO"). The GNU g77 compiler converts identifiers to lower case plus an underscore ("foo_"), except that 

identifiers already containing an underscore ("FOO_BAR") have two underscores appended ("foo_bar__"), 

following a convention established by f2c. Many other compilers, including SGI's IRIX compilers, gfortran, and 

Intel's Fortran compiler, convert all identifiers to lower case plus an underscore ("foo_" and "foo_bar_"). 

Identifiers in Fortran 90 modules must be further mangled, because the same subroutine name may apply to different 

routines in different modules. 

See also 

• Language binding 

• Foreign function interface 

• Calling convention 

• Application programming interface - API 

• Application Binary Interface - ABI 

• Comparison of application virtual machines 

• Java Native Interface 

• SWIG - opensource interfaces bindings generator from many languages to many languages



• Linux Itanium ABI for C++ [1] , including name mangling scheme. 

• c++filt [2] — filter to demangle encoded C++ symbols 

• undname [3] — msvc tool to demangle names. 

• The Objective-C Runtime System [4] — From Apple's The Objective-C Programming Language 1.0 [5] 

• C++ Name Mangling/Demangling [6] Quite detailed explanation of Visual C++ compiler name mangling scheme 

• PHP UnDecorateSymbolName [7] a php script that demangles Microsoft Visual C's function names. 

• Calling conventions for different C++ compilers [8] contains detailed description of name mangling schemes for 

various x86 C++ compilers 

• Macintosh C/C++ ABI Standard Specification [9] 

• Mixing C and C++ Code [10] 

• Symbol management – 'Linkers and Loaders' by John R. Levine [11] 

References 

[1] http:/ / www. codesourcery. com/ cxx-abi/ abi. html#mangling 

[2] http:/ / sources. redhat. com/ binutils/ docs-2. 15/ binutils/ c--filt. html 

[3] http:/ / msdn2. microsoft. com/ en-us/ library/ 5x49w699. aspx 

[4] http:/ / developer. apple. com/ legacy/ mac/ library/ documentation/ Cocoa/ Conceptual/ OOPandObjC1/ Articles/ ocRuntimeSystem. html#/ / 

apple_ref/ doc/ uid/ TP40005191-CH9-CJBBBCHG 

[5] http:/ / developer. apple. com/ legacy/ mac/ library/ documentation/ Cocoa/ Conceptual/ OOPandObjC1/ Introduction/ introObjectiveC. html 

[6] http:/ / www. kegel. com/ mangle. html#operators 

[7] http:/ / sourceforge. net/ projects/ php-ms-demangle/ 

[8] http:/ / www. agner. org/ optimize/ calling_conventions. pdf 

[9] http:/ / developer. apple. com/ tools/ mpw-tools/ compilers/ docs/ abi_spec. pdf 

[10] http:/ / www. parashift. com/ c+ + -faq-lite/ mixing-c-and-cpp. html 

[11] http:/ / www. iecc. com/ linker/ linker05. html


Patrick Naughton 

Patrick Naughton (born in 1965) is an American software developer, best known as being one of the original 

creators of the Java programming language. 

Career 

Working for Sun 

As a Sun engineer, Patrick Naughton had become increasingly frustrated with the state of Sun's C++ and C APIs 

(application programming interfaces) and tools. While considering moving to NeXT, Naughton was offered a chance 

to work on new technology and thus the Stealth Project was started. 

The Stealth Project was soon renamed to the Green Project with James Gosling and Mike Sheridan joining 

Naughton. Together with other engineers, they began work in a small office on Sand Hill Road in Menlo Park, 

California. They were attempting to develop a new technology for programming next generation smart appliances, 

[1] [2] 

which Sun expected to be a major new opportunity. 

In June and July 1994, after three days of brainstorming with John Gage, the Director of Science for Sun, James 

Gosling, Bill Joy, Naughton, Wayne Rosing, and Eric Schmidt, the team re-targeted the platform for the World Wide 

Web. They felt that with the advent of the first graphical web browser, Mosaic, the Internet was on its way to 

evolving into the same highly interactive medium that they had envisioned for cable TV. As a prototype, Naughton 

wrote a small browser, WebRunner, later renamed HotJava. [3] 

After Sun 

In 1994, Naughton quit Sun for Starwave (then a property of Paul Allen) to develop server Java applications for high 

profile web sites (in times when J2EE frameworks did not exist yet) [3] . They developed ESPN.com, 

ABCNEWS.com, Outside Online, and Mr. Showbiz.com among other groundbreaking sites, setting the standard for 

much of the commercial Internet explosion of the late 1990s. 

In 1998, Walt Disney Internet Group acquired Starwave and amalgamated it with Infoseek in the Go Network 

company. As a result, Naughton became executive vice president of Infoseek. 

After his arrest in 1999, Naughton was fired from Infoseek. [4] He is currently employed by the Seattle hedge fund L1 

Partners. 

Arrest for sex crimes 

Patrick Naughton was arrested by the FBI on 16 September 1999 and was prosecuted for traveling in interstate 

commerce with the intent to have sex with a minor, in violation of 18 U.S.C. §2423(b). [4] [5] [6] After the trial ended 

in a hung jury, the government moved for a new trial, then struck a plea agreement where he took a reduced 

sentence, serving no prison time, in exchange for working for the FBI for free for a year. [7] [8] His line of defense 

was that he claimed he was persuaded to participate online in a ritualized sexual role-playing exercise, dealing with a 

mature woman acting as a girl. [8]


See also 

• History of Java 

• Online identity 

References 

[1] Patrick Naughton. "Java Was Strongly Influenced by Objective-C" (http:/ / cs. gmu. edu/ ~sean/ stuff/ java-objc. html). . Retrieved 

2009-08-02. 

[2] "Java Technology: The Early Years" (http:/ / java. sun. com/ features/ 1998/ 05/ birthday. html). Sun Microsystems. . Retrieved 2009-08-02. 

[3] "Le cadre, le piège et la loi" (http:/ / www. cyberie. qc. ca/ chronik/ 990928. html#b) (in French). cyberie.qc.ca. . Retrieved 2009-08-02. 

[4] "Patrick Doesn't Work Here Anymore" (http:/ / www. wired. com/ wired/ archive/ 7. 12/ mustread. html?pg=5). Wired News. December 

1999. . Retrieved 2009-08-02. 

[5] "CEO: Naughton said 'I did it'" (http:/ / news. zdnet. co. uk/ security/ 0,1000000189,2075734,00. htm). zdnet.co.uk. 1999-12-09. . Retrieved 

2009-08-02. 

[6] "The Fantasy Defense" (http:/ / www. cbsnews. com/ stories/ 2000/ 05/ 24/ eveningnews/ main199192. shtml). CBS News. 2000-05-31. . 


[7] "Patrick Naughton faces retrial" (http:/ / www. zdnet. com. au/ news/ soa/ Patrick-Naughton-faces-retrial-/ 0,139023165,120104206,00. htm). 

zdnet.co.uk. 2000-10-13. . Retrieved 2009-08-02. 

[8] "Paper 2: Legal Treatment Of Online Identity" (http:/ / emoglen. law. columbia. edu/ CPC/ discuss/ 383. html). emoglen.law.columbia.edu. 

2006-04-29. . Retrieved 2009-08-02. "At his criminal trial, Naughton employed what has come to be known as the "fantasy defense": citing his 

technical sophistication and the adult tone of his interlocutor's conversation, he claimed that he believed her to be an adult woman playing the 

role of a teenage girl; which, indeed, she was, although for different reasons from those Naughton claimed to have believed." 

New I/O 

New I/O or Non-blocking I/O, usually called NIO, is a collection of Java programming language APIs that offer 

features for intensive I/O operations. It was introduced with the J2SE 1.4 release of Java by Sun Microsystems to 

complement an existing standard I/O. NIO was developed under the Java Community Process as JSR 51. [1] As of 

2006, an extension to NIO, called NIO2, is being developed under JSR 203; JSR 203 is scheduled to be included in 

Java SE 7 ("Dolphin"). [2] 

Features and organization. 

The APIs of NIO were designed to provide access to the low-level I/O operations of modern operating systems. 

Although the APIs are themselves relatively high-level, the intent is to facilitate an implementation that can directly 

use the most efficient operations of the underlying platform. 

The Java NIO APIs are provided in the java.nio package and its subpackages. The documentation by Sun 

Microsystems identifies these features. 

• Buffers for data of primitive types 

• Character set encoders and decoders 

• A pattern-matching facility based on Perl-style regular expressions (in package java.util.regex) 

• Channels, a new primitive I/O abstraction 

• A file interface that supports locks and memory mapping of files up to Integer.MAX_VALUE bytes (2 GiB) 

• A multiplexed, non-blocking I/O facility for writing scalable servers

New I/O 232 

NIO buffers 

NIO data transfer is based on buffers (java.nio.Buffer and related classes). These classes represent a contiguous 

extent of memory, together with a small number of data transfer operations. Although theoretically these are 

general-purpose data structures, the implementation may select memory for alignment or paging characteristics, 

which are not otherwise accessible in Java. Typically, this would be used to allow the buffer contents to occupy the 

same physical memory used by the underlying operating system for its native I/O operations, thus allowing the most 

direct transfer mechanism, and eliminating the need for any additional copying. In most operating systems, provided 

the particular area of memory has the right properties, transfer can take place without using the CPU at all. The NIO 

buffer is intentionally limited in features in order to support these goals. 

There are buffer classes for all of Java's primitive types except boolean, which can share memory with byte buffers 

and allow arbitrary interpretation of the underlying bytes. 

Usage 

NIO buffers maintain several pointers that dictate the function of its accessor methods. The NIO buffer 

implementation contains a rich set of methods for modifying these pointers: 

• The flip() method, rather than performing a "flip" or paging function in the canonical sense, moves the position 

pointer to the origin of the underlying array (if any) and the limit pointer to the former position of the position 

pointer. 

• Three get() methods are supplied for transferring data out of a NIO buffer. The bulk implementation, rather than 

performing a "get" in the traditional sense, "puts" the data into a specified array. The "offset" argument supplied 

to this method refers not to the offset from within the buffer from which to read, nor an offset from the position 

pointer, but rather the offset from 0 within the target array. 

• Unless using the absolute get() and put() methods, any get() or put() is conducted from the position pointer. 

Should one need to read from a different position within the underlying array, whilst not adjusting the writing 

position, the mark() and reset() methods have been supplied. 

• The mark() method effectively stores the position of the position pointer by setting the mark pointer to the 

position of the position pointer. The reset() method causes the position pointer to move to the mark pointer's 

position. 

• Upon invocation of the clear() method or the flip() method the mark pointer is discarded. 

• The clear() method does not ensure zero-ing of the buffer, but does return the limit pointer to the upper boundary 

of the underlying array, and the position pointer to zero. 

• put() and get() operations for NIO buffers are not thread safe. 

• You can only map() a java.nio.MappedByteBuffer from a java.nio.channels.FileChannel up to 

Integer.MAX_VALUE in size (2GiB); regions beyond this limit can be accessed using an offset greater than zero. 

Channels 

Channels (classes implementing the interface java.nio.channels.Channel) are designed to provide for bulk data 

transfers to and from NIO buffers. This is a low-level data transfer mechanism that exists in parallel with the classes 

of the higher-level I/O library (packages java.io and java.net). A channel implementation can be obtained from a 

high-level data transfer class such as java.io.File, java.net.ServerSocket, or java.net.Socket, and vice versa. Channels 

are analogous to "file descriptors" found in Unix-like operating systems. 

File channels (java.nio.channels.FileChannel) can use arbitrary buffers but can also establish a buffer directly 

mapped to file contents using memory-mapped I/O. They can also interact with file system locks. Similarly, socket 

channels (java.nio.channels.SocketChannel and java.nio.channels.ServerSocketChannel) allow for data transfer 

between sockets and NIO buffers.

New I/O 233 

FileChannel can be used to do a file copy, which is potentially far more efficient than using old read/write with a 

byte array. The typical code for this is: 

// Getting file channels 

FileChannel in = new FileInputStream(source).getChannel(); 

FileChannel out = new FileOutputStream(target).getChannel(); 

// JavaVM does its best to do this as native I/O operations. 

in.transferTo (0, in.size(), out); 

// Closing file channels will close corresponding stream objects as 

well. 

out.close(); 

in.close(); 

Selectors 

A selector (java.nio.channels.Selector and subclasses) provides a mechanism for waiting on channels and 

recognizing when one or more become available for data transfer. When a number of channels are registered with the 

selector, it enables blocking of the program flow until at least one channel is ready for use, or until an interruption 

condition occurs. 

Although this multiplexing behavior could be implemented with Java threads, the selector can provide a significantly 

more efficient implementation using native platform threads or, more likely, even lower-level operating system 

constructs. A POSIX-compliant operating system, for example, would have direct representations of these concepts, 

select(). A notable application of this design would be the common paradigm in server software which involves 

simultaneously waiting for responses on a number of sessions. 

Character sets 

In Java, a character set is a mapping between Unicode characters (or a subset of them) and bytes. The 

java.nio.charset package of NIO provides facilities for identifying character sets and providing encoding and 

decoding algorithms for new mappings. 

Regular expressions 

The regular expression library in the java.util.regex package provides a powerful search facility for character data 

based on regular expression matching. 

The following example was adopted from the NIO API guide examples [3] , where there are more examples. 

/* 

* @(#)Grep.java 1.3 01/12/13 

* Search a list of files for lines that match a given 

regular-expression 

* pattern. Demonstrates NIO mapped byte buffers, charsets, and 

regular 

* expressions. 

* 

* Copyright 2001-2002 Sun Microsystems, Inc. All Rights Reserved. 

* 

* Redistribution and use in source and binary forms, with or

New I/O 234 

* without modification, are permitted provided that the following 

* conditions are met: 

* 

* -Redistributions of source code must retain the above copyright 

* notice, this list of conditions and the following disclaimer. 

* 

* -Redistribution in binary form must reproduct the above copyright 

* notice, this list of conditions and the following disclaimer in 

* the documentation and/or other materials provided with the 

* distribution. 

* 

* Neither the name of Sun Microsystems, Inc. or the names of 

* contributors may be used to endorse or promote products derived 

* from this software without specific prior written permission. 

* 

* This software is provided "AS IS," without a warranty of any 

* kind. ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND 

* WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, 

* FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY 

* EXCLUDED. SUN AND ITS LICENSORS SHALL NOT BE LIABLE FOR ANY 

* DAMAGES OR LIABILITIES SUFFERED BY LICENSEE AS A RESULT OF OR 

* RELATING TO USE, MODIFICATION OR DISTRIBUTION OF THE SOFTWARE OR 

* ITS DERIVATIVES. IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE 

* FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR DIRECT, INDIRECT, 

* SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER 

* CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY, ARISING OUT OF 

* THE USE OF OR INABILITY TO USE SOFTWARE, EVEN IF SUN HAS BEEN 

* ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. 

* 

* You acknowledge that Software is not designed, licensed or 

* intended for use in the design, construction, operation or 

* maintenance of any nuclear facility. 

*/ 

import java.io.*; 

import java.nio.*; 

import java.nio.channels.*; 

import java.nio.charset.*; 

import java.util.regex.*; 

public class Grep { 

// Charset and decoder for ISO-8859-15 

private static Charset charset = Charset.forName("ISO-8859-15"); 

private static CharsetDecoder decoder = charset.newDecoder();

New I/O 235 

// Pattern used to parse lines 

private static Pattern linePattern = Pattern.compile(".*\r?\n"); 

// The input pattern that we're looking for 

private static Pattern pattern; 

// Compile the pattern from the command line 

private static void compile(String pat) { 

} 

applying 

try { 

pattern = Pattern.compile(pat); 

} catch (PatternSyntaxException x) { 

} 

System.err.println(x.getMessage()); 

System.exit(1); 

// Use the linePattern to break the given CharBuffer into lines, 

// the input pattern to each line to see if we have a match 

private static void grep(File f, CharBuffer cb) { 

} 

Matcher lm = linePattern.matcher(cb); // Line matcher 

Matcher pm = null; // Pattern matcher 

int lines = 0; 

while (lm.find()) { 

} 

lines++; 

CharSequence cs = lm.group(); // The current line 

if (pm == null) 

else 

pm = pattern.matcher(cs); 

pm.reset(cs); 

if (pm.find()) 

System.out.print(f + ":" + lines + ":" + cs); 

if (lm.end() == cb.limit()) 

break; 

// Search for occurrences of the input pattern in the given file 

private static void grep(File f) throws IOException { 

// Open the file and then get a channel from the stream 

FileInputStream fis = new FileInputStream(f); 

FileChannel fc = fis.getChannel(); 

// Get the file's size and then map it into memory 

int sz = (int)fc.size(); 

MappedByteBuffer bb = fc.map(FileChannel.MapMode.READ_ONLY, 0,

New I/O 236 

sz); 

} 

} 

// Decode the file into a char buffer 

CharBuffer cb = decoder.decode(bb); 

// Perform the search 

grep(f, cb); 

// Close the channel and the stream 

fc.close(); 


} 

if (args.length < 2) { 

} 

System.err.println("Usage: java Grep pattern file..."); 

return; 

compile(args[0]); 

for (int i = 1; i < args.length; i++) { 

} 

File f = new File(args[i]); 

try { 

grep(f); 

} catch (IOException x) { 

} 

JDK 7 and NIO.2 

System.err.println(f + ": " + x); 

JDK 7 includes a java.nio.file package which, with the java.io.file.Path class (also new to JDK 7), among other 

features, provides extended capabilities for filesystem tasks, e.g. can work with symbolic/hard links and dump big 

directory listings into buffers more quickly than the old File class does. 



• JDK 5.0 New I/O-related APIs & Developer Guides [4] - description of New I/O by Sun Microsystems 

• JSR 51 [5] (NIO) 

• JSR 203 [6] (NIO2) 

• Architecture of a Highly Scalable NIO-Based Server [7] - discussion on Java NIO and patterns of usage

New I/O 237 

References 

[1] "JSR 51: New I/O APIs for the JavaTM Platform" (http:/ / www. jcp. org/ en/ jsr/ detail?id=51). The Java Community Process(SM) Program 

- JSRs: Java Specification Requests. . Retrieved 2009-05-23. 

[2] "This JSR will be delivered as part of Java SE 7 "Dolphin"." "JSR 203: More New I/O APIs for the JavaTM Platform ("NIO.2")" (http:/ / 

www. jcp. org/ en/ jsr/ detail?id=203). The Java Community Process(SM) Program - JSRs: Java Specification Requests. 2006-01-30. . 


[3] http:/ / java. sun. com/ j2se/ 1. 4. 2/ docs/ guide/ nio/ example/ index. html 

[4] http:/ / java. sun. com/ j2se/ 1. 5. 0/ docs/ guide/ nio/ index. html 

[5] http:/ / www. jcp. org/ en/ jsr/ detail?id=51 


[7] http:/ / today. java. net/ pub/ a/ today/ 2007/ 02/ 13/ architecture-of-highly-scalable-nio-server. html 

Object type (object-oriented programming) 

In computer science, an object type (a.k.a. wrapping object) is a datatype which is used in object-oriented 

programming to wrap a non-object type to make it look like a dynamic object. 

Some object-oriented programming languages make a distinction between reference and value types, often referred 

to as objects and non-objects on platforms where complex value types don't exist, for reasons such as runtime 

efficiency and syntax or semantic issues. For example, Java has primitive wrapper classes corresponding to each 

primitive type: Integer and int, Character and char, Float and float, etc. Languages like C++ have little or no notion 

of reference type; thus, the use of object type is of little interest. 

Boxing 

Boxing is the process of placing a primitive type within an object so that the primitive can be used as a reference 

object. For example, lists may have certain methods which arrays might not, but the list might also require that all of 

its members be dynamic objects. In this case, the added functionality of the list might be unavailable to a simple 

array of numbers. For a more concrete example, in Java, a LinkedList can change its size, but an array must have a 

fixed size. One might desire to have a LinkedList of ints, but the LinkedList class only lists references to dynamic 

objects — it cannot list primitive types, which are value types. 

To get around this, ints can be boxed into Integers, which are dynamic objects, and then added to a LinkedList of 

Integers. (Using generic parameterized types introduced in J2SE 5.0, this type is represented as 

LinkedList.) On the other hand, C# has no primitive wrapper classes, but allows boxing of any value type, 

returning a generic Object reference. 

The boxed object is always a copy of the value object, and is usually immutable. Unboxing the object also returns a 

copy of the stored value. Note that repeated boxing and unboxing of objects can have a severe performance impact, 

since it dynamically allocates new objects and then makes them eligible for Garbage collection. 

Autoboxing 

Autoboxing is the term for treating a value type as a reference type without any extra source code. The compiler 

automatically supplies the extra code needed to perform the type conversion. 

For example, J2SE 5.0 allows the programmer to create a LinkedList of ints. This does not contradict what was said 

above: the LinkedList still only lists references to dynamic objects, and it cannot list primitive types. But now, when 

Java expects a reference but receives a primitive type, it immediately converts that primitive type to a dynamic 

object. Note that the declaration List is illegal in Java, but List is not, and autoboxing will allow 

adding of primitive ints to the collection. 

For example, in versions of Java prior to J2SE 5.0, the following code did not compile:

Object type (object-oriented programming) 238 

Integer i = new Integer(9); 

Integer j = new Integer(13); 

int k = 9 + 13; // always OK 

Integer l = i + j; // error in versions prior to 5.0! 

Compilers prior to 5.0 would not accept the last line. Integers are reference objects, on the surface no different from 

List, Object, and so forth; mathematical operators such as + were not meaningfully defined for references. As of 

J2SE 5.0, the Integers i and j are unboxed into ints, the two are added, and then the sum is autoboxed into a new 

Integer. [1] 

Unboxing 

Unboxing refers to a boxed value type which has been broken down and the value type retrieved for a process of 

some kind such as a mathematical operation. 

For example, in versions of Java prior to J2SE 5.0, the following code did not compile: 

int i = 4; 

int j = 5; 

Integer k = new Integer(i + j); // always OK 

Integer l = i + j; // would have been an error, but okay now - 

equivalent to previous line 

C# does not support automatic unboxing. A boxed object must be explicitly unboxed with a typecasting operator: 

int i = 42; 

object o = i; //box 

int j = (int)o; //unbox 

Console.Writeline(j); //outputs "42" 

References 

[1] java.sun.com Java language guide entry on autoboxing (http:/ / java. sun. com/ j2se/ 1. 5. 0/ docs/ guide/ language/ autoboxing. html)

Omniscient Debugger 239 

Omniscient Debugger 

The Omniscient Debugger, or ODB for short, is a Java programming language debugger which lets users step 

backwards in time. It allows this by keeping track of all changes to objects and variables made as a program runs. [1] 

It is free open source software, released under the GPL license. 

[1] Lewis, Bil (2003), "Debugging Backwards in Time" (http:/ / www. citebase. org/ abstract?id=oai:arXiv. org:cs/ 0310016), in Ronsse, M.; De 

Bosschere, K., Proceedings of the Fifth International Workshop on Automated Debugging (AADEBUG 2003) (http:/ / arxiv. org/ abs/ cs. SE/ 

0309027), Ghent, September 2003, 


• ODB home page (http:/ / www. lambdacs. com/ debugger/ ) 

• Debugging Backwards in Time (http:/ / video. google. com/ videoplay?docid=3897010229726822034) video, 

hosted by Google Video 

• Dr. Dobb's Journal article about ODB (http:/ / www. ddj. com/ article/ printableArticle. 

jhtml?articleID=184406101& dept_url=/ dept/ debug/ ) 

OpenJDK 


Initial release 

Stable release 


Operating 

system 

Type Library 

openJDK6 Build b05 February 12, 2008 [1] 

OpenJDK6 Build b20 [2] / June 21, 2010 


License GPL+linking exception 

Website [3] 


Preview release 


Operating 

system 

Type Library 

OpenJDK7 Build b105 [4] / August 13, 

2010 


License GPL+linking exception 

Website [5] 

OpenJDK (aka Open Java Development Kit) is a Free and open source implementation of the Java programming 

language. It is the result of an effort Sun Microsystems began in 2006. The implementation is licensed under the 

GNU General Public License (GPL) with a linking exception, which exempts components of the Java class library 

from the GPL licensing terms.

OpenJDK 240 

History 

Sun's promise and initial release 

Sun announced in JavaOne 2006 that Java would become open source software, [6] [7] and on October 25, 2006, at 

the Oracle OpenWorld conference, Jonathan Schwartz said that the company was set to announce the open-sourcing 

of the core Java Platform within 30 to 60 days. 

Sun released the Java HotSpot virtual machine and compiler as free software under the GNU General Public License 

on 13 November 2006, with a promise that the rest of the JDK (which includes the Java Runtime Environment) 

would be placed under the GPL by March 2007, "except for a few components that Sun does not have the right to 

publish in source form under the GPL". [8] According to computer scientist and Free software advocate Richard 

Stallman, this would end the "Java trap", the Vendor lock-in that he argues applies to Java and programs written in 

Java. [9] Software entrepreneur Mark Shuttleworth called the initial press announcement "A real milestone for the free 

software community". [10] 

Release of the class library 

Following their promise to release a Java Development Kit (JDK) based almost completely on Free and open source 

code in the first half of 2007 [11], Sun released the complete source code of the Java Class Library under the GPL on 

May 8, 2007, except for some limited parts that some third parties licensed to Sun that rejected the terms of the 

GPL. [12] Included in the list of encumbered parts were several major components of the Java Graphical User 

Interface (GUI). Sun stated that it planned to replace the remaining proprietary and closed source components with 

alternative implementations and to make the class library completely Free. [13] 

Community improvements 

On 2007-11-05, Red Hat announced an agreement with Sun, signing Sun's broad contributor agreement (which 

covers participation in all Sun-led free and open source software projects by all Red Hat engineers) and Sun's 

OpenJDK Community TCK License Agreement (which gives the company access to the test suite that determines 

whether a project based on openJDK complies with the Java SE 6 specification). [14] 

Also on November 2007, the porters group was created on OpenJDK [15] to aid in efforts to port OpenJDK to 

different processor architectures and operating systems. The BSD porting projects [16], led by Kurt Miller and Greg 

Lewis and the Mac OS X porting project (based on the BSD one) SoyLatte [17] led by Landon Fuller [18] have 

expressed interest in joining OpenJDK via the porters group and as of January 2008 are part of the mailing list 

discussions. Another project pending formalization on the porters group is the Haiku Java Team, led by Bryan 

Varner. [19] 

On December 2007, Sun moved the revision control of OpenJDK from TeamWare to Mercurial, as part of the 

[20] [21] 

process of releasing it to open source communities. 

OpenJDK has comparatively strict procedures of accepting code contributions: every proposed contribution must be 

reviewed by two of Sun's engineers and have the automatic test demonstrating that feature has been fixed. [22] 

However, although initially the fixes proposed by the community were committed by Sun in the codebase, 

September 2008 saw the first (significant) patches directly committed by a non-Sun or ex-Sun employee. [23]

OpenJDK 241 

Inclusion in software distributions 

As of May 2008, the Fedora 9 [24] [25] and Ubuntu 8.04 [26] distributions were released with OpenJDK, based 

completely on free and open source code. [27] 

In June 2008, it was announced that IcedTea 6 (as the packaged version of OpenJDK on Fedora 9) has passed the 

Technology Compatibility Kit tests and can claim to be a fully compatible Java 6 implementation. [28] 

On July 12, 2008, Debian accepted OpenJDK-6 in unstable [29] [30] , and it is now in stable [31] . OpenJDK is also 

available on openSUSE [32] , and also Red Hat Enterprise Linux and its derivatives such as CentOS [33] . 

Since August 2008, OpenJDK 7 is runnable on Mac OS X and other BSD distributions. [34] 

In July 2009, OpenJDK binary build for Ubuntu 9.04 passed all of the compatibility tests in the Java SE 6 JCK. [35] 

Status 

Supported JDK versions 

OpenJDK was initially based only on the JDK 7.0 version of the Java platform. [36] 

Since February 15, 2008, there are two separate OpenJDK projects: 

• The main OpenJDK [9] project, which is based on the JDK 7.0 version of the Java platform, 

• The JDK 6 [3] project, which provides an Open-source version of Java 6.0. [37] 

Compiler and Virtual Machine 

Sun's Java compiler, javac, and HotSpot (the virtual machine), are now under a GPL license. 

Class library 

As of May 2008, the only part of the Class library that remains proprietary and closed-source (4% as of May 2007 

for OpenJDK 7 [38] , and less than 1% as of May 2008 and OpenJDK 6 [24] ) is [39] [40] the SNMP implementation [40] . 

Since the first May 2007 release, Sun Microsystems, with the help of the community, has released as free and 

open-source software or replaced with free and open-source alternatives almost all the encumbered code: 

• All the audio engine code, including the software synthesizer, has been released as Open-source. [40] [41] The 

closed-source software synthesizer has been replaced by a new synthesizer developed specifically for OpenJDK 

called Gervill [42] , 

• All cryptography classes used in the Class library have been released as Open-source [43] , 

[44] [45] [46] 

• The code that scales and rasterizes fonts has been replaced by FreeType 

• The native color management system has been replaced by LittleCMS. [45] There is a pluggable layer in the JDK, 

so that the commercial version can use the old color management system and OpenJDK can use LittleCMS. 

• The anti-aliasing graphics rasterizer code has been replaced by the Open-sourced Pisces renderer used in the 

phoneME project. [45] [47] [48] This code is fully functional, but still needs some performance enhancements [49] , 

• The JavaScript plugin has been open-sourced (the Rhino JavaScript engine itself was open-sourced from the 

beginning). [50]

OpenJDK 242 

IcedTea 

Because of the encumbered components in the Class library, it was not possible to build OpenJDK only with free 

software components. In order to be able to do this before the whole class library is made free, and to be able to 

bundle OpenJDK in Fedora and other free Linux distributions, a project called IcedTea has been started by Red Hat. 

It is basically an OpenJDK/GNU Classpath hybrid that can be used to bootstrap OpenJDK using only free 

[51] [52] 

software. 

IcedTea is a software development and integration project launched by Red Hat in June 2007. [53] The goal is to make 

the OpenJDK software which Sun Microsystems released as free software in 2007 usable without requiring any other 

software that is not free software. For Red Hat, this would make it possible to add OpenJDK to the Fedora Linux 

distribution, as well as other distributions. 

On November 5, 2007, Red Hat has signed both the Sun Contributor Agreement and the OpenJDK Community TCK 

License. [54] One of the first benefits of this agreement is tighter alignment with the IcedTea project, which brings 

together Fedora, the Linux distribution, and JBoss, the application server, technologies in a Linux environment. 

IcedTea is providing free software alternatives for the few remaining proprietary sections in the OpenJDK project. 

Fedora 9 was the first version to ship with IcedTea6, based on the OpenJDK6 sources from Sun rather than 

OpenJDK7. It was also the first to use OpenJDK for the package name (via the OpenJDK trademark agreement [55] ) 

instead of IcedTea. [24] 

Ubuntu also first packaged IcedTea7 [56] before later moving to IcedTea6. Packages for IcedTea6 were also created 

for Debian and included in lenny. 

See also 

• javac, Sun's java compiler, now under a GPL license 

• HotSpot, Sun's Virtual Machine, now under a GPL license 

• Java Class Library 



• Apache Harmony 


• Main site [9] 

• OpenJDK FAQ [57] 

• OpenJDK - The First Year [58] by Mark Reinhold 

References 

[1] http:/ / download. java. net/ openjdk/ jdk6/ promoted/ b05/ 

[2] http:/ / download. java. net/ openjdk/ jdk6/ 

[3] http:/ / openjdk. java. net/ projects/ jdk6/ 

[4] http:/ / download. java. net/ openjdk/ jdk7/ 

[5] http:/ / openjdk. java. net/ projects/ jdk7/ 

[6] Schwartz, Jonathan (23 May 2006). "Busy Week..." (http:/ / blogs. sun. com/ roller/ page/ jonathan/ 200605#busy_week1). Sun 


[7] "Sun Opens Java" (http:/ / mediacast. sun. com/ share/ tmarble/ Sun_Opens_Java. ogg) (OGG Theora). Sun Microsystems. . 

[8] "Sun Opens Java" (http:/ / www. sun. com/ 2006-1113/ feature/ index. jsp). Sun Microsystems. 13 November 2006. . Retrieved 2007-05-09. 

[9] Stallman, Richard. "Free But Shackled—The Java Trap" (http:/ / www. gnu. org/ philosophy/ java-trap. html). . Retrieved 2007-12-04. 

[10] "Sun 'releases' Java to the world" (http:/ / news. bbc. co. uk/ 1/ hi/ technology/ 6144748. stm). BBC News. 13 November 2006. . Retrieved 

2007-05-09. 

[11] http:/ / www. sun. com/ software/ opensource/ java/ faq. jsp#b4

OpenJDK 243 

[12] "Open JDK is here!" (http:/ / mail. openjdk. java. net/ pipermail/ announce/ 2007-May. txt). Sun Microsystems. 8 May 2007. . Retrieved 

2007-05-09. 

[13] Some encumbered code remains in the JDK; Sun stated that it will continue to use such code in commercial releases until fully functional 

free and open source alternatives replace it. 

[14] Broad contributor agreement and TCK License pave way for a fully compatible, free and open source Java Development Kit for Red Hat 

Enterprise Linux (http:/ / www. businesswire. com/ portal/ site/ google/ index. jsp?ndmViewId=news_view& newsId=20071105005882& 

newsLang=en) 

[15] Porters Group (http:/ / openjdk. java. net/ groups/ porters/ ) 

[16] http:/ / www. eyesbeyond. com/ freebsddom/ java/ jdk16. html 

[17] http:/ / landonf. bikemonkey. org/ static/ soylatte 

[18] http:/ / landonf. bikemonkey. org/ code/ macosx/ 

[19] New java for haiku team formed (http:/ / haiku-os. org/ news/ 2008-01-03/ new_java_for_haiku_team_formed) 

[20] James Gosling. Interview with Robert Eckstein. James Gosling on Open Sourcing Sun's Java Platform Implementations, Part 1 (http:/ / java. 

sun. com/ developer/ technicalArticles/ Interviews/ gosling_os1_qa. html). October 2006. 

[21] O'Hair, Kelly (2007-12-12). "Mercurial OpenJDK Questions" (http:/ / blogs. sun. com/ kto/ entry/ mercurial_openjdk_questions). . 

[22] Tripp, Andy (2007-07-16). "Classpath hackers frustrated with slow OpenJDK process" (http:/ / www. javalobby. org/ java/ forums/ t98834. 

html). . Retrieved 2008-04-20. 

[23] Kennke, Roman (2008-09-29). "A small step for me" (http:/ / kennke. org/ blog/ 2008/ 09/ 29/ a-small-step-for-me/ ). . Retrieved 

2008-10-19. 





[25] "Open Source Java Technology Debuts In GNU/Linux Distributions" (http:/ / www. sun. com/ aboutsun/ pr/ 2008-04/ sunflash. 20080430. 

1. xml). Sun Microsystems. . Retrieved 2008-05-02. 

[26] "openjdk-6 in Ubuntu" (https:/ / launchpad. net/ ubuntu/ + source/ openjdk-6). . Retrieved 2008-04-19. 

[27] Reinhold, Mark (2008-04-24). "There’s not a moment to lose!" (http:/ / blogs. sun. com/ mr/ entry/ in_hardy_heron). . Retrieved 2008-04-19. 

[28] Sharples, Rich (2008-06-19). "Java is finally Free and Open" (http:/ / blog. softwhere. org/ archives/ 196). . 

[29] Topic, Dalibor (2008-07-14). "QotD: Debian Overview of openjdk-6 source package" (http:/ / robilad. livejournal. com/ 33750. html). . 


[30] "Overview of openjdk-6 source package" (http:/ / packages. qa. debian. org/ o/ openjdk-6. html). debian.org. . Retrieved 2008-07-15. 

[31] "Package: openjdk-6-jdk" (http:/ / packages. debian. org/ stable/ openjdk-6-jdk). debian.org. 2009-02-14. . Retrieved 2009-02-16. 

[32] "Package: OpenJDK" (http:/ / en. opensuse. org/ OpenJDK). opensuse.org. . Retrieved 2009-06-01. 

[33] "How to download and install prebuilt OpenJDK packages" (http:/ / openjdk. java. net/ install/ #epel). . Retrieved 2010-03-03. 

[34] Fuller, Landon (2008-08-19). "SoyLatte, Meet OpenJDK: OpenJDK 7 for Mac OS X" (http:/ / landonf. bikemonkey. org/ code/ java/ 

SoyLatte_Meets_OpenJDK. 20080819. html). . Retrieved 2008-08-22. 

[35] Announcing OpenJDK 6 Certification for Ubuntu 9.04 (jaunty) (https:/ / lists. ubuntu. com/ archives/ ubuntu-devel-announce/ 2009-July/ 

000587. html) 

[36] "Didn't you promise to open source both JDK 6 and JDK 7 last November? What happened to JDK 6?" (http:/ / www. sun. com/ software/ 

opensource/ java/ faq. jsp#b10). Sun Microsystems. . Retrieved 2007-10-14. "Sun did make that promise, and we plan to keep it. But in the six 

months since the November 2006 announcement, it has become clear that doing this is far more complex than just changing the license and 

publishing the source code." 

[37] Darcy, Joe (2008-02-11). "The code is coming! The code is coming!" (http:/ / mail. openjdk. java. net/ pipermail/ jdk6-dev/ 2008-February/ 

000001. html). . Retrieved 2008-02-16. "At Sun we're making final preparations for the first source release for the OpenJDK 6 project. We 

plan to release a tarball of the source, along with matching binary plugs, by February 15, 2008." 

[38] Fitzsimmons, Thomas (2007-05-18). "Plans for OpenJDK" (http:/ / fitzsim. org/ blog/ ?p=17). . Retrieved 2007-05-22. 

[39] Herron, David (2007-10-04). "Plans for OpenJDK" (http:/ / weblogs. java. net/ blog/ robogeek/ archive/ 2007/ 10/ openjdk_encumbr. html). . 


[40] "OpenJDK 6 b10 source posted" (http:/ / mail. openjdk. java. net/ pipermail/ jdk6-dev/ 2008-May/ 000058. html). 2008-05-30. . Retrieved 

2008-06-01. 

[41] audio-engine project page (http:/ / openjdk. java. net/ projects/ audio-engine/ ) 

[42] "Gervill - Software Synthesizer" (https:/ / gervill. dev. java. net/ ). . Retrieved 2008-06-01. 

[43] "Crypto has been added to OpenJDK" (http:/ / mail. openjdk. java. net/ pipermail/ security-dev/ 2007-September/ 000015. html). 

2007-09-27. . Retrieved 2007-10-07. 

[44] font-scaler projectpage (http:/ / openjdk. java. net/ projects/ font-scaler/ ) 

[45] Java2D project page (http:/ / openjdk. java. net/ groups/ 2d/ ) 

[46] "Freetype font rasteriser" (http:/ / mail. openjdk. java. net/ pipermail/ font-scaler-dev/ 2007-August/ 000011. html). 2007-08-07. . Retrieved 

2007-11-24. 

[47] phoneme.dev.java.net/ (https:/ / phoneme. dev. java. net/ )

OpenJDK 244 

[48] graphics-rasterizer project page (http:/ / openjdk. java. net/ projects/ graphics-rasterizer/ ) 

[49] Graham, Jim (2007-10-03). "Open Source rasterizer" (http:/ / mail. openjdk. java. net/ pipermail/ 2d-dev/ 2007-October/ 000078. html). Sun 


[50] "Javascript is encumbered and there is no javascript plugin support." (http:/ / icedtea. classpath. org/ bugzilla/ show_bug. cgi?id=85). 

IcedTea. 2008-03-11. . Retrieved 2008-06-01. "Changing Summary. JavaScript is no longer encumbered, but we still need liveconnect 

support." 

[51] Andrew, Haley (2007-06-07). "Experimental Build Repository at icedtea.classpath.org" (http:/ / article. gmane. org/ gmane. comp. java. 

openjdk. distro-packaging. devel/ 5). . Retrieved 2007-06-09. 

[52] Mark, Wielaard (2007-06-07). "Experimental Build Repository at icedtea.classpath.org" (http:/ / developer. classpath. org/ pipermail/ 

classpath/ 2007-June/ 002109. html). . Retrieved 2007-06-09. 

[53] Fitzsimmons, Thomas (2007-06-08). "Credits" (http:/ / mail. openjdk. java. net/ pipermail/ distro-pkg-dev/ 2007-June/ 000032. html). . 


[54] "Red Hat and Sun Collaborate to Advance Open Source Java Technology" (http:/ / home. businesswire. com/ portal/ site/ google/ index. 

jsp?ndmViewId=news_view& newsId=20071105005882& newsLang=en). Red Hat. 2007-11-05. . Retrieved 2007-11-06. 

[55] http:/ / openjdk. java. net/ legal/ openjdk-trademark-notice. html 

[56] "icedtea-java7 in Ubuntu" (https:/ / launchpad. net/ ubuntu/ + source/ icedtea-java7). . Retrieved 2008-04-19. 

[57] http:/ / www. sun. com/ software/ opensource/ java/ faq. jsp 

[58] http:/ / parleys. com/ display/ PARLEYS/ OpenJDK+ -+ The+ First+ Year?showComments=true 

PHP/Java Bridge 

There are three well known implementations of the PHP scripting language: 

• The original implementation of PHP and the de facto standard is the open source PHP distribution. 

• Project Zero has a PHP runtime written in Java. It also distributes extensions from the open source 

implementation of PHP. 

• Quercus is an open-source pure Java implementation of the PHP scripting language. 

To bridge between PHP scripts and Java libraries all three implementations provide a PHP/Java bridge. 

The de facto implementation of PHP has a PHP/Java Bridge separately available from SourceForge. This uses a dual 

process model where the Java libraries are run in a separate process from the PHP runtime. Interactions with Java 

objects are marshalled across to the Java process using an XML [1] protocol. 

Quercus and Project Zero implement PHP on top of the Java Virtual Machine and so can run the Java libraries in the 

same process as the PHP runtime. This reduces the overhead of interacting with Java libraries when compared with 

the dual process model. 

See also 

• Quercus (software) 


• Open source PHP homepage [2] 

• SourceForge PHP/Java Bridge homepage [3] 

• Project Zero homepage [4] 

• Quercus homepage [5]

PHP/Java Bridge 245 

References 

[1] http:/ / php-java-bridge. sourceforge. net/ pjb/ PROTOCOL. TXT 

[2] http:/ / www. php. net/ 

[3] http:/ / php-java-bridge. sourceforge. net/ 

[4] http:/ / www. projectzero. org/ documentation/ 

[5] http:/ / quercus. caucho. com/ 

Java package 

A Java package is a mechanism for organizing Java classes into namespaces similar to the modules of Modula. Java 

packages can be stored in compressed files called JAR files, allowing classes to download faster as a group rather 

than one at a time. Programmers also typically use packages to organize classes belonging to the same category or 

providing similar functionality. 

• A package provides a unique namespace for the types it contains. 

• Classes in the same package can access each other's package-access members. 

Overview 

In general, a package can contain the following kinds of types. 

• Classes 

• Interfaces 

• Enumerated types 

• Annotations 

Using packages 

In a Java source file, the package that this file's class or classes belong to is specified with the package keyword. This 

keyword is usually the first keyword in source file. [1] 

package java.awt.event; 

To use a package's classes inside a Java source file, it is convenient to import the classes from the package with an 

import declaration. The following declaration 

import java.awt.event.*; 

imports all classes from the java.awt.event package, while the next declaration 

import java.awt.event.ActionEvent; 

imports only the ActionEvent class from the package. After either of these import declarations, the ActionEvent 

class can be referenced using its simple class name: 

ActionEvent myEvent = new ActionEvent(); 

Classes can also be used directly without an import declaration by using the fully-qualified name of the class. For 

example, 

java.awt.event.ActionEvent myEvent = new java.awt.event.ActionEvent(); 

does not require a preceding import declaration. 

[2] [3] 

Note that if you do not use a package declaration, your class ends up in an unnamed package.


Package access protection 

Classes within a package can access classes and members declared with default access and class members declared 

with the protected access modifier. Default access is enforced when neither the public, protected nor private access 

modifier is specified in the declaration. By contrast, classes in other packages cannot access classes and members 

declared with default access. Class members declared as protected can be accessed from the classes in the same 

package as well as classes in other packages that are subclasses of the declaring class. 

Creation of JAR files 

JAR Files are created with the jar command-line utility. The command 

jar cf myPackage.jar *.class 

compresses all .class files into the JAR file myPackage.jar. The ' c ' option on the command line tells the jar 

command to "create new archive." The ' f ' option tells it to create a file. The file's name comes next before the 

contents of the JAR file. 

Package naming conventions 

Packages are usually defined using a hierarchical naming pattern, with levels in the hierarchy separated by periods (.) 

(pronounced "dot"). Although packages lower in the naming hierarchy are often referred to as "subpackages" of the 

corresponding packages higher in the hierarchy, there is no semantic relationship between packages. The Java 

Language Specification establishes package naming conventions to avoid the possibility of two published packages 

having the same name. The naming conventions describe how to create unique package names, so that packages that 

are widely distributed will have unique namespaces. This allows packages to be separately, easily and automatically 

installed and catalogued. 

In general, a package name begins with the top level domain name of the organization and then the organization's 

domain and then any subdomains listed in reverse order. The organization can then choose a specific name for their 

package. Package names should be all lowercase characters whenever possible. 

For example, if an organization in Canada called MySoft creates a package to deal with fractions, naming the 

package ca.mysoft.fractions distinguishes the fractions package from another similar package created by 

another company. If a US company named MySoft also creates a fractions package, but names it 

us.mysoft.fractions, then the classes in these two packages are defined in a unique and separate namespace. 

Complete conventions for disambiguating package names and rules for naming packages when the Internet domain 

name cannot be directly used as a package name are described in section 7.7 of the Java Language Specification. 

Core packages in Java SE 6



java.lang — basic language functionality and fundamental types 

java.util — collection data structure classes 

java.io — file operations 

java.math — multiprecision arithmetics 

java.nio — the New I/O framework for Java 

java.net — networking operations, sockets, DNS lookups, ... 

java.security — key generation, encryption and decryption 

java.sql — Java Database Connectivity (JDBC) to access databases 

java.awt — basic hierarchy of packages for native GUI components 

javax.swing — hierarchy of packages for platform-independent rich GUI components 

java.applet — classes for creating and implementing applets 


• Java Language Specification, 3rd Edition, Chapter 7: Packages [4] 

• Code Conventions for the Java Programming Language, Chapter 9: Naming conventions [5] (mentions packages) 

• Sun's "Java Tutorials" Lesson: Packages [6] 

References 

[1] http:/ / java. sun. com/ docs/ books/ tutorial/ java/ package/ managingfiles. html 

[2] http:/ / java. sun. com/ docs/ books/ tutorial/ java/ package/ createpkgs. html 

[3] http:/ / java. sun. com/ docs/ books/ jls/ second_edition/ html/ packages. doc. html#26639 

[4] http:/ / java. sun. com/ docs/ books/ jls/ third_edition/ html/ packages. html 

[5] http:/ / java. sun. com/ docs/ codeconv/ html/ CodeConventions. doc8. html 

[6] http:/ / java. sun. com/ docs/ books/ tutorial/ java/ package/ index. html


Parboiled (Java) 

Developer(s) Mathias Doenitz 

Initial release November 12, 2009 





Website http:/ / www. parboiled. org/ 

parboiled is an open-source Java library released under an Apache License. It provides support for defining PEG 

parsers directly in Java source code. 

parboiled is commonly used as an alternative for regular expressions or parser generators (like ANTLR or JavaCC), 

especially for smaller and medium-size applications. 

Apart from providing the constructs for grammar definition parboiled implements a complete recursive descent 

parser with support for abstract syntax tree construction, parse error reporting and parse error recovery. 

Example 

Since parsing with parboiled does not require a separate lexing phase and there is no special syntax to learn for 

grammar definition parboiled makes it comparatively easy to build custom parsers quickly. 

Consider this the following classic “calculator” example, with these rules in a simple pseudo notation 

Expression ← Term ((‘+’ / ‘-’) Term)* 

Term ← Factor (('*' / '/') Factor)* 

Factor ← Number / '(' Expression ')' 

Number ← [0-9]+ 

With parboiled this rule description can be translated directly into the following Java code: 

import org.parboiled.BaseParser; 

public class CalculatorParser extends BaseParser { 

public Rule expression() { 

} 

return sequence( 

); 

term(), 

zeroOrMore( 

public Rule term() { 

) 

sequence( 

) 

firstOf('+', '-'), 

term()


} 

} 

return sequence( 

); 

factor(), 

zeroOrMore( 

public Rule factor() { 

} 

) 

return firstOf( 

); 

sequence( 

) 

number(), 

public Rule number() { 

} 

firstOf('*', '/'), 

factor() 

sequence('(', expression(), ')') 

return oneOrMore(charRange('0', '9')); 

The class defines the parser rules for the language (yet without any actions), which could be used to parse actual 

input with code such as this: 

String input = "1+2"; 

CalculatorParser parser = 

Parboiled.createParser(CalculatorParser.class); 

ParsingResult result = ReportingParseRunner.run(parser.expression(), 

input); 

String parseTreePrintOut = ParseTreeUtils.printNodeTree(result); 

System.out.println(parseTreePrintOut); 

See also 

• Parsing expression grammars 

• Regular expressions 

• ANTLR 

• JavaCC 


• Official parboiled web site [1] 

• Example of a complete Java 5 parser written with parboiled [2]


References 

[1] http:/ / www. parboiled. org/ 

[2] http:/ / github. com/ sirthias/ parboiled/ blob/ master/ examples/ org/ parboiled/ examples/ java/ JavaParser. java 

Plain Old Java Object 

In computing software, POJO is an acronym for Plain Old Java Object. The name is used to emphasize that a 

given object is an ordinary Java Object, not a special object, and in particular not an Enterprise JavaBean. The term 

was coined by Martin Fowler, Rebecca Parsons and Josh MacKenzie in September 2000: 

"We wondered why people were so against using regular objects in their systems and concluded that it 

was because simple objects lacked a fancy name. So we gave them one, and it's caught on very 

nicely." [1] 

The term "POJO" is mainly used to denote a Java object which does not follow any of the major Java object models, 

conventions, or frameworks such as EJB. The term continues the pattern of older terms for technologies that do not 

use fancy new features, such as POTS (Plain Old Telephone Service) in telephony, and PODS (Plain Old Data 

Structures) that are defined in C++ but use only C language features, and POD (Plain Old Documentation) in Perl. 

The equivalent to POJO on the .NET framework is Plain Old CLR Object. 

Contextual variations 

The POJO phenomenon has most likely gained widespread acceptance because of the need for a common and easily 

understood term that contrasts with complicated object frameworks. A JavaBean is a POJO that is serializable, has a 

no-argument constructor, and allows access to properties using getter and setter methods. An Enterprise JavaBean is 

not a single class but an entire component model (again, EJB 3 reduces the complexity of Enterprise JavaBeans). As 

designs using POJOs have become more commonly-used, systems have arisen that give POJOs some of the 

functionality used in frameworks and more choice about which areas of functionality are actually needed. Hibernate 

and Spring are examples. 

Ideally speaking, a POJO is a Java object not bound by any restriction other than those forced by the Java Language 

Specification. I.e., a POJO should not have to 

1. Extend prespecified classes, as in 

public class Foo extends javax.servlet.http.HttpServlet { ... 

2. Implement prespecified interfaces, as in 

public class Bar implements javax.ejb.EntityBean { ... 

3. Contain prespecified annotations, as in 

@javax.ejb.Entity public class Baz{ ... 

However, due to technical difficulties and other reasons, many software products or frameworks described as 

POJO-compliant actually still require the use of prespecified annotations for features such as persistence to work 

properly.


POJO generation projects 

Prevayler [2] 

an open source system prevalence layer that transparently persists POJOs. 

BeanExaminer [3] 

framework to present any java objects in an interactive surface to browse and edit them. A generator is 

included to create the desired pojo's through a given db connection. 

Roma Meta Framework [4] 

DDD centric framework. The innovative holistic approach lets the designer/developer to view anything as a 

POJO: GUI, I18N, Persistence, etc. 

OpenXava [5] 

Framework to develop J2EE business applications rapidly and easily. It's based in business components 

defined with XML. Feature rich and flexible since it's used for years to create business applications. Generates 

POJO Hibernate EJB2 and EJB3 JPA ... 

PlainXML [6] 

PAT [7] 

Generating POJO by DTD; XML-POJO mapping via Java5 annotations or DTD; XML manipulations using 

POJO without SAX/DOM; Preprocessing of XML documents using expression language; Binary XML; RMI 

friendly XML; Exporting to JSON; XML marshall/unmarshall ... 

AOP (JBossAOP) persistence library (aspect library). Provides persistence layer with underlying Prevayler 

(1.02). Allows users to write their code without worrying about persistence code (POJO). Uses annotations. 

Java O/RM [8] 

This is a Java Object Relational mapping tool that is very simple to use. It works with all major databases and 

requires only minimal coding effort. JOR strictly follows the POJO / POJI (Plain Old Java Objects / Plain Old 

Java Interfaces) model. 

AutoPersistJ [9] 

This project aims to assist developers in developing java EE persistence layer for existing database tables. It 

gets metadata of selected database tables and generates classes for them. it uses and extends the ideas of 

DbGen project to EJB 3.0 POJO. 

PojoGen [10] 

Pojodbc [11] 

It is a small tool to generate Java Code (a POJO) for an APPFUSE-based project from a DDL file, which is 

created from an ER diagram by Microsoft VISIO. It makes an APPFUSE-based project more easy to use. 

An easy-to-use Java Object Relation mapping library without configurations file or annotations. Built on top 

of JDBC, you still use your optimized native SQL and get POJOs. 

Apache Felix iPOJO [12] 

A new type of dynamic service-oriented component runtime that runs pure POJO applications on the top of 

OSGi platforms. Non-functional (extra-functional) services can be added and removed at runtime. 

JBoss Microcontainer [13] 

The JBoss Microcontainer is a refactoring of JBoss's JMX Microkernel to support direct POJO deployment 

and standalone use outside the JBoss application server. 

Naked Objects [14]


An open source framework that auto-creates an object-oriented user interface from POJOs using the naked 

objects pattern. 

Metawidget [15] 

A 'smart User Interface widget' that populates itself, at runtime, with UI components to match the properties of 

POJOs. 

fbDaoGenerator [16] 

Fbdaogenerator connects to a Firebird Database, reads the metadata of the Database by querying the 

system-tables, and generates POJOs and Data Access Objects. 

Pojo Testing Projects 

• OpenPojo [17] a pluggable testing framework 

See also 

• Data Transfer Object 

• Anemic Domain Model 

References 

[1] MF Bliki: POJO (http:/ / www. martinfowler. com/ bliki/ POJO. html) from MartinFowler.com 

[2] http:/ / prevayler. org 

[3] https:/ / sourceforge. net/ projects/ beanexaminer 

[4] http:/ / www. romaframework. org 

[5] http:/ / sourceforge. net/ projects/ openxava 

[6] http:/ / sourceforge. net/ projects/ plainxml 

[7] http:/ / sourceforge. net/ projects/ patsystem 

[8] http:/ / sourceforge. net/ projects/ jor 

[9] http:/ / sourceforge. net/ projects/ auto-persist-j 

[10] http:/ / sourceforge. net/ projects/ pojogen 

[11] http:/ / sourceforge. net/ projects/ pojodbc 

[12] http:/ / cwiki. apache. org/ FELIX/ ipojo. html 

[13] http:/ / labs. jboss. com/ jbossmc/ 

[14] http:/ / www. nakedobjects. org/ home/ index. shtml 

[15] http:/ / www. metawidget. org 

[16] http:/ / code. google. com/ p/ fbdaogenerator 

[17] http:/ / code. google. com/ p/ openpojo


Pluggable look and feel 

Pluggable look and feel is a mechanism used in the Java Swing widget toolkit allowing to change the look and feel 

of the graphical user interface at runtime. 

Swing allows an application to specialize the look and feel of widgets, by modifying the default (via runtime 

parameters), deriving from an existing one, by creating one from scratch, or, beginning with J2SE 5.0, by using the 

skinnable synth look and feel, which is configured with an XML property file. The look and feel can be changed at 

runtime. 

Architecture 

The corresponding API includes: 

• Hooks in Swing widgets to interact with their look and feel. Each widget defined in Swing can delegate its 

"painting" to its associated user interface classes called UI delegates. 

• An API to manage existing look and feel definitions. This API allow to set the look and feel or switch from look 

and feels at runtime. 

• Another API to define a specific look and feel, or derive a look and feel from an existing one. 

Examples of look and feels 

Platform look and feels 

The Java platform comes with several bundled look and feels [1] : 

• A default cross-platform look and feel, called Metal (see MetalLookAndFeel). This look and feel comes with 

several themes: 

• The DefaultMetalTheme, which was historically the first Swing default theme. 

• The smoother OceanTheme, which became the default theme for Java 5.0. 

• Other cross-platform look and feels: 

• A skinnable look and feel called synth (see synth), which is configured with an XML property file. 

• The Nimbus look and feel (based on synth), which is added for the Java SE 6 Update 10 [2] [3] . 

• Platform dependent look and feels [4] : Look and feels that aim to be the closest as possible to the platform native 

GUI. The fidelity to the native look and feel theming has been improved in recent Java versions by leveraging the 

[5] [6] 

platform native GUI theming library when possible 

• A Windows look and feel (this look and feel depends on the version of the Windows Operating System), 

• A Motif or GTK+ (for newer distributions) look and feel on Linux or Solaris, 

• A specific vendor look and feel for IBM AIX, HP-UX, and Mac OS X.


Third-party look and feels 

Numerous other look and feels have been developed by third parties, such as: 

• Substance [4] , a skinnable look and feel, 

• Napkin [7] , which can be used to make GUI work look provisional, 

• Synthetica [8] , which is based on synth, 

• Liquid [9] , which aim to look like the Liquid theme for KDE, 

• JGoodies [10] Windows and plastic look and feels. 

See also 

• Look and feel 

• Swing 


• a list of Java look and feels [11] 

• Sun's tutorial overview of the pluggable look and feel mechanism [12] 

• Swing pluggable look and feel architecture [13] 

• Sun's tutorial on setting the look and feel in Java [14] 

References 

[1] "Java Tutorials: Available Look and Feels" (http:/ / java. sun. com/ docs/ books/ tutorial/ uiswing/ lookandfeel/ plaf. html#available). Sun 

Microsystems. 2008-02-14. . Retrieved 2008-05-25. 

[2] Potts, Jasper (2007-12-07). "Nimbus Category" (http:/ / www. jasperpotts. com/ blog/ category/ nimbus/ ). . Retrieved 2008-05-25. 

[3] "Nimbus" (http:/ / java. sun. com/ javase/ downloads/ ea/ 6u10/ nimbus. jsp). Sun Microsystems. . Retrieved 2008-05-25. 

[4] "Available Look and Feels" (http:/ / java. sun. com/ docs/ books/ tutorial/ uiswing/ lookandfeel/ plaf. html#available). Sun Microsystems. . 


[5] "GTK Native L&F Fidelity" (http:/ / bugs. sun. com/ bugdatabase/ view_bug. do?bug_id=6185456). Sun Microsystems. . Retrieved 

2008-05-25. 

[6] "XP L&F does not work on Windows Vista (Longhorn) - needs to use uxtheme api" (http:/ / bugs. sun. com/ bugdatabase/ view_bug. 

do?bug_id=5106661). Sun Microsystems. . Retrieved 2008-05-25. 

[7] http:/ / napkinlaf. sourceforge. net/ 

[8] http:/ / www. javasoft. de/ jsf/ public/ products/ synthetica 

[9] https:/ / liquidlnf. dev. java. net/ 

[10] http:/ / www. jgoodies. com/ freeware/ looks/ index. html 

[11] http:/ / www. java2s. com/ Product/ Java/ Swing/ Look-And-Feel-LaF. htm 

[12] http:/ / java. sun. com/ docs/ books/ tutorial/ ui/ features/ plaf. html 

[13] http:/ / java. sun. com/ products/ jfc/ tsc/ articles/ architecture/ index. html#pluggable 

[14] http:/ / java. sun. com/ docs/ books/ tutorial/ uiswing/ lookandfeel/ plaf. html


Primitive wrapper class 

A primitive wrapper class in the Java programming language is one of eight classes provided in the java.lang 

package to provide object methods for the eight primitive types. All of the primitive wrapper classes in Java are 

immutable. J2SE 5.0 introduced autoboxing of primitive types into their wrapper object, and automatic unboxing of 

the wrapper objects into their primitive value—the implicit conversion between the wrapper objects and primitive 

values. 

Wrapper classes are used to represent primitive values when an Object is required. The wrapper classes are used 

extensively with Collection classes in the java.util package and with the classes in the java.lang.reflect reflection 

package. 

The primitive wrapper classes and their corresponding primitive types are: 

Primitive type Wrapper class Constructor 

Arguments 

byte Byte byte or String 

short Short short or String 

int Integer int or String 

long Long long or String 

float Float float, double or String 

double Double double or String 

char Character char 

boolean Boolean boolean or String 

The Byte, Short, Integer, Long, Float, and Double wrapper classes are all subclasses of the Number class. 

Void 

Although it is not a wrapper class, the Void class is similar in that it provides an object representation of the void 

return type. The Void class is an uninstantiable placeholder class used by the java.lang.reflect API to hold a 

reference to the Class object representing the Java keyword void.. 

Atomic wrapper classes 

With Java 5.0, additional wrapper classes were introduced in the java.util.concurrent.atomic package. These classes 

are mutable and cannot be used as a replacement for the regular wrapper classes. Instead, they provide atomic 

operations for addition, increment and assignment. 

The atomic wrapper classes and their corresponding types are:


Primitive type Wrapper class 

int AtomicInteger 

long AtomicLong 

boolean AtomicBoolean 

V AtomicReference 

The AtomicInteger and AtomicLong classes are subclasses of the Number class. The AtomicReference class accepts 

the type parameter V that specifies the type of the object reference. (See "Generics in Java" for a description of type 

parameters in Java). 

See also 

• java.lang 

• java.lang.reflect 


• Java syntax 

Project Semplice 

Ģ Project Semplice is a project announced at the 2006 JavaOne conference to develop tools to allow Visual Basic 

6.0 source code to be compiled into Java applications. 

What the project does is develop a script engine for BASIC, which would then be interpreted by the Java Virtual 

Machine. 

As to this point, the project is still being developed and that it is not yet available to the public. Although, IDEs like 

NetBeans is already available for Java Developers, the capability of Visual Basic's Rapid Application Development 

is also to be developed. 

The project's main goal is to provide VB6 Developer's a free solution of building Web/Desktop Application which 

would be system independent. 

UPDATE: This project appears to be dead at the moment. 2 of its 3 main developers have left Sun* [1] . No code has 

been publicly released. 


• Project Semplice on Herbert Czymontek's blog [2] 

• Project Semplice on Tor Norbye's blog [3] 

• JavaOne Project Semplice presentation [4] 

References 

[1] http:/ / blogs. sun. com/ tor/ entry/ semplice_update 

[2] http:/ / blogs. sun. com/ herbertc/ entry/ project_semplice_visual_basic_for 

[3] http:/ / blogs. sun. com/ tor/ entry/ semplice_keynote_demo 

[4] https:/ / www28. cplan. com/ javaone06_cv_124_1/ sessions_catalog. jsp?ilc=124-1& ilg=english& isort=1& is=%3CISEARCH%3E& 

ip=yes& itrack=+ & isession_type=+ & isession_id=TS-3576& iabstract=& ispeaker=& ispk_company=


Quark Framework 

Paradigm functional, non-strict, modular 


Designed by Luke Evans, Bo Ilic (Business 

Objects) 

Typing discipline static, strong, inferred 

Major implementations Open Quark Framework for Java [1] 

Dialects -- 

Influenced by Haskell, Clean, Java 

Influenced -- 

The Quark Framework (Open Quark) consists of a non-strict functional language and runtime for the Java 

platform. The framework allows the compilation and evaluation of functional logic on the Java Virtual Machine 

(JVM), directly or under the control of a regular Java application. The native language (syntax) for the Quark 

Framework is called CAL. A full range of Java APIs provides the means to invoke the CAL compiler, manipulate 

workspaces of modules, add metadata and evaluate functional logic. Functional logic is usually dynamically 

compiled to Java bytecodes and executed directly on the JVM (with some small kernel logic controlling the normal 

evaluation order). However, an interpreter (G-machine) is also available. 

Motivation, History and Concept 

CAL, and the associated tools and APIs forming the Quark Framework, was conceived in 1998 within Seagate 

Software (later Crystal Decisions, now Business Objects) as a way to enable a common framework for sharing 

business logic across business intelligence products. A framework was desired that would allow data behaviour to be 

captured, at all levels of abstraction, and for these components to be composable into the actual data flows that 

individual products required. In general terms, such a system had to provide a way to express data behaviour 

declaratively, with universal composition and typing laws. In essence, this places the problem firmly in the domain 

of functional languages, and the desire to allow machine compositions of functions without incurring increasing 

efficiency penalties strongly suggested a non-strict evaluation semantic. 

As well as the operational requirements, it was envisaged that future application logic would likely be written for a 

dynamic platform (such as Java or .Net), and therefore it was determined that the Quark Framework should be native 

to Java (initially) with considerable emphasis on performance and interoperability with application logic written on 

that platform. In 1999, work began in Crystal's Research Group on an implementation of this framework. Many of 

the original insights into lazy functional systems were drawn from implementations of Haskell. Early on, Haskell 

(HUGS, GHC) was even considered as a starting point for the implementation itself, but a number of requirements 

made this impractical, so it was decided to let the project emerge and evolve freely following its own design criteria. 

For the first few years of development, the CAL source language itself was not a primary motivator, but the 

operational semantics were of primary concern. At this time, CAL was merely a convenient script for expressing 

functions rather than composing them programmatically through Java APIs, or using a graphical language native to a 

tool called the Gem Cutter, which began to be implemented in mid-2000 as a way to author systems of functions that


could be used in applications. From about 2002 onward, the CAL language became rather more central to the Quark 

Framework, especially once programmers began to create usable libraries of functions for real applications. As the 

language evolved, so did the demand for tools, and so a range of tools and utilities were created in parallel to 

language development to support those doing real work with the platform. 

While the Gem Cutter remained the main development environment in the initial years, since late 2005 there has 

been an intention to produce Eclipse-based tools, and the emphasis has shifted to activities advancing the state of 

Eclipse integration. 

The motivations for the Quark Framework appear to be similar to those driving Microsoft's LINQ project, in 

particular the desire for a declarative style and some lazy evaluation for certain kinds of logic, hosted within 

applications coded in an Object Oriented language. While CAL cannot yet be embedded inline within Java source, 

generated functions are fully compiled and the system can efficiently share data between CAL and Java sourced 

logic. For instance, CAL lists can be marshalled dynamically to and from Java data structures that implement the 

Iterator interface. 

In 2007, the Quark Framework is an advanced and well tested framework for integrating non-strict functional logic 

into Java programs. It can be used as a standalone functional language too, that happens to compile to Java 

bytecodes. The framework was offered as open source under a BSD-style license in January 2007, and continues to 

be used and developed within Business Objects. 

CAL 

CAL is the name of a programming language originally developed by Business Objects and now released as "Open 

Quark", with sources, under a BSD-style license. It is a lazy functional programming language similar to the Haskell 

programming language. An implementation is available from the Business Objects Labs [2] site. CAL forms part of 

the Quark Framework which includes a visual programming tool, Gem Cutter. 

One of the main objectives of the Quark Framework is to allow logic expressed in a declarative, lazy functional style 

to be easily and efficiently integrated into Java applications. CAL source is typically compiled directly to byte codes 

(though an interpreter is also available), and can be called from regular OO code. In turn CAL code can call any Java 

code. Evaluation of CAL programs, and exploration of results can be completely controlled by procedural code, 

allowing data transformation logic (for which CAL is ideally suited) to be flexibly integrated into Java applications. 

A Java program can also easily build new functions on-the-fly, to describe transient data flows, or to create persisted 

logic. This form of 'functional metaprogramming' is common in real-world deployments of the Quark Framework. 

The CAL language borrows much from Haskell syntax, but also eschews some Haskell features. As such, CAL is a 

strongly typed, lazily evaluated functional language, supporting algebraic functions and data types with parametric 

polymorphism and type inferencing. CAL has special syntax for strings, tuples, characters, numbers, lists and 

records. Single parameter type classes are supported, with superclasses, derived instances, deriving clauses for 

common classes, default class methods and higher-kinded type variables. While doubtless a subjective measure, 

CAL's developers have tried to keep the language simple. In particular, only the expression style is supported 

(Haskell's equation based style with argument pattern matching is not supported), and CAL does not make use of 

layout (semicolons are required to terminate definitions). CAL also makes certain syntactic choices to align it more 

strongly with Java. For instance, Java's syntax for comments is used, and CAL's inline documentation comments are 

close to JavaDoc. 

One of the main differences between Haskell and CAL is in the area of interfacing with the 'real world'. Whereas 

Haskell goes to great lengths to validate the purity of functions, CAL relies on the programmer to hide 'imported 

impurity', exposing pure functions from a module where impure imports are made. CAL has a range of mechanisms 

for controlling evaluation order and laziness. These are often essential tools in the creation of effective solutions with 

native functions, but are also important in the aforementioned interface with the stateful world. The choice to 

de-emphasise formal tracking of purity, in favour of mechanisms to allow the programmer to express the right logic,


has proven to provide a good balance of flexibility and 'directness' when interfacing with external operations. 

One of the main design goals for CAL was to make the language as comfortable as possible for mainstream 

developers to pick up and use effectively. This is reflected in choices for syntax, but also in conventions and patterns 

used within the standard libraries. For example, libraries use longer, descriptive names and are commented to explain 

the implementations and best practices for use. 

To see some CAL language source code click here [3] . This tutorial CAL module is designed as a top-to-bottom 

'feature parade' to showcase basic syntax with examples of some built-in and user defined data structures. 

Here are a few examples, derived from the tutorial module linked to in the preceding paragraph: 

1. Quicksort 

/** 

* Here is a simple implementation of the quicksort algorithm for lists in 

* CAL. 

* 

* Note: it is not the most efficient implementation, since it filters the 

* list twice to partition. 

* 

* It is used here as an illustration. The production implementation of 

* sorting on lists is 

* {@link List.sort@}. 

* 

* The type of quicksort is constrained by the {@link Ord@} type class. This 

* means that quicksort can sort list of any orderable type. 

*/ 

quicksort :: Ord a => [a] -> [a]; 

quicksort list = 

let 

in 

//partition_min is a local function of 1 argument 

partition_min pivot = filter (\x -> x < pivot); 

partition_max pivot = filter (\x -> x >= pivot); 

case list of 

[] -> []; 

pivot : tail -> 

; 

quicksort (partition_min pivot tail) 

++ (pivot : (quicksort (partition_max pivot tail))); 

Note that CAL supports inline documentation comments, with embedded tags. Function type declarations 

immediately precede the function definition. CAL supports type classes (e.g. Ord). Two local functions are declared 

in the let block. Quicksort has a recursive definition, building up the output list at each level of recursion from the 

sorts applied to the list of values either side of the pivot item.


2. Data Declarations 

In common with other functional languages, CAL provides a way to declare new types using data declarations. Here 

is an example of declaring a new data type for 'Employee': 

/** 

* The Employee data type is an example of a CAL algebraic data type. It 

* has one data constructor, RegularEmployee. The RegularEmployee data 

* constructor has 3 fields: name, manager and directReports. 

* 

* The firstName and lastName fields have type String. The manager field 

* has type Maybe Employee. This reflects the fact that an employee may 

* have one manager or no managers (in the case fo the CEO), and that 

* manager is also an Employee. directReports has type [Employee] i.e. a 

* list of 0 or more employees. Note that the manager and directReports 

* fields have types that recursively refer to the Employee type. In other 

* words, Employee is a recursive algebraic data type. 

*/ 

data Employee = 

RegularEmployee 

name :: String 

//the employeeID field is a potential future addition to the 

//Employee data type. Notice below that case expressions using 

//field-name based extraction would not need to be updated due 

//to this change, but case expressions using positional based 

//extraction would need updating. 

//employeeID :: Int 

manager :: (Maybe Employee) 

directReports :: [Employee] 

//This deriving clause provides a default instance implementation for 

//the Show type class for the Employee type. Essentially what this 

//means is that the Debug.show function will work with Employee 

//values to display a String representation of the value suitable for 

//debugging purposes. 

deriving Show; 

Note that fields (data constructor arguments) must have names in CAL, as well as their type. The deriving clause 

makes the data type work with functions defined in certain type classes. Here we ensure that CAL automatically adds 

the requisite logic to make values of Employee be renderable as strings for the purposes of tracing. 

Fields can be extracted in a variety of ways: 

a) Positionally in a case expression: 

/** 

* @arg employee 

* @return the employee's name 

*/ 

employeeName :: Employee -> String; 

employeeName employee = 

case employee of


//illustrates positionally based case expression extraction of the 

//"name" field of the RegularEmployee data constructor 

RegularEmployee empname _ _ -> empname; 

; 

b) By field name in a case expression: 

/** 



*/ 



case employee of 

//illustrates field-name based case expression extraction of the 

//"name" field of the RegularEmployee data constructor 

RegularEmployee {name} -> name; 

; 

This method is obviously more stable with respect to changes in data constructor arguments than the positional 

version 

c) By a selector expression 

/** 



*/ 



//illustrates data constructor field selection of the directReports 

//field 

employee.RegularEmployee.name; 

Note that CAL allows multiple constructor arguments to be cited in a case extractor, along with multiple constructors 

to match on (so long as they all have the named arguments). So, the following scenario is possible (assuming the 

data declaration includes the employeeID field and new constructors for Contractor and Associate): 

// ...snip... 

case employee of 

//illustrates multiple field case expression extraction over multiple 

//data constructors. Note the local renaming of the employeeID field 

//to 'id' 

(RegularEmployee | Contractor | Associate) {name, employeeID = id } -> (name, id); 

; 

// ...snip...


3. Records 

CAL unifies tuples and records, which can be used as containers for heterogeneously typed values (as compared to 

lists, which are sequences of values of the same type). Records are extensible and can be convenient for passing 

collections of values where the formality of a new data definition is not necessary. Records can have textual or 

numeric (ordinal) indexed fields. Traditional tuples are simply records with exclusively ordinal fields and tuple 

constructors (parentheses) simply generate ordinal fields in sequence up from #1. 

Here are three examples of records: a tuple (demonstrating its simpler constructor syntax), a record with ordinal 

fields (fully equivalent to the first tuple) and a record with mixed ordinal and named fields: 

/** 

* A record with 3 fields: field #1 has type String, field #2 has type Maybe 

* Boolean and field #3 has type [Double]. 

* It is expressed using tuple notation. 

*/ 

tupleRecord1 :: (String, Maybe Boolean, [Double]); 

tupleRecord1 = ("apple", Just True, [2.0, 3.0, -5]); 

/** 

* This record actually has the same value as tupleRecord1, but it includes 

* field names explicitly, and thus uses braces rather than parentheses. 

* When using explicit field names, the ordering of the fields does not 

* matter. 

*/ 

tupleRecord2 :: {#1 :: String, #3 :: [Double], #2 :: Maybe Boolean}; 

tupleRecord2 = {#3 = [2.0, 3.0, -5], #1 = "apple", #2 = Just True}; 

/** 

* Here is a record with both textual and ordinal fields. 

*/ 

mixedRecord1 :: {#1 :: Maybe [Int], #2 :: Boolean, age :: Double, name :: String}; 

mixedRecord1 = {name = "Anton", age = 3.0, #1 = Just [10 :: Int, 20], #2 = False}; 

CAL on Java 

The CAL compiler takes CAL source, as text or as a source model (Java object model). This is processed by the 

early compiler stages to desugar and analyse the source. The intermediate form, plus metadata from analysis, is 

processed by a number of optimisers, optionally including a full rewrite optimiser capable of function fusion, 

deforestation and other major optimisations that preserve semantics but improve a program operationally. 

The compiler supports plugable back-ends. First amongst these is LECC (Lazily Evaluating CAL Compiler). This 

back-end generates Java classes and byte codes directly, emitting methods according to compiler schemes that take 

account of context metadata derived in the compiler, such as strictness of function arguments. LECC can package 

generated code in a number of ways, including as a CAL Archive (CAR), or a Java JAR. At runtime, a class loader 

can load an entire corpus of functions, or the Quark Framework loader can load closely connected functions 

according to prior dependency analysis. This latter feature is important to minimise start up times, whereby only the 

functions actually required by an application incur loading overhead. 

The LECC back-end can also generate Java source code, which is then compiled by the regular JDK Java compiler 

to produce class files. Amongst other things, this is very useful when validating compiler schemes during compiler 

development, and provides a way to reason about the operational behaviour of CAL on the Java platform.


As well as LECC, Open Quark includes a G-machine interpreter and a compiler back-end that generates G-machine 

code. While considerably slower than LECC, this option is useful for experiments and may be a better fit for some 

deployments. 

While many deployments of CAL may use the language standalone, the Quark Framework is fundamentally 

designed to be used within regular Java applications to provide a hybrid/multi-paradigm system. The intent is to 

allow transformational logic, which benefits from more algebraic representation, to be embeddable within Java OO 

logic handling regular (stateful) aspects of the application. To this end, CAL supports a very powerful and easy to 

use interface to Java, and the Quark Framework SDK allows Java code considerable control over how functions are 

evaluated and results produced. Java code can issue new functions to the Quark Framework for compilation, which 

can be immediately available for evaluation. Thus, Java can use the Quark Framework as a functional 

meta-programming environment. This has been a common use case for the framework, and is supported efficiently 

(low latency, with concurrent compilation and evaluation). On the consumption side, results can be presented to Java 

as lazy suspensions, so that minimal functional evaluation is performed and only when Java logic requests the 'next' 

output value. This feature allows data-flow logic to be constructed on-the-fly within a Java application, used 

on-demand and then disposed of if necessary. Both the LECC and G-machine runtimes are able to load and unload 

functions from memory to support a fully dynamic environment. 

The 'foreign' interface between CAL and Java is able to import any Java entity into CAL and make calls on Java 

methods. Values are passed efficiently between the two environments, without unnecessary boxing/unboxing 

operations. A powerful feature called "I/O policies" allows values to be lazily marshalled between structures if 

required (for instance, if you have a particular Java class or data structure that you wish to produce to represent a 

CAL value). These policies are declared completely on the CAL side, leaving the Java side 'natural'. The default 

policies are usually quite sufficient to share values, so usually nothing special must be done to exchange values. 

Here are some examples of CAL code that declares interfaces to Java entities: 

1. Importing a Java type, a constructor and a method 

The following code imports the "java.util.LinkedList" class (which becomes the CAL 'opaque' data type 

"JLinkedList"). The fragment then imports the default constructor for this class, and the instance method 'add'. All of 

these imports are marked private, which means that they would only be usable within the importing CAL module. 

This is quite common, as its usually good practise to export public functions from modules that behave as pure 

functions. 

data foreign unsafe import jvm "java.util.LinkedList" 

private JLinkedList deriving Inputable, Outputable; 

foreign unsafe import jvm "constructor" 

private linkedList_new :: JLinkedList; 

foreign unsafe import jvm "method add" 

private linkedList_add :: JLinkedList -> JObject -> Boolean;


2. Fields can be imported too 

foreign unsafe import jvm "static field java.lang.Float.NEGATIVE_INFINITY" floatNegativeInfinity :: Float; 

This is especially useful for constants, per the example. 

3. Casts for Java types 

Occasionally, it is necessary to cast between Java types that have been imported. For instance, JObject and JList are 

imported in the Prelude. If you needed to cast between them in CAL, then you could declare the appropriate casting 

functions. These declarations are properly checked for validity. 

foreign unsafe import jvm "cast" castObjectToList :: JObject -> JList; 

foreign unsafe import jvm "cast" castListToObject :: JList -> JObject; 

Of course, with casting, there's always the potential for runtime class cast exceptions, so it's a good thing that CAL's 

exception features are fully integrated with Java too, e.g. ... 

4. Java Exceptions 

The following fragment shows a CAL exception type being declared and a function that can demonstrate the 

throwing in CAL of this exception, or a Java NullPointerException depending on the argument it is passed. Note that 

CAL exceptions can have any payload. The definition of nullPointerException_make is not shown for brevity. 

data MyExceptionType a = 

MyExceptionType 

message :: String 

someOtherStuff :: a 

list :: [a] 

deriving Show 

; 

instance Exception Double where; 

instance Exception a => Exception (MyExceptionType a) where; 

//this is an interesting example because the JNullPointerException is not 

//caught by the JThrowable catch clause. exceptions thrown by CAL (with 

//CAL types) must be caught using their CAL type. 

calThrownException1 :: Int -> String; 

calThrownException1 n = 

( 

) 

if n < 0 then 

throw (MyExceptionType "spinach salad" 10.0 [20, 30, 40]) 

else if n > 0 then 

else 

`catch` 

throw (nullPointerException_make "a new NullPointerException") 

"all OK" 

(\ex -> "caught MyExceptionType: " ++ show (ex :: MyExceptionType Double)) 

`catch` 

(\ex -> "caught Throwable: " ++ show (ex :: JThrowable))


`catch` 

(\ex -> "caught NullPointerException: " ++ show (ex :: JNullPointerException)) 

; 

If you want, you can make any type an Exception. See the following fragment: 

instance Exception String where; 

instance Exception Int where; 

instance Exception Integer where; 

instance Exception a => Exception (Maybe a) where; 

instance Exception a => Exception [a] where; 

instance Exception r => Exception {r} where; 

//tests using various Cal types as Exception types, including the interesting 

//case of records 

calThrownException5 = 

throw ("abc", 1 :: Int, 2 :: Integer, ["abc", "def"], Just (20 :: Int)) 

`catch` 

( 

); 

let 

in 

handler :: (String, Int, Integer, [String], Maybe Int) -> String; 

handler r = show (r.#5, r.#4, r.#3, r.#2, r.#1); 

handler 

Finally, and just for fun, we show how you can map an exception handler over a list! 

handleAnyThrowableWithDefault :: a -> JThrowable -> a; 

handleAnyThrowableWithDefault def throwable = def; 

exceptionTest1 :: Boolean; 

exceptionTest1 = 

List.map (\x -> x `catch` handleAnyThrowableWithDefault (-999)) 

[(4 :: Int) / 1, 10 /2, 5 / 0, (1 - 1) / 0, 2 / 2, 5 / (2 -2)] 

== [4, 5, -999, -999, 1, -999] 

; 

The three arithmetic exceptions (divide by zero) are converted to the default value (-999) by the exception handler. 

External references 

Downloads of Open Quark (with and without sources) and collateral are currently hosted at the Open Quark [1] site. 

The following documents are available: 

• The CAL Users Guide [4] - The main reference for the CAL language 

• CAL for Haskell Programmers [5] - A comparison of CAL with Haskell for those with familiarity of the latter 

• Effective CAL [6] - A discussion of best practices when programming in CAL 

• Open Quark Library documentation [7] - The HTML docs generated from library CAL Doc 

• The Gem Cutter Manual [8] - The main reference for the Graphical Language and its tool, the Gem Cutter 

• Open Quark Java SDK documentation [9] - The HTML docs generated from SDK JavaDoc 

• Java meets Quark [10] - A discussion and tutorial for using the SDK to embed Open Quark in Java applications


• Using JFit [11] - The reference for the JFit tool, a batch generator for foreign function declarations in CAL 

• Business Activity Monitor Sample [12] - A case study of embedding Open Quark in a Java app 

References 

[1] http:/ / openquark. org 

[2] http:/ / labs. businessobjects. com/ cal 

[3] http:/ / openquark. org/ Documents/ tutorial_calintro. html 

[4] http:/ / openquark. org/ Documents/ cal_users_guide. pdf 

[5] http:/ / openquark. org/ Documents/ cal_for_haskell_programmers. pdf 

[6] http:/ / openquark. org/ Documents/ effective_cal. pdf 

[7] http:/ / openquark. org/ Documents/ open_quark_cal_doc. zip 

[8] http:/ / openquark. org/ Documents/ gem_cutter_manual. pdf 

[9] http:/ / openquark. org/ Documents/ open_quark_javadoc. zip 

[10] http:/ / openquark. org/ Documents/ java_meets_quark. pdf 

[11] http:/ / openquark. org/ Documents/ using_jfit. pdf 

[12] http:/ / openquark. org/ Documents/ business_activity_monitor_overview. pdf 

REPLAY (software) 

REPLAY is a management system for audiovisual content developed at ETH Zurich. 

Background 

REPLAY was developed as the future Multimedia Portal of ETH Zurich within the scope of the ICT strategy 

2006-2009 and got branded „REPLAY“ in 2007. It is to manage the audiovisual content of ETH Zurich from 

production to distribution in an automated manner. 

Application area 

The main focus of REPLAY is the quasi automated handling of large number of lecture recordings (>150 per week) 

and to provide an integrated management solution for other video objects (films, digitization results etc.). Thus, it 

covers all the audiovisual material usually to be found in academic and other institutions (museums, companies etc.). 

Workflow 

REPLAY covers the complete lifecycle of the audiovisual objects: In the classroom / lecture hall, the Linux-based 

Playmobil as an additional hardware component automatically captures audio, video, and VGA (for 

slides/presentations/computer display/other devices). After the lecture, these sources are bundled with metadata and 

proceeded into the REPLAY backend. Other video material can be ingested through an inbox. All bundles are then - 

archived, - indexed (based on slide content, using Optical Character Recognition), - encoded according to settings 

and - distributed in various channels (RSS, streaming, download etc.) One of the distribution channels is Interplay, a 

user interface designed for interactive consumption of video. 

Much of the indexing and searching functionalites comes from Yovisto, a German metadata search engine for 

academic content.

REPLAY (software) 267 

Qualities 

REPLAY is written in Java, Open Source and oriented towards standards wherever possible. It is modular in design 

and envisaged to run on a singular machine as well as in a distributed environment. 

License 

REPLAY is Open Source under GNU LGPL license version 2. 

Development 

Development website [1] . Replay has been developed towards release 0.7 (March 2009); as of June 2009 the project 

has ended and support was suspended by the end of 2009. Efforts around REPLAY and its technology are beinge 

transferred to the Opencast Matterhorn project. 



• Project website [3] 

• Article from the proceedings of the 36th annual ACM SIGUCCS conference [4] 

• The WSU eLearner blog on REPLAY [5] 

• The ICT en Onderwijs blog on REPLAY (Dutch) [6] 

• Presentation of REPLAY at EDUCAUSE 2008 [7] 

• Article on REPLAY (German) [8] 

• Presentation of REPLAY (German, video) [9] 

References 

[1] http:/ / replay. origo. ethz. ch/ 

[2] http:/ / www. replay. ethz. ch 

[3] http:/ / www. project-replay. ethz. ch/ 

[4] http:/ / portal. acm. org/ citation. cfm?doid=1449956. 1450016 

[5] http:/ / wsuelearner. wordpress. com/ 2008/ 11/ 18/ educause-2008-replay-for-audiovisual-lecture-recordings/ 

[6] http:/ / www. gorissen. info/ Pierre/ item/ 2008/ 10/ 31/ replay-opern-source-lecture-capturing 

[7] http:/ / www. replay. ethz. ch/ docs/ educause 

[8] http:/ / www. workshop. ch/ openmind/ 2008/ 12/ 20/ 

replay-gesamtloesung-zur-aufzeichnung-und-verbreitung-von-vorlesungen-der-eth-zuerich/ 

[9] http:/ / www. tele-task. de/ lectures/ view/ 3910/ real/


Real time Java 

Real time Java is a catch-all term for a combination of technologies that allows programmers to write programs that 

meet the demands of Real time systems in the Java programming language. 

Java's sophisticated memory management, native support for threading and concurrency, type safety, and relative 

simplicity have created a demand for its use in many domains. Its capabilities have been enhanced to support real 

time computational needs: 

• Java supports a strict priority based threading model. 

• Because Java threads support priorities, Java locking mechanisms support priority inversion avoidance 

techniques, such as priority inheritance or the priority ceiling protocol. 

To overcome typical real time difficulties, the Java Community introduced a specification for real-time Java, 

JSR001. A number of implementations of the resulting Real-Time Specification for Java (RTSJ) have emerged, 

including a reference implementation from Timesys, IBM's WebSphere Real Time, Sun Microsystems's Java SE 

Real-Time Systems [1] , Aonix PERC or JamaicaVM from aicas. 

The RTSJ addressed the critical issues by mandating a minimum specification for the threading model (and allowing 

other models to be plugged into the VM) and by providing for areas of memory that are not subject to garbage 

collection, along with threads that are not preemptable by the garbage collector. These areas are instead managed 

using region-based memory management. 

Real-Time Specification for Java 

The Real-Time Specification for Java (RTSJ) is a set of interfaces and behavioral specifications that allow for 

real-time programming in the Java programming language. RTSJ 1.0 was developed as JSR 1 under the Java 

Community Process, which approved the new standard in November, 2001. As of 2006, RTSJ 1.1 is being developed 

under JSR 282. 

See also 

• Functional specification 

• Javolution - RTSJ Compliant Java Library (open-source) 


• Real-Time Specification for Java (RTSJ) [2] 

• JSR-1 [3] 

• IBM WebSphere Real Time [4] a fully conformant RTSJ SE VM 

• JamaicaVM [5] an RTSJ SE implementation with deterministic garbage collection 

• PERC [6] a real-time VM based on Java Standard Edition rather than RTSJ 

• Sun Java SE Real-Time System [7] 

• Apogee real-time Java with real-time GC [8] 

• Timesys RTSJ implementation and testing toolkit [9] 

• jRate (Java Real-Time Extension) [10] an open-source extension of the GNU GCJ compiler front-end and runtime 

system which adds support for most of the features required by the RTSJ. 

• DDC-I Scorpion Java [11] real-time Java SE, with safety-critical and secure versions. 

• International Workshop on Java Technologies for Real-time and Embedded Systems (JTRES 2006) [12] JTRES 

2007 [13] JTRES 2008 [14]


References 

[1] Java SE Real-Time Systems (http:/ / java. sun. com/ javase/ technologies/ realtime/ index. jsp) 

[2] http:/ / www. rtsj. org/ 

[3] http:/ / jcp. org/ en/ jsr/ detail?id=1 

[4] http:/ / www-03. ibm. com/ linux/ realtime. html 

[5] http:/ / www. aicas. com/ jamaica. html 

[6] http:/ / www. aonix. com/ 

[7] http:/ / java. sun. com/ javase/ technologies/ realtime. jsp 

[8] http:/ / www. apogee. com/ 

[9] http:/ / www. timesys. com/ java/ 

[10] http:/ / jrate. sourceforge. net/ 

[11] http:/ / www. ddci. com/ products_scorpion. php 

[12] http:/ / www-users. cs. york. ac. uk/ ~andy/ JTRES06/ 

[13] http:/ / www. vmars. tuwien. ac. at/ jtres2007/ 

[14] http:/ / jtres. java. sun. com/ 2008/ 

Resource (Java) 

In the Java programming language a resource is a piece of data that can be accessed by the code of an application. 

An application can access its resources through Uniform Resource Locators, like web resources, but the resources 

are usually contained within the JAR file(s) of the application. 

A resource bundle is a set of key and value pairs, stored as a resource, that is commonly used to allow the 

localization of an application. For this purpose different resource bundles with a common set of keys are used to 

store translations for the messages and user interface texts of an application. 

References 

Campione, Mary; Kathy Walrath, Alison Huml (2004). "Internationalization" [1] . The Java Tutorial Continued [2] (6 

print. ed.). Addison-Wesley. ISBN 0-201-48558-3. Retrieved April 2006. 

References 

[1] http:/ / java. sun. com/ docs/ books/ tutorial/ i18n/ TOC. html 

[2] http:/ / java. sun. com/ docs/ books/ tutorial/ books/ continued/ index. html

Restlet 270 

Restlet 





Website http:/ / www. restlet. 

org/ 

Restlet is a lightweight, comprehensive, open source REST framework for the Java platform. Restlet is suitable for 

both server and client Web applications. It supports major Internet transport, data format, and service description 

standards like HTTP and HTTPS, SMTP, XML, JSON, Atom, and WADL. A GWT port of the client-side library is 

also available. 

Licenses 

Restlet is available under four different licenses: [1] 

• CDDL ver 1.0 

• LGPL ver 2.1 

• LGPL ver 3.0 

• EPL ver 1.0 

Architecture 

Restlet directly models the concepts (Resource, Representation, Connector, Component, etc.) from Roy T. Fielding's 

original dissertation on the architecture of the Web, Architectural Styles and the Design of Network-based Software 

Architectures [2] . 

The Restlet framework is composed of two main parts. First, there is the "Restlet API", a neutral API supporting the 

concepts of REST and facilitating the handling of calls for both client-side and server-side applications. This API 

must be supported by a Restlet implementation before it can effectively be used. Multiple implementations could be 

provided (open source projects or commercial products). 

It is available in five consistent editions. Each edition targets a special development environment: 

• Google Web Toolkit (GWT) for AJAX applications deployed in desktop browsers, without any plugin required; 

• Google App Engine (GAE/J) for deployment on Google’s cloud computing infrastructure; 

• Android for deployment on compatible smartphones; 

• Java SE for standalone deployments in regular Java Virtual Machines; 

• Java EE for deployment in Servlet engines.

Restlet 271 

Connectors 

The list of available connectors splits into: 

• Server connectors: Servlet, Spring, Jetty, Grizzly, Simple, JAXB, JAX-RS, JiBX, Velocity; 

• Client connectors: Internal, Apache HTTP Client, Net (JDK's HttpURLConnection), JavaMail, JDBC. 

History 

Founder Jerome Louvel of Noelios Consulting began the Restlet project in December 2005, and was the primary 

developer and committer through the project's 1.0 release in April, 2007. [3] He was subsequently joined by Thierry 

Boileau, also of Noelios, and an expanding list of extension developers from the Restlet community. 

The May, 2007 publication of the O'Reilly book RESTful Web Services featured Restlet alongside Django and 

Rails. [4] 

Restlet 1.1 was released October 28, 2008 [5] , and included support for GWT and the then-emerging JAX-RS 

standard. 

On May 6, 2009, Jerome Louvel announced that the planned 1.2 release of Restlet would be renamed 2.0, mainly 

due to significant changes in the modeling of resources. The 2.0 release is targeted for the second half of 2009. [6] 

Features exposed in 2.0 milestone builds include specific support for Google App Engine and Android. 

An upcoming Restlet book ("Restlet In Action") has been announced by Noelios and Manning Press, planned to 

cover Restlet version 2.0. 


• Restlet - Lightweight REST framework for Java [7] 

• JavaWorld article on Restlet [8] 

References 

[1] Restlet - Legal terms (http:/ / www. restlet. org/ about/ legal) 

[2] http:/ / www. ics. uci. edu/ ~fielding/ pubs/ dissertation/ top. htm 

[3] http:/ / www. eweek. com/ c/ a/ Application-Development/ Java-Project-Founder-Outlines-Benefits-of-Restlet/ 

[4] Richardson, Leonard; Ruby, Sam (2007), RESTful Web Services, O'Reilly (published (May 8, 2007)), ISBN 0596529260 

[5] http:/ / blog. noelios. com/ 2008/ 10/ 28/ restlet-110-released/ 

[6] http:/ / restlet. tigris. org/ ds/ viewMessage. do?dsMessageId=2078602& dsForumId=4447 

[7] http:/ / www. restlet. org/ 

[8] http:/ / www. javaworld. com/ javaworld/ jw-12-2008/ jw-12-rest-series-2. html

Retrotranslator 272 

Retrotranslator 

Stable release 1.2.6 / February 29, 2008 


Operating 

system 


Platform Java Virtual Machine 

License BSD-like License 

Website [1] 

Retrotranslator is a program written in Java that converts Java classes (bytecode). The source classes may use Java 

1.5 and Java 1.6 features, whereas the target will be compatible with Java 1.4 and older environments. 

Retrotranslator supports all Java 5 language features and part of the Java 5 API on both J2SE 1.4 and J2SE 1.3. On 

older Java environments only the Java 5 features that don't depend on the new API are supported. Retrotranslator is 

based on the ASM bytecode manipulation framework and the backport of the Java 5.0 concurrency utilities (see 

http:/ / backport-jsr166. sourceforge. net/ ) 

The Stripes Framework developers suggest to use Retrotranslator in order to use Stripes (which extensively use Java 

1.5 features) on a Java 1.4 environment [2] 

Alternative tools 

• Retroweaver 

• Declawer 

• JBossRetro 


• Java backporting tools 

References 

[1] http:/ / retrotranslator. sourceforge. net/ 

[2] http:/ / www. stripesframework. org/ display/ stripes/ Java+ 1. 4+ and+ Stripes

SLAMD 273 

SLAMD 

The SLAMD Distributed Load Generation Engine (SLAMD) is a Java-based application designed for stress testing 

and performance analysis of network-based applications. Initial development of SLAMD was performed at Sun 

Microsystems, with recent development sponsored primarily by UnboundID Corp. [1] . 

SLAMD is available under the terms of the Sun Public License, which is an OSI-approved open source license. The 

main site for obtaining information about SLAMD is available at its main web site [2] , and it is available as a java.net 

[3] project. 

SLAMD was originally developed for the purpose of benchmarking and analyzing the performance of LDAP 

directory servers, and it is the most powerful and flexible tool available for this task. However, it is also well-suited 

for testing other kinds of network applications and has been used for things like Web servers and Web-based 

applications, relational databases, and mail servers. It can also be used for non-network based applications (and in 

fact, it is used for comparing things like CPU power and memory latency across a number of different kinds of 

systems), although its distributed nature makes it ideal for systems that can be accessed remotely. 

Architecture 

SLAMD uses a distributed model consisting of a server (SLAMD is distributed with Apache Tomcat) and clients. 

The operator schedules a new job using a browser, and submits the job for execution. The server sends the scheduled 

job to selected clients, these clients then generate load based on parameters defined in the SLAMD job class and 

report results back to the SLAMD Server. SLAMD 2.0.0-alpha1 uses the Berkeley DB Java Edition. [4] 

Extensibility 

"SLAMD provides a Java-based API to make it possible to quickly develop custom workloads, and it also 

contains an embedded scripting engine that can make it easy to stress applications using protocols like LDAP, 

HTTP, SMTP, IMAP, and POP, or any database that can be accessed via JDBC. It also includes tools for 

recording and playing back TCP traffic, and a utility for intercepting LDAP communication and writing it as a 

script that may be executed in the SLAMD scripting engine." [5] 

SLAMD jobs are managed by Java classes. New SLAMD job classes can be created by writing Java code using a 

well-defined API[6], compiling the Java code, and installing the Job Class (the class is installed on the servers and 

the server pushes it out to the clients). 

Installation 

Supported Systems 

SLAMD is supported on any computer operating system that supports Java, such as Solaris, Linux, AIX, HPUX, and 

Windows. SLAMD version 2 or greater requires Java 5 or greater. 

Jobs 

Benchmarking campaigns are a series of SLAMD jobs. SLAMD jobs are created by filling in the forms in the 

Schedule a New Job page. The operator sets up a job via a browser, then submits the job. The Server sends the job to 

SLAMD Clients. 

The SLAMD Clients generate load based on parameters in the SLAMD job class. Parameters can be items such as 

duration, ramp-up and ramp-down, and any other parameter defined in the Job Class.

SLAMD 274 

Reporting 

SLAMD generates reports in the following formats: 

• HTML 

• Portable Document Format 

• Text file 

See also 

• Benchmarking 


• SLAMD at java.net [3] 

• SLAMD website [7] 

• Benchmarking at about.com [8] 

• Six Sigma [9] 

• MrBenchmark blog at Sun Microsystems [10] 

References 

[1] http:/ / www. unboundid. com 

[2] http:/ / www. slamd. com/ 

[3] http:/ / slamd2. dev. java. net 

[4] http:/ / www. slamd. com/ downloads/ slamd-2. 0. 0-alpha1-release-notes. pdf 

[5] SLAMD Distributed Load Generation Engine - Home (http:/ / www. slamd. com) 

[6] http:/ / www. slamd. com/ docs/ slamd_job_developers_guide. pdf 

[7] http:/ / www. slamd. com 

[8] http:/ / management. about. com/ cs/ benchmarking/ a/ Benchmarking. htm 

[9] http:/ / www. isixsigma. com/ me/ benchmarking/ 

[10] http:/ / blogs. sun. com/ MrBenchmark

SLAMD Server 275 

SLAMD Server 

A SLAMD Server is a server supported by an application server that services SLAMD clients and SLAMD jobs. 

SLF4J 

Developer(s) Ceki Gülcü 



Operating 

system 


Type Logging Tool 

License MIT License 

Website http:/ / www. slf4j. org/ 

Simple Logging Facade for Java (SLF4J) provides a Java logging API by means of a simple facade pattern. The 

underlying logging backend is determined at deployment time and includes java.util.logging [1] , log4j and logback. 

The separation of the client API from the logging backend reduces the coupling between an application and any 

particular logging framework. This can make it easier to integrate with existing or third-party code or to deliver code 

into other projects that have already made a choice of logging backend. 

SLF4J was created by Ceki Gülcü as a more reliable alternative to Jakarta Commons Logging framework. 

Similarities and Differences with Log4j 

• Five of Log4j's six logging levels are used. FATAL has been dropped on the basis that inside the logging 

framework is not the place to decide when an application should terminate and therefore there is no difference 

between ERROR and FATAL from the logger's point of view. 

• Logger instances are created via the LoggerFactory, which is very similar in Log4j. For example, 

private static final Logger LOG = 

LoggerFactory.getLogger(Wombat.class); 

• In Logger [2] , the logging methods are overloaded with forms that accept one, two or more values. Occurrences of 

the simple pattern {} in the log message is replaced in turn with the values. This is simple to use yet provides a 

performance benefit when the values have expensive toString() methods. When logging is disabled at the 

DEBUG level, the logging framework does not need to evaluate the string representation of the values. In the 

following example, the values count or userAccountList only need to be evaluated when DEBUG is 

enabled; otherwise the overhead of the debug call is trivial. 

LOG.debug("There are now " + count + " user accounts: " + 

userAccountList); // slow 

LOG.debug("There are now {} user accounts: {}", count, 

userAccountList); // faster 

• Similar methods exist in Logger [2] for isDebugEnabled() etc to allow more complex logging calls to be 

wrapped so that they are disabled when the corresponding level is disabled, avoiding unnecessary processing.

SLF4J 276 

• Unlike Log4j, SLF4J offers logging methods that accept markers. These are special objects that enrich the log 

messages and are an idea that SLF4J has borrowed from logback. 

See also 

• log4j 

• Java Logging Frameworks 


• Official slf4j Homepage [3] 

References 

[1] http:/ / java. sun. com/ javase/ 6/ docs/ api/ java/ util/ logging/ package-summary. html 

[2] http:/ / slf4j. org/ apidocs/ org/ slf4j/ Logger. html 

[3] http:/ / slf4j. org/

Bruno Souza 277 

Bruno Souza 

Born 

Nationality Brazilian 

Bruno Souza 

Bruno Peres Ferreira de Souza [1] 

Known for Self-promotion 

Website 

www.javaman.com.br [2] 

Bruno Souza is the President of SOUJava [3] , a Brazilian Java User Group. He promotes himself as the 

"JavaMan" [1] 

Javali, a project owned by SOUJava, is focused in increasing Java usage in Brazil [4] . This project has the support 

from ITI [5] [6] [7] . 

From 2007 [8] to 2009 [9] , Bruno was on the Board of Directors at the Open Source Initiative, where he currently 

holds an Emeritus status. [9] 


• Bruno Souza´s homepage [10] and weblog [11] 

• Bruno Souza´s Interview in Netbeans.tv [12] 

References 

[1] Souza, Bruno. "Site do JavaMan" (http:/ / www. javaman. com. br/ ) (in Portuguese). Bruno's own homepage. . Retrieved 2009-01-13. 

[2] http:/ / www. javaman. com. br 

[3] "Organização - SOUJava" (http:/ / www. soujava. org. br/ pages/ viewpage. action?pageId=1835023) (in Portuguese). SOUJava. . Retrieved 

2009-01-13. 

[4] "Javali" (https:/ / javali. dev. java. net/ ). . Retrieved 2008-10-19. 

[5] Instituto Nacional de Tecnologia da Informação (2004-07-01). "ITI apóia projeto Javali" (http:/ / www. iti. gov. br/ twiki/ bin/ view/ Noticias/ 

PressRelease2004Jul01A) (in Portuguese). Press release. . Retrieved 2009-01-13. 

[6] Instituto Nacional de Tecnologia da Informação (2006-05-24). "Governo Federal recebe apoio de empresa na adoção de Software Livre" 

(http:/ / www. iti. gov. br/ twiki/ bin/ view/ Noticias/ PressRelease2006May24A) (in Portuguese). Press release. . Retrieved 2009-01-13. 

[7] "Apresentação" (http:/ / www. iti. gov. br/ twiki/ bin/ view/ ITI/ Apresentacao) (in Portuguese). Instituto Nacional de Tecnologia da 

Informação. . Retrieved 2009-01-13. 

[8] "OSI Board of Directors" (http:/ / www. opensource. org/ docs/ board-annotated#BrunoDeSouza). . Retrieved 2008-10-19. 

[9] OSI (http:/ / www. opensource. org) (2009-05-11). "2009 OSI Board Elections held in April" (http:/ / www. opensource. org/ node/ 431). 

Press release. . 

[10] http:/ / www. javaman. com. br/ 

[11] http:/ / today. java. net/ pub/ au/ 88 

[12] http:/ / www. netbeans. tv/ interviews/ Bruno-Souza-215/


Static import 

Static import is a feature introduced in the Java programming language that allows members (fields and methods) 

defined in a class as public static to be used in Java code without specifying the class in which the field is defined. 

This feature was introduced into the language in version 5.0. 

The feature provides a typesafe mechanism to include constants into code without having to reference the class that 

originally defined the field. It also helps to deprecate the practice of creating a constant interface: an interface that 

only defines constants then writing a class implementing that interface, which is considered an inappropriate use of 

interfaces [1] . 

The mechanism can be used to reference individual members of a class: 

import static java.lang.Math.PI; 

import static java.lang.Math.pow; 

or all the static members of a class: 

import static java.lang.Math.*; 

For example, this class: 



cm, it has:"); 

"cm"); 

System.out.println("Hello World!"); 

System.out.println("Considering a circle with a diameter of 5 

System.out.println("A circumference of " + (Math.PI * 5) + 

System.out.println("And an area of " + (Math.PI * 

Math.pow(5,2)) + "sq. cm"); 

} 

} 

Can be shortened to: 

import static java.lang.Math.*; 

import static java.lang.System.out; 


has:"); 

} 


} 

out.println("Hello World!"); 

out.println("Considering a circle with a diameter of 5 cm, it 

out.println("A circumference of " + (PI * 5) + "cm"); 

out.println("And an area of " + (PI * pow(5,2)) + "sq. cm");


References 

[1] Java Practices (http:/ / www. javapractices. com/ topic/ TopicAction. do;jsessionid=8DE0FD351E0CF7378452E4E1001FCDDA?Id=32) 

StormMQ 

Developer(s) StormMQ Limited 

Stable release 2010.05.20.1859.RC / May 20, 2010 


Operating 

system 


Type AMQP, Message Queuing Service, message oriented middleware 

License Client downloads Mozilla Public License 

Website 

StormMQ.com [1] 

In computing, StormMQ is a Message Queuing Service (a form of message-oriented middleware that provides a 

message broker), using the standard Advanced Message Queuing Protocol (AMQP). StormMQ is the first Hosted, 

On-Premise or Cloud solution for Machine-to-Machine Message Queuing using AMQP. StormMQ Limited provides 

an open, secure platform and the necessary legal protections for data moved through the cloud. The platform 

interoperates with clients from RabbitMQ and Apache Qpid, with additional clients developed by StormMQ with 

third parties available as open source with code released under the Mozilla Public License. 

See also 

• Advanced Message Queuing Protocol 

• Message Queuing Service 

• message oriented middleware 

References 

[1] http:/ / stormmq. com/ 

• Ross Cooney (2010-03-20). "StormMQ at CloudStorm" (http:/ / www. spoutingshite. com/ 2010/ 03/ 20/ 

cloudstorm-london/ ). SpoutingShite. 

• Tony Byrne (2010-05-01). "StormMQ-Ruby-Client" (http:/ / github. com/ tonybyrne/ StormMQ-Ruby-Client/ 

tree/ l). GitHub. 


• StormMQ web site (http:/ / stormmq. com/ ) 

• StormMQ touts data-protection compliance for secure messaging service in the cloud (http:/ / www. the451group. 

com/ report_view/ report_view. php?entity_id=62762)

strictfp 280 

strictfp 

strictfp is a keyword in the Java programming language that restricts floating-point calculations to ensure 

portability. It was introduced into Java with the Java virtual machine (JVM) version 1.2. 

Basis 

The IEEE standard, IEEE 754, specifies a standard method for both floating-point calculations and storage of 

floating-point values in either single (32-bit, used in Java floats) or double (64-bit, used in Java doubles) precision. 

Prior to JVM 1.2, floating-point calculations were strict; that is, all intermediate floating-point results were 

represented as IEEE single or double precisions. As a consequence, errors of calculation, overflows and underflows, 

could occur. Whether or not an error had occurred, the calculation would always return a valid number; if an 

overflow or underflow had occurred, that number would be incorrect. Hence, whether an error had occurred was 

typically not obvious. Since JVM 1.2, intermediate computations are not limited to the standard 32- and 64- bit 

precisions. On platforms that can handle other representations, those representations can be used, preventing 

overflows and underflows, thereby increasing precision. For some applications, a programmer might need every 

platform to have precisely the same floating-point behavior, even on platforms that could handle greater precision. 

The strictfp modifier accomplishes this by truncating all intermediate values to IEEE single- and double- precision, 

as occurred in earlier versions of the JVM [1] . 

Usage 

Programmers can use the modifier strictfp to ensure that calculations are performed as in the earlier versions; that is, 

only with IEEE single and double precision types used. Using strictfp guarantees that results of floating-point 

calculations are identical on all platforms. This can be extremely useful when comparing floating-point numbers. 

It can be used on classes, interfaces and non-abstract methods. [2] When applied to a method, it causes all calculations 

inside the method to use strict floating-point math. When applied to a class, all calculations inside the class use strict 

floating-point math. Compile-time constant expressions must always use strict floating-point behavior 

Examples 

public strictfp class MyFPclass { 

} 

// ... contents of class here ... 

The Java package java.lang.Math class contains these strictfp methods: 

public static strictfp double abs(double); 

public static strictfp int max(int, int); 

public static strictfp long max(long, long); 

public static strictfp float max(float, float); 

public static strictfp double max(double, double); 

public static strictfp int min(int, int);

strictfp 281 

Behaviors and restrictions 

Strictfp is sometimes viewed as a problem of Java [3] [4] . 

References 

• http:/ / java. sun. com/ docs/ books/ vmspec/ 2nd-edition/ html/ Concepts. doc. html#24465 

[1] Flanagan, David (March 2005). Java in a Nutshell (http:/ / oreilly. com/ catalog/ 9780596007737) (Fifth ed.). O'Reilly Media. 

ISBN 978-0-596-00773-7. . Retrieved 2010-03-03. 

[2] Schildt, Herbert (2007). Java: A Beginner's Guide (4 ed.). McGraw-Hill Companies. ISBN 978-0-07-226384-8. 

[3] Kahan, W.; Joseph D. Darcy (1998-03-01). "How Java's Floating-Point Hurts Everyone Everywhere" (http:/ / www. cs. berkeley. edu/ 

~wkahan/ JAVAhurt. pdf) (PDF). . Retrieved 2006-12-09. 

[4] "Types, Values, and Variables" (http:/ / java. sun. com/ docs/ books/ jls/ third_edition/ html/ typesValues. html#4. 2. 3). Sun Microsystems. . 


String Buffer 

In object-oriented programming, a String Buffer is an alternative to a String. It has the ability to be altered through 

adding or appending, whereas a String is normally fixed or unchangeable. 

In Java 

Theory 

Java's standard way to handle text is to use its String class. Any given String in Java is an immutable object, which 

means its state cannot be changed. A String has an array of characters. Whenever a String must be manipulated, any 

changes require the creation of a new String (which, turn, involves the creation of a new array of characters, and 

copying of the original array). This happens even if the original String's value or intermediate Strings used for the 

manipulation are not kept. 

Java provides an alternate class for string manipulation, called a StringBuffer [1] . A StringBuffer, like a String, has 

an array to hold characters. It, however, is mutable (its state can be altered). Its array of characters is not necessarily 

completely filled (as oppose to a String, whose array is always the exact required length for its contents). Thus, it has 

the capability to add, remove, or change its state without creating a new object (and without the creation of a new 

array, and array copying). The exception to this is when its array is no longer of suitable length to hold its content. In 

this case, it is required to create a new array, and copy contents. 

For these reasons, Java would handle an expression like 

String newString = aString + anInt + aChar + aDouble; 

like this: 

String newString = (new StringBuffer(aString)).append(anInt).append(aChar).append(aDouble)).toString(); 

Implications 

Generally, a StringBuffer is more efficient than a String in string handling. However, this is not necessarily the case, 

since a StringBuffer will be required to recreate its character array when it runs out of space. Theoretically, this is 

possible to happen the same number of times as a new String would be required, although this is unlikely (and the 

programmer can provide length hints to prevent this). Either way, the effect is not noticeable in modern desktop 

computers.

String Buffer 282 

As well, the shortcomings of arrays are inherent in a StringBuffer. In order to insert or remove characters are 

arbitrary positions, whole sections of arrays must be moved. 

The method by which a StringBuffer is attractive in an environment with low processing power takes this ability by 

using too much memory, which is likely also at a premium in this environment. This point, however, is trivial, 

considering the space required for creating many instances of Strings in order to process them. As well, the 

StringBuffer can be optimized to "waste" as little memory as possible. 

The StringBuilder class, introduced in J2SE 5.0, differs from StringBuffer in that it is unsynchronized. When only a 

single thread at a time will access the object, using a StringBuilder is more efficient than using a StringBuffer. 

StringBuffer and StringBuilder are included in the java.lang package. 

In .NET 

Microsoft's .NET Framework has a StringBuilder class in its Base Class Library. 

See also 

• Analysis of algorithms 

Links 

• The JavaDocs of StringBuffer [1] , StringBuilder [2] and String [3] , as well as the article StringBuffer and 

StringBuilder. 

• The source code of these classes [4] 

• Urban Performance Legends [5] - An article which involves a discussion of immutable objects with respect to 

object-oriented design 

References 

[1] http:/ / java. sun. com/ j2se/ 1. 5. 0/ docs/ api/ java/ lang/ StringBuffer. html 

[2] http:/ / java. sun. com/ j2se/ 1. 5. 0/ docs/ api/ java/ lang/ StringBuilder. html 

[3] http:/ / java. sun. com/ j2se/ 1. 5. 0/ docs/ api/ java/ lang/ String. html 

[4] http:/ / www. java2s. com/ Code/ JavaAPI/ java. lang/ StringBuffer. htm 

[5] http:/ / www-128. ibm. com/ developerworks/ java/ library/ j-jtp04223. html?ca=dgr-lnxw01JavaUrbanLegends


Sun Web Developer Pack 

The Sun Web Developer Pack (SWDP) is a collection of open source software released by Sun Microsystems for 

developing web applications that run on Java EE application servers. The SWDP is targeted at software developers 

interested in writing web applications that use Web 2.0 technologies such as Ajax, REST, Atom, and JavaScript. 

Software Included in the SWDP 

The SWDP consists of the following software: 

• Scripting language support 

• Project Phobos, a project that allows you to write web applications in JavaScript or other scripting languages 

• Ajax technologies 

• Project jMaki, a framework for creating Ajax-enabled web applications in Java, PHP, or Phobos 

• Project Dynamic Faces, a framework for creating Ajax-enabled JavaServer Faces applications 

• REST 

• RESTful web services, an API for creating REST web services in Java 

• WADL 

• ROME, a Java API for parsing and generating RSS and Atom web feeds 

• Atom Server (The ROME Propono subproject), a prototype Java API and framework for creating a web feed 

server for Atom feeds 

Release history 

Release 1 of the SWDP was made public on March 12, 2007. 


• Sun Web Developer Pack home page [1] 

• Documentation 

• Online SWDP Tutorial [2] 

• SWDP Tutorial bundle download [3] 

• Getting Started with the SWDP [4] 

• java.net project pages 

• Project jMaki [5] 

• Project Dynamic Faces [6] 

• Project Phobos [7] 

• WADL [8] 

• ROME API [9]


References 

[1] http:/ / developers. sun. com/ web/ swdp/ index. jsp 

[2] http:/ / developers. sun. com/ web/ swdp/ docs/ tutorial/ doc/ toc. html 

[3] http:/ / developers. sun. com/ web/ swdp/ docs/ tutorial/ download. html 

[4] http:/ / developers. sun. com/ web/ swdp/ docs/ GettingStarted. html 

[5] https:/ / ajax. dev. java. net 

[6] https:/ / jsf-extensions. dev. java. net 

[7] https:/ / phobos. dev. java. net 

[8] https:/ / wadl. dev. java. net 

[9] https:/ / rome. dev. java. net 

Swing (Java) 

Swing is a widget toolkit for Java. It is part 

of Sun Microsystems' Java Foundation 

Classes (JFC) — an API for providing a 

graphical user interface (GUI) for Java 

programs. 

Swing was developed to provide a more 

sophisticated set of GUI components than 

the earlier Abstract Window Toolkit. Swing 

provides a native look and feel that emulates 

the look and feel of several platforms, and 

also supports a pluggable look and feel that 

allows applications to have a look and feel 

unrelated to the underlying platform. 

History 

The Internet Foundation Classes (IFC) were 

Example Swing widgets in Java 5 for the X Window System 

a graphics library for Java originally developed by Netscape Communications Corporation and first released on 

December 16, 1996. On April 2, 1997, Sun Microsystems and Netscape Communications Corporation announced 

their intention to incorporate IFC with other technologies to form the Java Foundation Classes. 

Swing introduced a mechanism that allowed the look and feel of every component in an application to be altered 

without making substantial changes to the application code. The introduction of support for a pluggable look and feel 

allows Swing components to emulate the appearance of native components while still retaining the benefits of 

platform independence. This feature also makes it easy to make an application written in Swing look very different 

from native programs if desired. 

Originally distributed as a separately downloadable library, Swing has been included as part of the Java Standard 

Edition since release 1.2. The Swing classes and components are contained in the javax.swing package hierarchy.


The Swing Architecture 

Swing is a platform-independent, Model-View-Controller GUI framework for Java. It follows a single-threaded 

programming model, and possesses the following traits: 

Foundations 

Swing is platform independent both in terms of expression (Java) and implementation (Look-and-Feel). 

Extensible 

Swing is a highly partitioned architecture, which allows for the "plugging" of various custom implementations of 

specified framework interfaces: Users can provide their own custom implementation(s) of these components to 

override the default implementations. In general, Swing users can extend the framework by extending existing 

(framework) classes and/or providing alternative implementations of core components. 

Swing is a component-based framework. The distinction between objects and components is a fairly subtle point: 

concisely, a component is a well-behaved object with a known/specified characteristic pattern of behaviour. Swing 

objects asynchronously fire events, have "bound" properties, and respond to a well-known set of commands (specific 

to the component.) Specifically, Swing components are Java Beans components, compliant with the Java Beans 

Component Architecture specifications. 

Customizable 

Given the programmatic rendering model of the Swing framework, fine control over the details of rendering of a 

component is possible in Swing. As a general pattern, the visual representation of a Swing component is a 

composition of a standard set of elements, such as a "border", "inset", decorations, etc. Typically, users will 

programmaticaly customize a standard Swing component (such as a JTable) by assigning specific Borders, Colors, 

Backgrounds, opacities, etc., as the properties of that component. The core component will then use these properties 

(settings) to determine the appropriate renderers to use in painting its various aspects. However, it is also completely 

possible to create unique GUI controls with highly customized visual representation. 

Configurable 

Swing's heavy reliance on runtime mechanisms and indirect composition patterns allows it to respond at runtime to 

fundamental changes in its settings. For example, a Swing-based application can change its look and feel at runtime. 

Further, users can provide their own look and feel implementation, which allows for uniform changes in the look and 

feel of existing Swing applications without any programmatic change to the application code. 

Lightweight UI 

Swing's configurability is a result of a choice not to use the native host OS's GUI controls for displaying itself. 

Swing "paints" its controls programmatically through the use of Java 2D APIs, rather than calling into a native user 

interface toolkit. Thus, a Swing component does not have a corresponding native OS GUI component, and is free to 

render itself in any way that is possible with the underlying graphics APIs. 

However, at its core every Swing component relies on an AWT container, since (Swing's) JComponent extends 

(AWT's) Container. This allows Swing to plug into the host OS's GUI management framework, including the crucial 

device/screen mappings and user interactions, such as key presses or mouse movements. Swing simply "transposes" 

its own (OS agnostic) semantics over the underlying (OS specific) components. So, for example, every Swing 

component paints its rendition on the graphic device in response to a call to component.paint(), which is defined in 

(AWT) Container. But unlike AWT components, which delegated the painting to their OS-native "heavyweight" 

widget, Swing components are responsible for their own rendering. 

This transposition and decoupling is not merely visual, and extends to Swing's management and application of its 

own OS-independent semantics for events fired within its component containment hierarchies. Generally speaking,


the Swing Architecture delegates the task of mapping the various flavors of OS GUI semantics onto a simple, but 

generalized, pattern to the AWT container. Building on that generalized platform, it establishes its own rich and 

complex GUI semantics in the form of the JComponent model. 

Loosely-Coupled and MVC 

The Swing library makes heavy use of the Model/View/Controller software design pattern [1] , which conceptually 

decouples the data being viewed from the user interface controls through which it is viewed. Because of this, most 

Swing components have associated models (which are specified in terms of Java interfaces), and the programmer can 

use various default implementations or provide their own. The framework provides default implementations of 

model interfaces for all of its concrete components. The typical use of the Swing framework does not require the 

creation of custom models, as the framework provides a set of default implementations that are transparently, by 

default, associated with the corresponding JComponent child class in the Swing library. In general, only complex 

components, such as tables, trees and sometimes lists, may require the custom model implementations around the 

application-specific data structures. To get a good sense of the potential that the Swing architecture makes possible, 

consider the hypothetical situation where custom models for tables and lists are wrappers over DAO and/or EJB 

services. 

Typically, Swing component model objects are responsible for providing a concise interface defining events fired, 

and accessible properties for the (conceptual) data model for use by the associated JComponent. Given that the 

overall MVC pattern is a loosely-coupled collaborative object relationship pattern, the model provides the 

programmatic means for attaching event listeners to the data model object. Typically, these events are model centric 

(ex: a "row inserted" event in a table model) and are mapped by the JComponent specialization into a meaningful 

event for the GUI component. 

For example, the JTable has a model called TableModel that describes an interface for how a table would access 

tabular data. A default implementation of this operates on a two-dimensional array. 

The view component of a Swing JComponent is the object used to graphically "represent" the conceptual GUI 

control. A distinction of Swing, as a GUI framework, is in its reliance on programmatically-rendered GUI controls 

(as opposed to the use of the native host OS's GUI controls). Prior to Java 6 Update 10, this distinction was a source 

of complications when mixing AWT controls, which use native controls, with Swing controls in a GUI (see Mixing 

AWT and Swing components). 

Finally, in terms of visual composition and management, Swing favors relative layouts (which specify the positional 

relationships between components) as opposed to absolute layouts (which specify the exact location and size of 

components). This bias towards "fluid"' visual ordering is due to its origins in the applet operating environment that 

framed the design and development of the original Java GUI toolkit. (Conceptually, this view of the layout 

management is quite similar to that which informs the rendering of HTML content in browsers, and addresses the 

same set of concerns that motivated the former.)


Relationship to AWT 

Since early versions of Java, a portion of the Abstract Window Toolkit 

(AWT) has provided platform-independent APIs for user interface 

components. In AWT, each component is rendered and controlled by a 

native peer component specific to the underlying windowing system. 

By contrast, Swing components are often described as lightweight 

because they do not require allocation of native resources in the 

operating system's windowing toolkit. The AWT components are 

referred to as heavyweight components. 

Much of the Swing API is generally a complementary extension of the 

AWT rather than a direct replacement. In fact, every Swing lightweight 

interface ultimately exists within an AWT heavyweight component 

because all of the top-level components in Swing (JApplet, JDialog, 

JFrame, and JWindow) extend an AWT top-level container. Prior to 

Java 6 Update 10, the use of both lightweight and heavyweight 

AWT and Swing class hierarchy 

components within the same window was generally discouraged due to Z-order incompatibilities. However, later 

version of Java have fixed these issues, and both Swing and AWT components can now be used in one GUI without 

Z-order issues. 

The core rendering functionality used by Swing to draw its lightweight components is provided by Java 2D, another 

part of JFC. 

Relationship to SWT 

The Standard Widget Toolkit (SWT) is a competing toolkit originally developed by IBM and now maintained by the 

Eclipse community. SWT's implementation has more in common with the heavyweight components of AWT. This 

confers benefits such as more accurate fidelity with the underlying native windowing toolkit, at the cost of an 

increased exposure to the native platform in the programming model. 

The advent of SWT has given rise to a great deal of division among Java desktop developers, with many strongly 

favoring either SWT or Swing. Sun's development on Swing continues to focus on platform look and feel (PLAF) 

fidelity with each platform's windowing toolkit in the approaching Java SE 7 release (as of December 2006). 

There has been significant debate and speculation about the performance of SWT versus Swing; some hinted that 

SWT's heavy dependence on JNI would make it slower when the GUI component and Java need to communicate 

data, but faster at rendering when the data model has been loaded into the GUI, but this has not been confirmed 

either way [2] . A fairly thorough set of benchmarks concluded that neither Swing nor SWT clearly outperformed the 

other in the general case [3] . 

SWT serves the Windows platform very well but is considered by some to be less effective as a technology for 

cross-platform development. By using the high-level features of each native windowing toolkit, SWT returns to the 

issues seen in the mid 90's (with toolkits like zApp, Zinc, XVT and IBM/Smalltalk) where toolkits attempted to 

mask differences in focus behaviour, event triggering and graphical layout. Failure to match behavior on each 

platform can cause subtle but difficult-to-resolve bugs that impact user interaction and the appearance of the GUI.


Examples 

A basic example 

The following is a rather simple Swing-based program. It displays a window (a JFrame) containing a label and a 

button. 

Notice how all instantiation and handling of all Swing components are done on the Event Dispatch Thread by use of 

the method EventQueue.invokeLater(Runnable)) and an anonymous Runnable class (see Swing and thread safety). 

// Import the swing and AWT classes needed 

import java.awt.EventQueue; 

import java.awt.FlowLayout; 

import javax.swing.JButton; 

import javax.swing.JFrame; 

import javax.swing.JLabel; 

/** 

* Basic Swing example. 

*/ 

public class SwingExample { 


on the 

// Make sure all Swing/AWT instantiations and accesses are done 

// Event Dispatch Thread (EDT) 

EventQueue.invokeLater(new Runnable() { 

@Override 

"decorations", i.e. 

contained 

else the 

public void run() { 

// Create a JFrame, which is a Window with 

// title, border and close-button 

JFrame f = new JFrame("Swing Example Window"); 

// Set a simple Layout Manager that arranges the 

// Components 

f.setLayout(new FlowLayout()); 

// Add some Components 

f.add(new JLabel("Hello, world!")); 

f.add(new JButton("Press me!")); 

// "Pack" the window, making it "just big enough". 

f.pack(); 

// Set the default close operation for the window, or


} 

window 

} 

See also 

}); 

} 

• Abstract Window Toolkit 

• Layout manager 

// program won't exit when clicking close button 

// (The default is HIDE_ON_CLOSE, which just makes the 

// invisible, and thus doesn't exit the app) 

f.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); 

// Set the visibility as true, thereby displaying it 

f.setVisible(true); 

• SwingLabs - Extensions to Swing that might be included in Swing in the future 

• Standard Widget Toolkit A third party competing widget toolkit resembling the Abstract Window Toolkit in 

function. 

References 

• Matthew Robinson, Pavel Vorobiev: Swing, Second Edition, Manning, ISBN 1-930110-88-X 

• David M. Geary: Graphic Java 2, Volume 2: Swing, Prentice Hall, ISBN 0-13-079667-0 

• John Zukowski: The Definitive Guide to Java Swing, Third Edition, Apress, ISBN 1-590-59447-9 

• James Elliott, Robert Eckstein, Marc Loy, David Wood, Brian Cole: Java Swing, O'Reilly, ISBN 0-596-00408-7 

• Kathy Walrath, Mary Campione, Alison Huml, Sharon Zakhour: The JFC Swing Tutorial: A Guide to 

Constructing GUIs, Addison-Wesley Professional, ISBN 0-201-91467-0 

• Joshua Marinacci, Chris Adamson: Swing Hacks, O'Reilly, ISBN 0-596-00907-0 


• The Swing API documentation [7] 

• The Swing architecture [4] 

References 

[1] Swing as MVC (http:/ / java. sun. com/ products/ jfc/ tsc/ articles/ architecture/ ) 

[2] Swing vs. SWT Performance - Have a Look at the Call Stacks (http:/ / www. javalobby. org/ java/ forums/ t65168. html) 

[3] Igor, Križnar (2005-05-10). "SWT Vs. Swing Performance Comparison" (http:/ / cosylib. cosylab. com/ pub/ CSS/ DOC-SWT_Vs. 

_Swing_Performance_Comparison. pdf). cosylab.com. . Retrieved 2008-05-24. "It is hard to give a rule-of-thumb where SWT would 

outperform Swing, or vice versa. In some environments (e.g., Windows), SWT is a winner. In others (Linux, VMware hosting Windows), Swing 

and its redraw optimization outperform SWT significantly. Differences in performance are significant: factors of 2 and more are common, in 

either direction." 

[4] http:/ / java. sun. com/ products/ jfc/ tsc/ articles/ architecture/

SwingLabs 290 

SwingLabs 

Developer(s) Sun 

Operating 

system 


Type Widget library 

License LGPL 

Website 

swinglabs.dev.java.net [1] 

swingLabs is a Sun Open source project proposing extensions to the Java Swing GUI toolkit. Available components 

include: 

• Sorting, filtering, highlighting for tables, trees, and lists 

• Find/search 

• Auto-completion 

• Login/authentication framework 

• TreeTable component 

• Collapsible panel component 

• Date picker component 

• Tip-of-the-Day component 

The aim of the project is to experiment new or enhanced GUI functionalities that are required by Rich client 

applications. It acts as a testbed for ideas related to client side technologies. 

Integration into Java API 

Successful project components are eventually incorporated into the core Swing toolkit for future Java versions, 

although API compatibility is not guaranteed. Examples of these are: 

• the GroupLayout manager in Java SE 6 [2] . 

• incorporation of the SystemTray in Java SE 6. 

• the new Desktop class in Java SE 6, which allows to launch easily associated applications registered on the native 

desktop, as for example : launching the user-default browser, launching the user-default mail client, launching a 

registered application to open, edit or print a specified file. 

License 

The project is distributed under a LGPL license. 

Sub-projects 

The swingLabs project [1] is divided into several sub-projects. For example : 

• swingX [3] : provides extensions to the Java Swing GUI toolkit. 

• JDIC [4] : as for JDesktop Integration Components, a project aims to make Java applications first-class citizens of 

current desktop platforms without sacrificing platform independence. Its mission is to enable seamless 

desktop/Java integration. 

• nimbus [5] : a Look and feel using synth, the Java skinnable look and feel. 

• swingLayout [6] : the home of the GroupLayout manager, before inclusion in Java SE 6.

SwingLabs 291 

• JDNC [7] : Contained components that allow to build easily Swing-based rich-client Java applications. The project 

is no more actively maintained. It has been replaced by Swing Application Framework (JSR 296) 

• scenegraph [8] : A library that provide 2D Scene graph functionality to Java 2D, including Swing widgets. This 

library is used internally by the JavaFX Script language. 

• PDFRenderer [9] : A 100% pure Java PDF viewer library. 

See also 

• Swing (Java) 

• Swing Application Framework 

• SwingWorker 


• swingLabs project home page [1] 

• swingx project home page [3] 

• swingx project tutorials and documents [10] 

• swingx 0.7 version javadoc [11] 

References 

[1] https:/ / swinglabs. dev. java. net/ 

[2] GroupLayout was initially developed in conjunction with Matisse, the GUI builder of NetBeans. 

[3] https:/ / swingx. dev. java. net/ 

[4] https:/ / jdic. dev. java. net/ 

[5] https:/ / nimbus. dev. java. net/ 

[6] https:/ / swing-layout. dev. java. net/ 

[7] https:/ / jdnc. dev. java. net/ 

[8] https:/ / scenegraph. dev. java. net/ 

[9] https:/ / pdf-renderer. dev. java. net/ 

[10] http:/ / swinglabs. org/ docs. jsp 

[11] http:/ / www. javadesktop. org/ swinglabs/ build/ weekly/ latest/ swingx-HEAD/ javadoc/ index. html


Synth Look and Feel 

synth is a skinnable Java look and feel, which is configured with an XML property file. 

According to Sun, goals for synth were: 

• Enable to create custom look without writing any code. 

• Allow appearance to be configured from images. 

• Provide the ability to customize the look of a component based on its named properties. 

• Provide a centralized point for overriding the look of all components. 

• Enable custom rendering based on images, or user-defined SynthPainters. 

History 

synth is available beginning with version J2SE 5.0 of Java (see Java version history). 

Java SE 6 Update 10 release and newer contain Nimbus, a cross-platform Look and Feel implemented with Synth. 

However, for backwards compatibility, Metal is still the default Swing look and feel. [1] 

Architecture 

Synth is a skinnable look and feel in which all painting is delegated to the components, without having to write any 

code (see Synth Look and Feel). 

However synth does not provide a default look, and components that are not defined in the synth XML file will not 

be painted. It is however possible to assign a default style to all other widgets, and customize styles for some specific 

widgets only. 

Example 

The following XML declaration defines a style named textfield and binds it to all text fields. The defaultStyle allows 

to set a default font, foreground and background colors to all other widgets. 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 


Supposing that the XML declaration is defined in a file named synthExample.xml, the following code loads the XML 

definition file and sets the current look and feel to synth (loading a synth Look and Feel is done using the load 

method of the SynthLookAndFeel class): 

SynthLookAndFeel laf = new SynthLookAndFeel(); 

laf.load(new File("synthExample.xml").toURL()); 

UIManager.setLookAndFeel(laf); 

See also 

• Swing, the standard cross-platform widget toolkit for Java 

• Pluggable look and feel 

• Look and Feel in Widget Toolkits 


• Synth Look and Feel API documentation 

• synth file format [2] 

• synth tutorial [3] 

• another synth tutorial [4] 

• nimbus home page [5] 

• Synthetica - commercial Synth Look and Feel with many different themes [8] 

• EaSynth Look And Feel Designer - commercial IDE for Synth based look and feel [5] 

References 

[1] "Nimbus Look and Feel (The Java Tutorials > Creating a GUI With JFC/Swing > Modifying the Look and Feel)" (http:/ / java. sun. com/ 

docs/ books/ tutorial/ uiswing/ lookandfeel/ nimbus. html). Sun Microsystems. . Retrieved 2010-07-01. 

[2] http:/ / java. sun. com/ j2se/ 1. 5. 0/ docs/ api/ javax/ swing/ plaf/ synth/ doc-files/ synthFileFormat. html 

[3] http:/ / javadesktop. org/ articles/ synth/ 

[4] http:/ / www. ibm. com/ developerworks/ java/ library/ j-synth/ 

[5] http:/ / www. easynth. com/ products/ EaSynthLookAndFeelDesigner. html


TeachScheme! 

The TeachScheme! project is an outreach effort of the PLT research group. The goal is to train college faculty, high 

school teachers and possibly even middle school teachers in programming and computing. 

History 

Matthias Felleisen and PLT started the effort in 1995 (January, one day after the POPL symposium) in response to 

observations of his Rice freshmen students and the algebra curriculum of local public schools. His objective was to 

use functional programming to bring mathematics alive and to help inject design knowledge into the introductory 

computer science curriculum. 

The group raised funds from several private foundations, the US Department of Education, and the National Science 

Foundation to create 

• software appropriate for novices in functional programming 

• courseware (curricula, lecture notes, exercises, mini-projects) 

• teacher training camps. 

Over ten years, it ran several dozen one-week workshops for some 550 teachers. In 2005, the TeachScheme! project 

ran an Anniversary workshop where two dozen teachers presented their work with students. 

In 2010, PLT renamed its major programming language Racket. The name for DrScheme, the IDE, was changed to 

DrRacket. 

Functional Programming, Computing and Algebra 

The starting point of TeachScheme! is the observation that students are computers in grade school courses on 

arithmetic and middle/high school courses on pre/algebra. Teachers program them with rules and run specific 

problems via exercises. The key is that students execute purely functional programs. 

If we can turn students into teachers that create functional programs and run them on computers, we can reinforce 

this content and show students how writing down mathematics and how writing down functional programs creates 

lively animated scenes and even computer games. 

Here is an example: 

(require 2htdp/universe) 

(require 2htdp/image) 

;; create an image from the current time 

(define (create-image t) 

(place-image APPLE 50 (* 1/10 t t) SPACE)) 

;; names for basic images 

(define APPLE (circle 3 "solid" "red")) 

(define SPACE (empty-scene 100 100)) 

(animate create-image) 

This short program simulates an apple falling from the top to the bottom of a small white canvas. It consists of three 

parts:


• a function definition for create-image, which is a one-line function in mathematics, assuming an algebra of 

images with place-image, circle, and empty-scene have been introduced; 

• two abbreviations, where names are equated with some value, just as in "let x be 5" in an algebra text; and 

• one line for running the program. 

A teacher can explain create-image as easily as any ordinary function in an algebra course. For example, one can 

first draw a table with two rows and n columns where each column contains t at the top and an appropriate image at 

the bottom. That is, if the numbers increase from left to right, then on each image the red dot is a little bit lower. 

Finally the animate line applies the given function, create-image, at the rate of 28 ticks per second to 0, 1, 2, 3, and 

so on. The resulting images are displayed on the computer monitor at the same pace. That's how movies are made. 

The background needed for such an example is little more than knowledge about making movies, about the algebra 

of pictures in DrRacket (which is like the one for numbers), and minimal pre-algebra. The TeachScheme! project 

claims, however, that children would have more fun with such "live" functions than with algebraic expressions that 

count the number of garden tiles [see Prentice Hall books for grades 8-9]. 

The TeachScheme! project proposes that both traditional mathematics as well as science courses could benefit from 

an integration of this form of programming. In contrast to the traditional Basic or Visual Basic blocks in such books, 

a Racket program consists of as many lines as the mathematics. Moving between the mathematics and the program is 

thus straightforward. Better still, the meaning of the two are the same. DrRacket's algebraic stepper can illustrate 

how Racket evaluates the program as if it were a sixth or seventh grade student, step by step, using plain algebra. 

Functional Programming, Computing and Design in Programming 101 

For the introductory curriculum on programming, the TeachScheme! project emphasizes that courses should focus 

on the role of systematic design. Even if students never program again, they should see how helpful a systematic 

approach to problem solving is. This should help them whether they become programmers or doctors or journalists 

or photographers. Thus, an introductory course in programming would not be perceived as a place where students 

learn about the syntax of the currently fashionable (and soon-to-be-obsolete) programming languages, but a place 

where they can learn something widely applicable. 

The key design element of the TeachScheme! curriculum is the design recipe. It has two dimensions: the process 

dimension and the data dimension. 

Along the process dimension students learn that there are six steps to designing a (simple) program, before they can 

run it and others can use it: 

• problem analysis with the goal of describing the classes of data that go into the program and come out; 

• the reformulation of the problem statement as a concise purpose statement; 

• the creation of examples that illustrate the purpose statement and that serve as criteria for success; 

• the organization of givens, also called a template or inventory; 

• coding; 

• and the creation of a test suite from examples to ensure the program works properly on small inputs. 

Note that, as in test-driven development, test cases are written before coding, as part of requirements analysis, rather 

than afterward as part of testing. 

Almost any human endeavour can benefit from clearly understanding the problem, defining criteria for success, 

analyzing the available resources/givens, developing a proposed solution, and checking it against the criteria, in that 

order. A journalist, for example, benefits from a similar process: figuring out the major concepts in a story; coining a 

headline; lining up examples and specific data; organizing the article about the story around the givens and how the 

story unfolded; writing; and fact checking. 

The data dimension can be summarized by the maxim the shape of the data determines the shape of the code and 

tests. For example, if the input or output data type has three variants, a test suite should have at least one test case


from each variant, and program code will probably contain a three-way conditional (whether explicit or hidden in a 

polymorphic dispatch). If the input or output data type has three fields, a test suite will have to specify values for 

those three fields, and program code will have to refer to those three fields. If the input or output data type has a 

simple base case and one or more self-referential variants, the test suite should include a base case and one or more 

non-base cases, and the program code will probably have a base case and one or more self-referential cases, 

isomorphic to the data type. The technique of recursion, rather than being scary and mysterious, is simply the 

application of already-learned techniques to a self-referential data type. 

Organizing the givens is the task of translating the descriptions of data into a program skeleton. Each form of 

description determines a specific form of program organization. The transformation is nearly mechanical and helps 

the students focus on the creative part of the task. 

How to Design Programs is the text book authored by the core of the TeachScheme! group. 

TeachScheme! and choice of programming language 

The name TeachScheme! appears to imply that this design recipe requires Scheme (now Racket) and is only 

teachable with DrRacket. Neither conclusion is true, however. The TeachScheme! members and their students have 

successfully applied the design recipe in Assembly, C, Java, ML, Python, and other programming languages, not to 

speak of poetry, geometry, and biology courses. 

To get started the TeachScheme! project has produced three essential elements: 

• a series of successively more powerful and permissive teaching languages, which are dialects of Racket, matched 

to the design recipe but with error reporting matched to the student's level (for example, many things that are legal 

in standard Racket, but which a beginning student doesn't need, are flagged as errors in the Beginning Student 

level); 

• a beginner-friendly, freely-downloadable, pedagogic programming environment, DrRacket, that enforces these 

language levels; 

• a curriculum, encoded mostly in the book HTDP and its (draft) successor HtDP 2nd Edition [1] 

Their choice of Racket reflects their belief that Racket is a good language for a small team with little funding (in 

comparison to Java) to validate their conjectures. The PLT group has always tried to ensure, however, that the ideas 

remain portable to other contexts. 

From TeachScheme! to ReachJava 

Over the past few years, the team has also created a second part of the curriculum. It demonstrates how the same 

design recipe ideas apply to a complex object-oriented programming language, such as Java. This phase of the 

curriculum applies the same design recipe to Java, initially in a functional paradigm, then introducing object-oriented 

concepts such as polymorphism and inheritance, and then introducing the imperative techniques that are idiomatic in 

mainstream Java. 

A part of the team has a grant from the National Science Foundation for conducting field tests in colleges and high 

schools. Professional-development workshops took place in the summer of 2007, 2008, 2009, and 2010. This part of 

the project is dubbed ReachJava; the accompanying book is tentatively titled "How to Design Classes."


TeachScheme! and Bootstrap 

Recently PLT at Northeastern University and Citizen Schools from Boston [2] have joint efforts to reach out to inner 

city students with after-school programs. Citizen Schools is a nation-wide organization that matches volunteers with 

after-school program sites and gets them started with scripted curricula. They have translated the TeachScheme! 

material into a sixth-grade curriculum and tested it with great success in Boston. [3] The effect on the mathematics 

courses of this program has encouraged Microsoft to fund a national scale-up effort, developing materials for 

training teachers and creating sites in Texas, California, and other volunteer cities. 


• TeachScheme! [4] 

• Racket [5] 

• How to Design Programs [6] 

• Bootstrap [7] 

References 

[1] http:/ / www. ccs. neu. edu/ home/ matthias/ HtDP2e/ 

[2] http:/ / www. citizenschools. org/ boston/ 

[3] http:/ / www. cs. brown. edu/ ~sk/ Publications/ Talks/ Moby-Bootstrap/ 

[4] http:/ / www. teach-scheme. org/ 

[5] http:/ / www. racket-lang. org/ 

[6] http:/ / www. htdp. org/ 

[7] http:/ / www. bootstrapworld. org/ 

The Java Posse 

The Java Posse is a podcast of news, 

discussion, and interviews about the 

Java programming language and 

associated Java technologies. The four 

regular contributors are Tor Norbye 

(Sun Microsystems), Carl Quinn 

(Google), Dick Wall (Google) and Joe 

Nuxoll (Apple Inc.). [1] By January 

2007, the estimated listenership was 

between 7- and 10,000 people. [2] 

The podcast was begun in September 

2005 and was a successor to an earlier 

short-lived Java podcast produced by 

Wall called "JavaCast", cohosted with 

Brandon Werner. [1] As of December 

2007, over 150 episodes of The Java 

(Left to right) Tor Norbye, Joe Nuxoll, Carl Quinn and Dick Wall recording Java Posse 

episode #96 in December 2006 

Posse have been recorded. The group has also organized the "Java Posse Roundup", an unconference held in Crested 

Butte, Colorado in 2007 and organized by Bruce Eckel. Sessions from the roundup have been published as episodes 

of the podcast. 

Quinn and Wall also co-host the Google developer podcast.

The Java Posse 298 


• The Java Posse web site [3] . 

References 

[1] Chris Adamson, "The Java Podcasters" (http:/ / www. onjava. com/ pub/ a/ onjava/ 2006/ 01/ 25/ java-podcasters. html), 25 January 2006 

[2] Chris Adamson, Editor's Daily Blog (http:/ / weblogs. java. net/ blog/ editors/ archives/ 2007/ 01/ hold_on. html), java.net, 25 January 2007 

[3] http:/ / javaposse. com/ 

Unified Expression Language 

The Java Unified Expression Language is a special purpose programming language mostly used in Java web 

applications for embedding expressions into web pages. The Java specification writers and expert groups of the Java 

web-tier technologies have worked on a unified expression language which is now part of the JSP 2.1 specification 

(JSR-245). While the expression language is part of the JSP specification, it does not depend on the JSP specification 

and therefore it is available for a variety of technologies. 

History 

The expression language started out as part of the JavaServer Pages Standard Tag Library (JSTL) and was originally 

called SPEL (Simplest Possible Expression Language). It offered a simple way to access data objects. Over the 

years, the expression language has evolved to include more advanced functionality and it was included in the JSP 2.0 

specification, because of the popularity and success in the community. 

During the development of JSP 2.0, the JavaServer Faces technology was released which also needed an expression 

language, but the expression language defined in the JSP 2.0 specification didn't satisfy all the needs for 

development with JSF technology. The most obvious limitation is that its expressions are evaluated immediately. 

And also, the JSF components need a way to invoke methods on server-side objects. A more powerful language was 

created with the following new features: 

• Deferred expressions, which are not immediately evaluated 

• Expressions that can set as well as get data 

• Method expressions, which can invoke methods 

The new expression language worked well for the purposes of JSF. But developers had problems when integrating 

the JSP EL with the JSF EL because of conflicts. Because of these incompatibilities, the unified expression language 

initiative was started to unify these expression languages. As of JSP 2.1, the expression languages of JSP 2.0 and JSF 

1.1 have been merged into a single unified expression language (EL 2.1). 

Features 

The new unified EL is a union of the JSP and JSF expression languages. In addition to the features already available 

in the JSP EL, the unified EL has the following features: 

• Deferred evaluation 

• Support for expressions that can set values and expressions that can invoke methods 

• A pluggable API for resolving expressions

Unified Expression Language 299 

Implementations 

JUEL is an open-source implementation of the Unified Expression Language. It is considered stable and feature 

complete and is licensed under the Apache License 2.0. JUEL is also suitable for use in non-JSP applications. 


• JSR 245: JavaServer Pages 2.1 [1] 

• Unified Expression Language [2] (article at Sun Developer Network (SDN) 

• Unified Expression Language for JSP and JSF [3] (article at java.net) 

• JUEL [4] is an implementation of the Unified Expression Language (EL), specified as part of the JSP 2.1 standard 

(JSR-245). 

References 


[2] http:/ / java. sun. com/ products/ jsp/ reference/ techart/ unifiedEL. html 

[3] http:/ / today. java. net/ pub/ a/ today/ 2006/ 03/ 07/ unified-jsp-jsf-expression-language. html 

[4] http:/ / juel. sourceforge. net 

Java Virtual Machine 

A Java Virtual Machine (JVM) enables a set of computer software programs and data structures to use a virtual 

machine model for the execution of other computer programs and scripts. The model used by a JVM accepts a form 

of computer intermediate language commonly referred to as Java bytecode. This language conceptually represents 

the instruction set of a stack-oriented, capability architecture. Sun has claimed there are over 4.5 billion 

JVM-enabled devices. [1] 

Overview 

A JVM can also be used to implement programming languages other than Java. For example, Ada source code can 

be compiled to Java bytecode, which may then be executed by a JVM. JVMs can also be released by other 

companies besides Sun (the developer of Java) — JVMs using the "Java" trademark may be developed by other 

companies as long as they adhere to the JVM specification published by Sun (and related contractual obligations). 

Java was conceived keeping in mind the concept of WORA ‘write once and run anywhere’. This is possible using the 

Java Virtual Machine. The JVM is the environment in which java programs execute. It is software that is 

implemented on top of real hardware and operating system. 

JVM is a crucial component of the Java Platform, and because JVMs are available for many hardware and software 

platforms, Java can be both middleware and a platform in its own right — hence the trademark write once, run 

anywhere. The use of the same bytecode for all platforms allows Java to be described as "compile once, run 

anywhere", as opposed to "write once, compile anywhere", which describes cross-platform compiled languages. A 

JVM also enables such features as Automated Exception Handling, which provides 'root-cause' debugging 

information for every software error (exception), independent of the source code. 

A JVM is distributed along with a set of standard class libraries that implement the Java API (Application 

Programming Interface). An API is provided by a computer system, library, or application in order to allow data 

exchange between them. APIs are bundled together as the Java Runtime Environment.

Java Virtual Machine 300 

Execution environment 

Programs intended to run on a JVM must be compiled into a standardized portable binary format, which typically 

comes in the form of .class files. A program may consist of many classes in different files. For easier distribution of 

large programs, multiple class files may be packaged together in a .jar file (short for Java archive). 

The JVM runtime executes .class or .jar files, emulating the JVM instruction set by interpreting it, or using a 

just-in-time compiler (JIT) such as Sun's HotSpot. JIT compiling, not interpreting, is used in most JVMs today to 

achieve greater speed. Ahead-of-time compilers that enable the developer to precompile class files into native code 

for a particular platforms also exist. 

Like most virtual machines, the Java Virtual Machine has a stack-based architecture akin to a 

microcontroller/microprocessor. However, the JVM also has low-level support for Java-like classes and methods, 

which amounts to a highly idiosyncratic memory model and capability-based architecture. 

The JVM, which is the instance of the 'JRE' (Java Runtime Environment), comes into action when a Java program is 

executed. When execution is complete, this instance is garbage collected. JIT is the part of the JVM that is used to 

speed up the execution time. JIT compiles parts of the byte code that have similar functionality at the same time, and 

hence reduces the amount of time needed for compilation. 

JVM languages 

Versions of non-JVM languages 

Language On JVM 

Erlang Erjang 

JavaScript Rhino 

PHP Quercus 

Python Jython 

REXX 

NetRexx [2] 

Ruby JRuby 

Tcl Jacl 

Languages designed expressly for JVM 

MIDletPascal 

Clojure 

Groovy 

Scala 

Although the JVM was primarily aimed at running compiled Java programs, many other languages can now run on 

top of it [3] . The JVM has currently no built-in support for dynamically typed languages: the existing JVM 

instruction set is statically typed, [4] although the JVM can be used to implement interpreters for dynamic languages. 

The JVM has a limited support for dynamically modifying existing classes and methods; this currently only works in 

a debugging environment. However, new classes and methods can be added dynamically. Built-in support for 

dynamic languages is currently planned for Java 7. [5]


Bytecode verifier 

A basic philosophy of Java is that it is inherently "safe" from the standpoint that no user program can "crash" the 

host machine or otherwise interfere inappropriately with other operations on the host machine, and that it is possible 

to protect certain functions and data structures belonging to "trusted" code from access or corruption by "untrusted" 

code executing within the same JVM. Furthermore, common programmer errors that often lead to data corruption or 

unpredictable behavior such as accessing off the end of an array or using an uninitialized pointer are not allowed to 

occur. Several features of Java combine to provide this safety, including the class model, the garbage-collected heap, 

and the verifier. 

The JVM verifies all bytecode before it is executed. This verification consists primarily of three types of checks: 

• Branches are always to valid locations 

• Data is always initialized and references are always type-safe 

• Access to "private" or "package private" data and methods is rigidly controlled. 

The first two of these checks take place primarily during the "verification" step that occurs when a class is loaded 

and made eligible for use. The third is primarily performed dynamically, when data items or methods of a class are 

first accessed by another class. 

The verifier permits only some bytecode sequences in valid programs, e.g. a jump (branch) instruction can only 

target an instruction within the same function or method. Furthermore, the verifier ensures that any given instruction 

operates on a fixed stack location [6] , allowing the JIT compiler to transform stack accesses into fixed register 

accesses. Because of this, the fact that JVM is a stack architecture does not imply a speed penalty for emulation on 

register-based architectures when using a JIT compiler. In the face of the code-verified JVM architecture, it makes 

no difference to a JIT compiler whether it gets named imaginary registers or imaginary stack positions that need to 

be allocated to the target architecture's registers. In fact, code verification makes the JVM different from a classic 

stack architecture whose efficient emulation with a JIT compiler is more complicated and typically carried out by a 

slower interpreter. 

Code verification also ensures that arbitrary bit patterns cannot get used as an address. Memory protection is 

achieved without the need for a Memory management unit (MMU). Thus, JVM is an efficient way of getting 

memory protection on simple architectures that lack an MMU. This is analogous to managed code in Microsoft's 

.NET Common Language Runtime, and conceptually similar to capability architectures such as the Plessey 250, and 

IBM System/38. 

Bytecode instructions 

The JVM has instructions for the following groups of tasks: 

• Load and store 

• Arithmetic 

• Type conversion 

• Object creation and manipulation 

• Operand stack management (push / pop) 

• Control transfer (branching) 

• Method invocation and return 

• Throwing exceptions 

• Monitor-based concurrency 

The aim is binary compatibility. Each particular host operating system needs its own implementation of the JVM and 

runtime. These JVMs interpret the byte code semantically the same way, but the actual implementation may be 

different. More complicated than just the emulation of bytecode is compatible and efficient implementation of the 

Java core API that has to be mapped to each host operating system.


Secure execution of remote code 

A virtual machine architecture allows very fine-grained control over the actions that code within the machine is 

permitted to take. This is designed to allow safe execution of untrusted code from remote sources, a model used by 

Java applets. Applets run within a VM incorporated into a user's browser, executing code downloaded from a remote 

HTTP server. The remote code runs in a restricted "sandbox", which is designed to protect the user from 

misbehaving or malicious code. Publishers can purchase a certificate with which to digitally sign applets as "safe", 

giving them permission to ask the user to break out of the sandbox and access the local file system, clipboard or 

network. 

C to bytecode compilers 

From the point of view of a compiler, the Java Virtual Machine is just another processor with an instruction set, Java 

bytecode, for which code can be generated. The JVM was originally designed to execute programs written in the 

Java language. However, the JVM provides an execution environment in the form of a bytecode instruction set and a 

runtime system that is general enough that it can be used as the target for compilers of other languages. 

Because of its close association with the Java language, the JVM performs the strict runtime checks mandated by the 

Java specification. That requires C to bytecode compilers to provide their own "lax machine abstraction", for 

instance producing compiled code that uses a Java array to represent main memory (so pointers can be compiled to 

integers), and linking the C library to a centralized Java class that emulates system calls. Most or all of the compilers 

listed below use a similar approach. 

Several C to bytecode compilers exist: 

• NestedVM [7] translates C to MIPS machine language first before converting to Java bytecode. 

• Cybil [8] works similarly to NestedVM but targets J2ME devices. 

• LLJVM [9] compiles C to LLVM IR, which is then translated to JVM bytecode. 

• C2J [10] is also GCC-based, but it produces intermediary Java source code before generating bytecode [11] . 

Supports the full ANSI C runtime. 

• Axiomatic Multi-Platform C [12] supports full ANSI C 1989, SWT, and J2ME CDC 1.1 for mobile devices. 

• Java Backend for GCC [13] , possibly the oldest project of its kind, was developed at The University of 

Queensland in 1999. 

• Javum [14] is an attempt to port the full GNU environment to the JVM, and includes one of the above compilers 

packaged with additional utilities. 

• egcs-jvm [15] appears to be an inactive project. 

Compilers targeting Java bytecode have been written for other programming languages, including Ada and COBOL. 

Licensing 

Starting with J2SE 5.0, changes to the JVM specification have been developed under the Java Community Process as 

JSR 924 [16] . As of 2006, changes to specification to support changes proposed to the class file format (JSR 202 [17] ) 

are being done as a maintenance release of JSR 924. The specification for the JVM is published in book form, [18] 

known as "blue book". The preface states: 

We intend that this specification should sufficiently document the Java Virtual Machine to make possible 

compatible clean-room implementations. Sun provides tests that verify the proper operation of 

implementations of the Java Virtual Machine. 

Sun's JVM is called HotSpot. Clean-room Java implementations include Kaffe, IBM J9 and Dalvik. Sun retains 

control over the Java trademark, which it uses to certify implementation suites as fully compatible with Sun's 

specification.


Heap 

The Java Virtual Machine heap is the area of memory used by the JVM (and specifically HotSpot) for dynamic 

memory allocation [19] . The heap is split up into "generations": 

• The young generation stores short-lived objects that are created and immediately garbage collected. 

• Objects that persist longer are moved to the old generation (also called the tenured generation). 

[20] [21] 

• The permanent generation (or permgen) is used for class definitions and associated metadata. 

There was originally no permanent generation, and objects and classes were just stored together in the same area. 

But as class unloading occurs much more rarely than objects are collected, moving class structures to a specific area 

allows significant performance improvements [20] . 

See also 


• Comparison of application virtual machines 

• Automated Exception Handling 

• Java performance 

• List of JVM languages 

References 

• Clarifications and Amendments to the Java Virtual Machine Specification, Second Edition [22] includes list of 

changes to be made to support J2SE 5.0 and JSR 45 

• JSR 45 [23] – Specifies changes to the class file format to support source-level debugging of languages such as 

JSP and SQLJ that are translated to Java 


• The Java Virtual Machine Specification [7] 

• Java implementations [24] at the Open Directory Project 

• Sun to build virtual machine for iPhone - ComputerWorld [25] 

• Java Virtual Machine Download Link [26] 

• JVM implementation in pure Java [27] 

References 

[1] http:/ / www. java. com/ en/ about/ Learn about Java Technology 

[2] 1996, possibly the first new language specifically designed to run on the JVM) 

[3] Tolksdorf, Robert (2005). "Languages for the Java VM" (http:/ / www. is-research. de/ info/ vmlanguages/ ). . Retrieved 2008-06-08. 

[4] Nutter, Charles (2007-01-03). "InvokeDynamic: Actually Useful?" (http:/ / headius. blogspot. com/ 2007/ 01/ invokedynamic-actually-useful. 

html). . Retrieved 2008-01-25. 

[5] Krill, Paul (2008-01-31). "Sun's Da Vinci Machine broadens JVM coverage" (http:/ / www. infoworld. com/ article/ 08/ 01/ 31/ 

davinci-machine_1. html). . Retrieved 2008-02-06. 

[6] "The Verification process" (http:/ / java. sun. com/ docs/ books/ jvms/ second_edition/ html/ ClassFile. doc. html#9766). The Java Virtual 

Machine Specification. Sun Microsystems. 1999. . Retrieved 2009-05-31. 

[7] http:/ / nestedvm. ibex. org/ 

[8] http:/ / cibyl. googlecode. com 

[9] http:/ / da. vidr. cc/ projects/ lljvm/ 

[10] http:/ / www. novosoft-us. com/ solutions/ product_c2j. shtml 

[11] http:/ / tech. novosoft-us. com/ product_c2j_faq. jsp 

[12] http:/ / objectmix. com/ compilers/ 37664-ampc-version-1-6-2-released-c-java-class-files-compiler. html 

[13] http:/ / www. itee. uq. edu. au/ ~cristina/ uqbt. html#gcc-jvm 

[14] http:/ / sourceforge. net/ projects/ javum/


[15] http:/ / sourceforge. net/ projects/ egcs-jvm/ 

[16] JSR 924 (http:/ / www. jcp. org/ en/ jsr/ detail?id=924) – Specifies changes to the JVM specification starting with J2SE 5.0 

[17] JSR 202 (http:/ / www. jcp. org/ en/ jsr/ detail?id=202) – Specifies a number of changes to the class file format 

[18] The Java Virtual Machine Specification (http:/ / java. sun. com/ docs/ books/ vmspec/ ) (the first (http:/ / java. sun. com/ docs/ books/ 

vmspec/ html/ VMSpecTOC. doc. html) and second (http:/ / java. sun. com/ docs/ books/ vmspec/ 2nd-edition/ html/ VMSpecTOC. doc. html) 

editions are also available online) 

[19] "Frequently Asked Questions about Garbage Collection in the Hotspot Java Virtual Machine" (http:/ / java. sun. com/ docs/ hotspot/ gc1. 4. 

2/ faq. html). Sun Microsystems. 6 February 2003. . Retrieved 7 February 2009. 

[20] Masamitsu, Jon (28 November 2006). "Presenting the Permanent Generation" (http:/ / blogs. sun. com/ jonthecollector/ entry/ 

presenting_the_permanent_generation). . Retrieved 7 February 2009. 

[21] Nutter, Charles (11 September 2008). "A First Taste of InvokeDynamic" (http:/ / blog. headius. com/ 2008/ 09/ first-taste-of-invokedynamic. 

html). . Retrieved 7 February 2009. 

[22] http:/ / java. sun. com/ docs/ books/ vmspec/ 2nd-edition/ jvms-clarify. html 


[24] http:/ / www. dmoz. org/ Computers/ Programming/ Languages/ Java/ Implementations/ 

[25] http:/ / www. computerworld. com/ action/ article. do?command=viewArticleBasic& articleId=9067358 

[26] http:/ / java. com/ en/ download/ inc/ windows_new_xpi. jsp 

[27] http:/ / igormaznitsa. com/ projects/ mjvm/ index. html 

Xerlin 

Xerlin is an open source XML editor for the Java 2 platform [1] released under an Apache style license. [2] The project 

is a Java based XML modeling application written to make creating and editing XML files easier. The latest version 

of Xerlin is 1.3, which was released in May 2005. 

Project Details 

Xerlin contains contributions originally made to the Merlot XML editor project, the open source project on which 

Xerlin is based. ChannelPoint founded and hosted the Merlot XML Editor as an open source project during 

2000-2001. Xerlin was created to build on those foundations and in fact used some of the same developers. [3] 

Xerlin runs on any Java 2 virtual machine (JDK1.2.2 or higher). The application is extensible via custom editor 

interfaces that can be added for individual DTD's. Xerlin can validate XML against both DTDs and Schemas. 

See also 

• Exari - Project founders 

Further reading 

• "Jar Bundler User Guide: Creating an Application Package" [4] . 2006-05-23. Retrieved 2009-05-15. 

• Kubo, Hiroya; Masatoshi Tamamura, Takashi Kowata, Ikuyo Kaneko (2002) (in Japanese) (pdf). Supporting 

School Evaluations by Customizable Questionnaire Schema Sharing [5] . Retrieved 2009-05-15. 

• Harold, Elliotte Rusty (2003-10-02). Effective XML: 50 specific ways to improve your XML. Addison-Wesley. 

pp. 76 – 77. ISBN 0-321-15040-6. 

• Baclawski, Kenneth; Niu, Tianhua (2005-10-01). Ontologies for Bioinformatics (1st ed.). MIT Press. pp. 10, 11, 

34. ISBN 0-262-02591-4. 

• Barth, Thomas; Schüll, Anke (March 2006) (in German, English). Grid Computing: Konzepte, Technologien, 

Anwendungen (1st ed.). Germany: Vieweg+Teubner. pp. 118, 122, 123, 132. ISBN 3-8348-0033-3. 

• Magnus, Jørgen Barsett (December 2007). Metabolic Engineering of the Valine Pathway in Corynebacterium 

Glutamicum - Analysis and Modelling. Germany: Forschungszentrum Jülich. p. 16. ISBN 3-89336-499-4.

Xerlin 305 

• Steinbrenner, Eugen (February 2009) (in German). Internetbasierte interaktive Lernmodule zur hierarchischen 

Datenstrukturierung und zur Linienglättung. Germany: Grin Verlag. pp. 9, 88. ISBN 3-640-27276-5. 



• Xerlin [7] at SourceForge.net 

References 

[1] Henderson, Robert; Deane, Sharon (2004-01-07). "Real-world XML". XML Made Simple. Amsterdam: Elsevier. p. 125. 

ISBN 0-7506-5998-X. 

[2] "Xerlin XML Editor license" (http:/ / www. xerlin. org/ LICENSE. txt). . Retrieved 2009-05-15. 

[3] "Stylus Studios: Open source XML Editor" (http:/ / www. stylusstudio. com/ xmldev/ 200207/ post20510. html). 2002-07-15. . Retrieved 

2009-05-15. 

[4] http:/ / developer. apple. com/ documentation/ Java/ Conceptual/ Jar_Bundler/ Packaging/ Packaging. html 

[5] http:/ / sqs. cmr. sfc. keio. ac. jp/ 2005/ 01/ gn. pdf 

[6] http:/ / www. xerlin. org/ 

[7] http:/ / sourceforge. net/ projects/ xerlin/

XStream 306 

XStream 

Developer(s) Codehaus 

Initial release January 1, 2004 


Operating 

system 


License BSD-style license 

Website http:/ / xstream. codehaus. 

org/ 

XStream is a simple Java library to serialize objects to XML (or JSON) and back again. [1] 

XStream library 

XStream stands out for its ease of use and low footprint. It uses reflection to discover the structure of the object 

graph to serialize at runtime. The XML it generates is very readable. 

The library doesn't require modifications to objects, so it's non intrusive to use the library. It can serialize internal 

fields, including private and final. Supports non-public and inner classes. [2] 

Object graph serialization 

When serializing an object it serializes the full object graph. Duplicate references encountered in the object-model 

will be maintained. For example using the following class CD 

package com.thoughtworks.xstream; 

public class Cd { 

private String id; 

private Cd bonusCd; 

Cd(String id, Cd bonusCd) { 

} 

this.id = id; 

this.bonusCd = bonusCd; 

Cd(String id) { 

} 

this.id = id; 

public String getId() { 

} 

return id; 

public Cd getBonusCd() { 

} 

return bonusCd;

XStream 307 

} 

and add some of these object to a list 

Cd bj = new Cd("basement_jaxx_singles"); 

Cd mr = new Cd("maria rita"); 

List order = new ArrayList(); 

order.add(mr); 

// adds the same cd twice (two references to the same object) 

order.add(bj); 

order.add(bj); 

// adds itself (cycle) 

order.add(order); 

XStream xstream = new XStream(); 

xstream.alias("cd", Cd.class); 

System.out.println(xstream.toXML(order)); 

If the above code is executed with XStream's default relative references mode, it will generate the following XML: 

 

 

maria rita 

 

 

basement_jaxx_singles 

 

 

 

 

XStream is free software, distributed under a permissive, revised BSD-style licence. 

Usage 

• Confluence [3] 

• Apache Muse [3] 


• XStream Library Home Page [4] 

References 

[1] "Serializing Java Objects with XStream" (http:/ / www. xml. com/ lpt/ a/ 1462). XML.com, O'Reilly Media, Inc. 2004-08-18. . Retrieved 

2009-12-14. 

[2] "Use XStream to serialize Java objects into XML" (http:/ / www. ibm. com/ developerworks/ java/ library/ x-xstream/ index. html). Ibm.com. 

. Retrieved 2009-12-14. 

[3] "XStream - References" (http:/ / xstream. codehaus. org/ references. html). Xstream.codehaus.org. . Retrieved 2009-12-14. 

[4] http:/ / xstream. codehaus. org/


Article Sources and Contributors 

Java (programming language) Source: http://en.wikipedia.org/w/index.php?oldid=379815313 Contributors: -Barry-, 16@r, 172.176.26.xxx, 1wolfblake, 4twenty42o, 7, =JaCyX=, @modi, 

ABCD, AJim, Aaron Bowen, Aaron Rotenberg, Abarnea 2000, Abelson, Adam1213, AdamH, Adamacious, Adashiel, Addaintstopnme, Addshore, Aditya, AdjustShift, Adw2000, Ae-a, Aeons, 

Aesopos, Agrawaam, Ahoerstemeier, Air pacquiao, Aitias, Aiyizo, Aka042, Akamad, Akersmc, Aksi great, Aktsu, Alai, Alainr345, Alan Rockefeller, Alansohn, AlbertCahalan, Alerante, Alex 

LE, Alex.atkins, Alex.muller, Alexdethier, Alexius08, Alfio, Alhoori, Alicam8, AlistairMcMillan, Allan McInnes, Alterego, Altmany, Alvin-cs, Am088, Amareto2, Amazon911, 

Ambarishmohan, Amicon, Amire80, Amitchaudhary, Ammubhave, Ancheta Wis, AndonicO, Andre Engels, Andrea Parri, Andres, Andrewferrier, Andrewlp1991, Andypandy.UK, Anger22, 

Angusmclellan, Anirudhsshastry, Anirudhvyas010, Anizzah, Anon lynx, Anoopan, Antaeus Feldspar, Antandrus, Antidrugue, Anwar saadat, Aphonik, Arabic Pilot, Arbitrarily0, 

ArchMageZeratuL, ArchNemesis, Archenzo, Ardonik, Ardric47, Aremith, Arloz, Armando82, Arnehans, Arrenlex, AscendantOat, Austin Hair, Averell23, B3t, BBUCommander, Baa, 

Babarcash, Babedacus, Babomb, Bacchus87, Bachmann1234, Bact, Badgernet, Banaticus, Baricom, Baronnet, BarretBonden, Basitj, Batneil, Bboy123, Bcrowell, Bedel23, Belem tower, Ben 

Arnold, BenAveling, Benhocking, Beno1000, Betacommand, Bevo, Biblbroks, BigGuyC, Bijee, Biker Biker, Billy On Bannana Peels, Biot, Bissinger, Blablablob, Blankfrack, Bluemoose, 

Blurpeace, Bobblewik, Bobo192, Boing! said Zebedee, Booyabazooka, Borislav, Bovlb, Bravegag, Brick Thrower, Brion VIBBER, Brossow, BruceMagnus, Bubba-, Buchanan-Hermit, Bulatych, 

BurntSky, Burzmali, Byronknoll, Bytbox, CAkira, Cal 1234, Calvin 1998, Calvinaustin, Canadafreakazoid, CanadianLinuxUser, Cananian, Candear, CanisRufus, Cap'n Refsmmat, CapitalR, 

Capricorn42, CaribDigita, Casperl, Cat-five, Catamorphism, Catgut, Cburnett, Centrx, CesarB, Cgs, Chandrasekar78, Chaotic cultist, Charles Matthews, CharlesC, Chasingsol, Chazwatson, 

Chealer, Cheesy mike, Chei, Cheung1303, Chinhnt2k3, Chiok, Chip Zero, Chiprunner, Chocolateboy, Chowbok, Chrislk02, Chrissyboi, ChristianEdwardGruber, ChristopheS, Christopher 

Mahan, Chu Jetcheng, Chuayw2000, Chuq, ClanCC, Classical Esther, Cleared as filed, ClockworkLunch, Closedmouth, Clydedoris, Coffee, Coley s, Cometstyles, Connelly, Conor H., 

Conversion script, Coolshit, Corpx, Corti, Cp98ak, Cpl Syx, Crazz bug 5, Creidieki, CunningLinguist, Cureden, Curmudgeon99, Curps, Cwfrei, Cwolfsheep, Cyan, Cybercobra, CyborgTosser, 

Cynic783, Cyp, Cyrius, D'Agosta, D6, DARTH SIDIOUS 2, DJ Clayworth, DMacks, DNewhall, Daf, Daimengrui, Damian Yerrick, Dan aka jack, Danakil, Dancraggs, Danhash, Daniel 

Brockman, DanielTrox, Danrah, Darklilac, Dave Runger, David Gerard, Davidjk, Davidweiner23, Dawnseeker2000, Dbiagioli, Dcoetzee, Dcprice555, DeadEyeArrow, Debajit, Debashish, Debeo 

Morium, Decagon, Delian31, Delirium, Delldot, Delta G, DennisWithem, Derek farn, DetlevSchm, Dgies, Dgwarwick, Dhoom, Diberri, Dibujon, Diderot's dreams, Dillard421, DineshMungra, 

Dingskes, Dipet343, Discospinster, Djsuess, Dll99, Dmyersturnbull, Dominic7848, Don-vip, Dongiulio, Doradus, Doug Bell, Dpark, Dr-unifex, DrIdiot, Drakkos, Drappel, Dreadstar, Dream of 

Goats, DreamGuy, Drmies, DropDeadGorgias, Dterei, Dumitru Gherea, Dysprosia, Dystopianray, Eagleal, Easyas12c, EatMyShortz, EbulaJonez, Ed Poor, Edcolins, Edknol, Edward, Edwin.wei, 

Efriedman, Egomaniac, Ekashp, ElBenevolente, Elf, Ellenaz, Ellmist, Eloquence, Elvarg, Ems2, Enchanter, EngineerScotty, Enough2000, EpiQ SkiLL, Er Komandante, ErKURITA, Errandir, 

Ervinn, Essjay, Ethridgela, Etz Haim, Euchiasmus, Everyking, Evice, Evil Monkey, Evil saltine, Evildeathmath, Excirial, FactChecker1199, Fagstein, Fakahi, Falcon300000, Falcon8765, Fang 

Aili, Fasga, Fashionslide, Fast.ch, Fasten, Favonian, Fennec, Ferdinand Pienaar, Feureau, Ff1959, Fieldday-sunday, Finlay McWalter, Flamingantichimp, Flash200, FlavrSavr, Fleminra, Fogger, 

Fotinakis, Frap, Frecklefoot, Fredrik, Freedom to share, FreplySpang, Ftiercel, Fuchsias, Funandtrvl, Furrykef, Fx2, Gail, Gaius Cornelius, Galaxy001, Galwhaa, Gamma, Gary King, 

Garygateaux, Garyzx, Gazwim, Gdavidp, Geekler, Generalguy11, Georgia guy, Giftlite, Gilgamesh, Gimme danger, Gimmekat, Givegains, Glasser, Glenn Maddox, Glezos, GnuDoyng, Gogo 

Dodo, Gortsack, Gracenotes, GraemeL, Graffity, Grandscribe, Graue, Great Cthulhu, Green caterpillar, Green meklar, Greenrd, Gronky, Grunt, Gscshoyru, Gudeldar, Gurch, Gurklurk, Gutworth, 

Guusbosman, Guy Peters, Guyjohnston, Gwern, Gzkn, Gökhan, H-b-g, H4xx0r, Hadal, Haham hanuka, HalfShadow, Hao2lian, HappyInGeneral, Hara100, Hariva, Harm.frielink, 

HarmonicSphere, HarryAlffa, Harshadoak, Haseo9999, Havarhen, Hayabusa future, Hdante, Hedoluna, Henning Makholm, Henrygb, HereToHelp, Hervegirod, Hfastedge, Hgfernan, Hirudo, 

Hirzel, Hmains, HoganLong, Hooperbloob, Hosterweis, Hrshtkumar, Hu12, Husond, IBlender, Ideogram, Imaginationac, Immunize, Int19h, Ioakar, Iodine, Iridescent, Irish Souffle, Irishguy, 

Ishanthasiribaddana, J Di, J.J.Sagnella, J.delanoy, J.l.barthel, J7, JEBrown87544, JHeinonen, JIP, JLaTondre, JOptionPane, JTN, JWaide, Jabberrock, Jaglnx, Jamesday, Jarchitect, Java jack jan, 

Javageek212, Javawizard, Jay, Jay Gatsby, Jaybee, Jaydeki, Jcw69, Jdforrester, Jeff G., Jeffq, Jeffrey Mall, Jeffuit, Jeltz, Jemijohn, JenniferHeartsU, Jeronimo, Jesse Viviano, JesseHogan, Jglick, 

Jibjibjib, Jijithp, JimWae, Jimguot, Jiy, Jj137, Jjaazz, Jleedev, Jmendez, Joelr31, Joerite, John Hendrikx, John Vandenberg, JohnCongerton, Johnuniq, Jojit fb, Jonabbey, Jonathanischoice, Jondel, 

Jonik, Jopo sf, JorgePeixoto, Joseph Solis in Australia, JoshHolloway, Joshisachin79, Jsavit, Juansempere, Julian Mendez, Junes, Jusdafax, Justforasecond, KUsam, Kaldari, Kamalraja, 

Kamasutra, Kariteh, Karl-Henner, Kbolino, Kcirb, Kedit1181, Keith Azzopardi, KelleyCook, Kevin Saff, Keycard, Khakipuce, Khalid hassani, Killick, Kingturtle, Kkm010, Kks krishna, 

Klausness, Klingpl0x, KnowledgeOfSelf, Knyf, Kona1611, Koyaanis Qatsi, Kozuch, Kprobst, Kula85, Kungfuadam, Kurrgo master of planet x, Kvdveer, Kwaku, Kyle Baggs, LFaraone, 

Landryhc, Lavellem, Leafyplant, LeaveSleaves, Lee Daniel Crocker, Lee J Haywood, LeeHunter, LeilaniLad, LestatdeLioncourt, Levin, Lights, Little Mountain 5, LittleDan, Loadmaster, 

Logariasmo, Lpetrazickis, Lucas Malor, Luk, Lukejea, Lumingz, Luna Santin, Lupin, Lysander89, M1chu, M4gnum0n, MER-C, MIT Trekkie, MYC36, MaBe, Magicfox13, Magioladitis, 

Magister Mathematicae, Magnus Manske, Mahanga, MaikSchreiber, Mailer diablo, Mainepenguin, Majorly, Malcohol, Mani1, Maoj-wsu-MC, MarSch, MarXidad, Maraist, Marcelbutucea, 

Marcoandre, Mark Harrison, Mark Renier, MarkSweep, Marky1981, Marlow4, Martarius, Marteau, Marty360, Maryo1912, Massysett, Matherson, Matthew Yeager, Matthewpun, Matthieu fr, 

Mav, Max Schwarz, MaxEnt, Maxim, Mcclain, Meara, Mecanismo, MeekMark, Meekohi, Melnakeeb, Melsaran, Menchi, Mentifisto, Metamorf, Mfb52, Mhorlbec, Michaelneale, Mikademus, 

Mike0001, Mikelo.Arbaro, Mikm, Minesweeper, Minghong, Minipie8, Minkythecat, Minute Lake, Mipadi, Mirror Vax, Misantropo, Misza13, Mitchellfx, Mjroots, Modster, Modulatum, 

Mohamedloey, Mohsens, Molteanu, Momet, Monkbel, MoraSique, Morte, Morwen, Mr link, MrCoder, MrJones, Mritunjai, Mrstonky, Msusmangani, Mtleslie, MuZemike, Mucus, Mxn, Myanw, 

Mzajac, N4te, NJM, Naddy, Nanshu, NapoliRoma, NathanBeach, Ncmathsadist, Neilc, Nephelin, Nephtes, Neurolysis, NevilleDNZ, NewEnglandYankee, Newsmaestro, Nick R Hill, Nick125, 

NickBush24, Nigelj, Nikai, Nikhil.bandekar, Nil Einne, Nimur, Nixeagle, Nmrd, Nnp, NoirNoir, Nopetro, Npovmachine, Ntsimp, NuclearWarfare, Nwbeeson, Oatmealcookiemon, Oblivious, 

Odinjobs, Ohnoitsjamie, Oldadamml, Oleg Alexandrov, Oli Filth, Onehundredandtwo, Onevalefan, Opt 05, Orderud, Orisino, OscarTheCat3, OwenBlacker, OwenX, Oysterguitarist, P-unit, 

P0lyglut, PGibbons, PMJain, Pagingmrherman, Pascalv, Patman g, Patrick987, Paul Murray, Paul Richter, Paul99, Paules nl, Pavel Vozenilek, Peepeedia, Pengo, PerLundberg, Perfecto, Peter 

Delmonte, Peter Griffin, Peter lawrey, Peterl, Pgk, PhageRules1, Phantomsteve, Pharos, Phgao, Phil websurfer@yahoo.com, PhilKnight, Philipwhiuk, Phoenix-forgotten, Piano non troppo, Piet 

Delport, Pigpigking, Pinktulip, Pipedreamergrey, Pizza Puzzle, Plugwash, PlusMinus, Pmronchi, Pne, Poccil, Polluxian, Polydor, Pontillo, Poor Yorick, Potatoj316, Premvvnc, Priyankgokani, Pro 

Grape, Professor Calculus, Proficient, ProvingReliabilty, Public Menace, Pundeerd, PuzzletChung, Pwooster, Quadell, Qwertyus, R3m0t, Rab8613, Raistlin11325, RandalSchwartz, Ranjith16, 

Rao crazy, Raul654, Ravchit, Raven4x4x, Raynoism, Rccarman, Rcs, Rdsmith4, Real-Life Sock Puppet, RedWolf, RedZombie125, Redrocket, Redvers, Reisio, Rettetast, RexNL, Rgeorgy, 

Rhobite, RichF, Rick Jelliffe, Risk one, Rjmfernandes, Rjwilmsi, Robert Merkel, Robert Skyhawk, RobertG, Robo.mind, Rodhullandemu, Rogerd, Ron mmi, Ronz, RossPatterson, Rossmann, 

RoyBoy, Rror, Rtanz, Rufous, Ruiz, Ruud Koot, Rzwitserloot, S-n-ushakov, SAE1962, SF007, SGNDave, SNIyer12, ST47, Sam Hocevar, Sam Korn, Sam jervis, Samohyl Jan, San25872, 

Santiago Roza (Kq), Saravask, Sasha Slutsker, Sass24, Satanjava, Scarian, Schissel, SchnitzelMannGreek, Scientus, Scjessey, Scm83x, Scovetta, Sdfisher, Sdornan, SeanJA, Seanhan, 

Search4Lancer, Sebastiangarth, Seraphimblade, Sfmontyo, Shadowjams, Shenme, Siddartha.kaja, Sigma 7, SimonP, Sinn, Sir Anon, SirWoland, Siroxo, Sirworthyduck, Sj, Sjarosz, Sjc, 

SkyWalker, Sleske, Slike, SlitherM, Smyth, Snowolf, Socablg2, SocratesJedi, Sohil it, Some P. Erson, Soptep, Spalding, Sparker046, Speedogoo, Spencer, Spiff, SpikeToronto, Spookfish, 

Spoon!, Spug, Squingynaut, Starblind, Starwiz, Steffen Felbinger, Stephen, Stephen B Streater, Stereo, Stevenj, Stevenrasnick, Stevietheman, Stormie, Styrofoam1994, Subanark, Suffusion of 

Yellow, Sunderland06, Super Quinn, SuperU, Superfly Jon, Superm401, Supernova17, Supertouch, Susvolans, SvGeloven, Swintrob, Sylent, Synthiac, Szajd, TOReilly, TRauMa, TakuyaMurata, 

Talandor, Tar5047, Tariqabjotu, Tasc, TastyPoutine, Tcgunner90, Tcncv, Teabeard, Technopat, Tedickey, Tellyaddict, Template namespace initialisation script, TerokNor, Terrible Tim, 

Testmod1, The Anome, The Elves Of Dunsimore, The Hokkaido Crow, The Thing That Should Not Be, The wub, The1physicist, The2ndflood, TheDarkArchon, TheSpook, Thehelpfulone, 

Theresa knott, Theuser, Thingg, Thornelytaylor, Thue, Thumperward, Thunderbolt16, Tillmo, Tim1988, TimTay, Timwhit, Titoxd, Tjansen, Tkgd2007, Tlim7882, Tmaher, Tmbg37, Tom 99, 

Tommy2010, Tompsci, Torc2, Tothwolf, Toussaint, Toytoy, Tresiden, Troels Arvin, Tthorley, Ttwaring, Turing, Tushar.kute, Tustin2121, Tvynr, Twister nt, Tyraios, Tyrol5, Tyw7, Ubuntu2, 

Ultimus, Uncle G, UnitedStatesian, Unixer, Unixxx, Urod, Uselesswarrior, Utcursch, UtherSRG, VX, Valerio81, VantagePoint, Vchimpanzee, VeLoCiTy89, Vera.tetrix, Viciodk, Viebel, Viento, 

Violetriga, Visor, Vizspring, Vocaro, Volt4ire, Vvidetta, WJBscribe, Wasimbargujar, Wbrameld, Wdyoung, Web-Crawling Stickler, Webmink, Weregerbil, Wesley crossman, Wgw2024, Wgw4, 

White Cat, Whosyourjudas, Wiggin15, Wik, WikiLeon, Wikianon, Wikipelli, Wikipendant, Wikiwerks, Wikiwikiwifi, William Allen Simpson, Wimt, Windchaser, Wknight94, Wlievens, 

Wmahan, Wonko, Wootery, Wowus, Wrp103, Wsaryada, WurmWoode, Ww, Wyredchris, Wzwz, Xan 213, Xaosflux, Xelgen, Xezbeth, Xinconnu, Xpodmaniac, Xproject, Yamaguchi先生, 

Yamamoto Ichiro, Yamla, Yozh, Yulracso, Yurik, Yurivict, Zawersh, Zazpot, Zekeo, Zenohockey, Zijian, Zik-Zak, Zxcvbnm, Zyphrix, Ævar Arnfjörð Bjarmason, 六脉飞天牛, 2413 anonymous 

edits 

Web Language Source: http://en.wikipedia.org/w/index.php?oldid=296014078 Contributors: Amalas, Anshul, Codeseg, Satori Son, Solarapex, Vycanis 

AgentSheets Source: http://en.wikipedia.org/w/index.php?oldid=345477334 Contributors: Adjusting, Andreas Kaufmann, Birbilis, CRGreathouse, CharlesGillingham, DNewhall, Destynova, 

Dragentsheets, Dugwiki, Gudeldar, Hroðulf, Karatorian, Kvn8907, Mange01, McLar eng, Oddharmonic, Peterl, The Thing That Should Not Be, Tziortzioti, VX, Waldir, William Avery, 12 

anonymous edits 

Oak (programming language) Source: http://en.wikipedia.org/w/index.php?oldid=368212204 Contributors: Csl77, Hervegirod, Hmains, Loadmaster, Paul Foxworthy, Rich Farmbrough, Ryan 

suchocki, 4 anonymous edits 

Lightweight Java Source: http://en.wikipedia.org/w/index.php?oldid=363175217 Contributors: Alainr345, Hmains, Rich Farmbrough, VX, Vortigen 

.properties Source: http://en.wikipedia.org/w/index.php?oldid=374340272 Contributors: .digamma, Andy.goryachev, Bissinger, Brsanthu, Chridd, Cybercobra, Goatcheez, Greenrd, Ike-bana, 

Iridescent, J. Finkelstein, Jerome Charles Potts, Jmlk17, John Vandenberg, Kjoonlee, Mipadi, Nick, Od Mishehu, PatrikR, Ptomasek, Rror, Spacebirdy, Timothy Truckle, Tom Morris, Waxigloo, 

22 anonymous edits 

Apache Harmony Source: http://en.wikipedia.org/w/index.php?oldid=378992487 Contributors: Aidan W, Alainr345, Andareed, Audriusa, Brian Geppert, Burschik, C. A. Russell, Daev, 

Dave.tillman, Dirk Riehle, Doug Bell, East718, Engas, Evice, Faisal.akeel, Fiftyquid, Frap, Gaius Cornelius, Geirmagnussonjr, Greenrd, Gronky, Grutness, Haakon, Hervegirod, Hu12, Ike-bana, 

ItsProgrammable, JLaTondre, JensMueller, Joehni, John of Reading, Kesla, Khalid hassani, LazyEditor, Lightmouse, Logixoul, Marudubshinki, Maurogiachero, Membar2,


Mercadodiego@gmail.com, MoreNet, Per Abrahamsen, Qutezuce, Revolus, Rich Farmbrough, Rjwilmsi, SF007, SimonP, Straxus, Superm401, SymlynX, TakuyaMurata, The Thing That Should 

Not Be, TheParanoidOne, UU, Uga2, Waldoalvarez00, 169 anonymous edits 

Apache Muse Source: http://en.wikipedia.org/w/index.php?oldid=331712358 Contributors: CultureDrone, EdGl, M4gnum0n, MauriceKA, Mlaffs, Power.corrupts 

Apache Shiro Source: http://en.wikipedia.org/w/index.php?oldid=371264579 Contributors: Achille, Alainr345, Cameronbraid, Jeandré du Toit, Kyle1278, Malcolma, Manjula.aw, Rhino1977, 

Skipshot4, Tokek, 8 anonymous edits 

Java applet Source: http://en.wikipedia.org/w/index.php?oldid=380110454 Contributors: 213.89.18.xxx, Alainr345, Alansohn, Alexwright, Alvin-cs, Amareto2, Anonymous56789, Artw, 

Audriusa, Bdiscoe, BonzoESC, Borgx, Bryan Derksen, Brz7, Byronknoll, Canderra, Cesarsorm, Charivari, Chris Wood, ChronoKinetic, Cmccormick8, Conradbate, Conversion script, Da rulz07, 

Doug Bell, Ency, EoffreyGey, FactChecker1199, Frap, Frecklefoot, Futurix, Fuzzie, Giftiger wunsch, Group29, Grshiplett, Haakon, Hellisp, Hem1234, Heron, Hu12, Ian Pitchford, Iridescent, 

Jacobolus, Jay, JeLuF, Jengelh, Jmnbatista, Jwoodger, Lee J Haywood, LittleDan, Lotje, Magioladitis, Maima, Marcobiscaro2112, Mark Renier, MartinHarper, Michael Hardy, Mikenolte, 

Minghong, Modulatum, NawlinWiki, Nipesh1, Od Mishehu, Patobrien99, Peak, Pearle, PhilKnight, Phyzome, Plugwash, Prodego, RealWorldExperience, RedWolf, Reisio, Rich Farmbrough, 

Rick Block, Rror, SDiZ, Sahib12, Shandru, Shanes, Sherool, Skeejay, SnowFire, Spoon!, Stephen B Streater, Taka, TimTay, TonyW, Toussaint, Twi20Pi, UU, Udittmer, Unknown W. Brackets, 

Wapcaplet, Wtmitchell, Yozh, 用心阁, 169 anonymous edits 

Associació d'Usuaris de Java de Catalunya Source: http://en.wikipedia.org/w/index.php?oldid=348025725 Contributors: Chris the speller, Jordi.pujol.ulied, LilHelpa, Malcolma, Rich 

Farmbrough, Skier Dude, Tabletop, 3 anonymous edits 

Automated exception handling Source: http://en.wikipedia.org/w/index.php?oldid=364328873 Contributors: Abarnea 2000, Alansohn, Cybercobra, Intgr, Reinyday, Rigadoun, Shabda, 1 


Bean Scripting Framework Source: http://en.wikipedia.org/w/index.php?oldid=345196680 Contributors: BeBop, Bkkbrad, Bluemoose, Caerwine, Curps, Faisal.akeel, Gaius Cornelius, 

JLaTondre, Jnc, Jpp, Kopf1988, Madhero88, Malcolma, TheParanoidOne, Weyes, Wikimsd, Winptor, 16 anonymous edits 

CJAN Source: http://en.wikipedia.org/w/index.php?oldid=300894550 Contributors: Elonka, JanGB, Rjwilmsi, Scrool, Skysmith, Tabletop, UncleFester, WRK, 6 anonymous edits 

Celtix Source: http://en.wikipedia.org/w/index.php?oldid=368606334 Contributors: Frap, MrOllie, Tassedethe, Yadab Das, 1 anonymous edits 

Chainsaw (log file viewer) Source: http://en.wikipedia.org/w/index.php?oldid=305625547 Contributors: Fabrictramp, Gamefreak2413, LAX, PigFlu Oink, Sci girl, 12 anonymous edits 

clone (Java method) Source: http://en.wikipedia.org/w/index.php?oldid=371965403 Contributors: Abdull, Afromayun, Andreafrancia, Btx40, Faustus, Gerd-HH, Jcarroll, Jugular, Ketiltrout, 

Lax4mike, Mcorazao, Pjpringle, Spoon!, Supereddy, Tyraios, Yaniv Kunda, Zxcvcxz, 19 anonymous edits 

Comparison of Java and C Sharp Source: http://en.wikipedia.org/w/index.php?oldid=379974742 Contributors: (www itshixun com)GaoXiaoZu, 21655, Acid2base, Ahoerstemeier, Ajgorhoe, 

Alasdairking, AmadeoV, Amniarix, Ancheta Wis, Audriusa, Bertport, Bilal.alsallakh, Blowdart, Brunoton, Btx40, CCFS, Canderra, CanisRufus, Capnmidnight, Cerowyn, Chip Zero, Chowells, 

Chri1753, Chrisahn, Closedmouth, Collard, Colonies Chris, Coolboy1234, Craig Stuntz, Creek23, Curps, Cybercobra, CyborgTosser, Cyril, Daniel Earwicker, Darthsco, Debresser, 

DerrickOswald, DevastatorIIC, Developer38, Donhalcon, DoomBringer, Doug Bell, Dreftymac, Drstorm, EDNY200901(FLYASDRAGON), EDNY20090105maona, Ed Poor, Edurant, 

Elsendero, Enchanter, Erik Sandberg, FayssalF, Firsfron, Frecklefoot, Futurix, Gaijin42, Gatoatigrado, Greggobridges, GregorB, GreyCat, Groat, Gurch, Helpsloose, Hervegirod, Hooperbloob, 

Howcheng, Idolescent, Ieee8023, Ike-bana, Inquisitus, Int19h, ItsProgrammable, J04n, JHunterJ, JIP, Jackcsk, Jamelan, JamesNK, JavaKid, Jaydec, Jdthood, Jfbilodeau, Jfrascencio, Jkl, Jmundo, 

Josephw, Jvorchak, Kenyon, Kesla, Khabara, Kittybrewster, Knowzilla, KrisK, Ktalon, Leotohill, Lightxx, Loadmaster, Lobner, Maghnus, Maraist, Martin Fuchs, Mazi, Mboverload, Melchoir, 

Mets501, Mfb52, Mik01aj, Mikenolte, Mikon, Mirror Vax, Mishka.medvezhonok, Mitch Ames, MovGP0, Mugunth Kumar, NaibStilgar, Nathanaeljones, Neilc, Netoholic, NewEnglandYankee, 

Nma wiki, Norm mit, Nuggetboy, Numberp, Oldadamml, Omegarad, Orderud, Oren0, PPGMD, Pelister, Philu, Piano non troppo, Porges, Promit, Psiphiorg, Quota, Qutezuce, RHB, Rajakhr, 

Ralesk, RapidSkis, Raptor3676, Rednblu, RenataLiting, RevRagnarok, Robartin, Root4(one), Rp, Rror, Rursus, Samrolken, Sarloth, SchfiftyThree, ShadowRangerRIT, Shubhkarmansandhawalia, 

Soumyasch, Spidermario, Squash, SteinbDJ, Steven Zhang, Strangeweather, Subanark, Superm401, Svick, Tbjablin, The Elves Of Dunsimore, The1physicist, Tim1357, TimBentley, TimTay, 

Timwi, Tleave2000, Tmcdouga, TobiasPersson, Tohd8BohaithuGh1, Torc2, Toussaint, Triplesub, UnitedStatesian, Useerup, Vahid83, Valodzka, Vazbik, Visor, Vlad, W3bbo, Waldir, War 

Famine Pestilence Death, Webmaster961, Winterst, Woohookitty, Yms, Ynhockey, Yurik, ZacBowling, Zain engineer, 543 anonymous edits 

Comparison of Java and C++ Source: http://en.wikipedia.org/w/index.php?oldid=380005248 Contributors: 1exec1, Aandu, Aavindraa, ActiveSelective, Adamd1008, Alainr345, Alex Heinz, 

Alexnye, Alterego, Aprock, Barefootguru, Bdodo1992, Bjdehut, Bovineone, Bryan Derksen, Buckyboy314, CanisRufus, Cardatron, Catamorphism, Cfeet77, Chip Zero, CmdrRickHunter, 

CodedoC, Crashie, Curps, CyborgTosser, Damian Yerrick, Dangiankit, DanielPharos, Daquell, Darkwind, David Wahler, Decltype, Derek Ross, DerrickOswald, DevastatorIIC, Donhalcon, Doug 

Bell, Dthomsen8, Dustball, EYOLs, Ed Poor, EdSquareCat, Eelis.net, Ees, EmeryD, Erik Sandberg, Esben, EverGreg, Ezrakilty, Flums, Frecklefoot, Gamahucheur, Garyzx, Giftlite, Grunt, 

Gudeldar, Harryboyles, Hgb asicwizard, Hirzel, Hsz, Ivec, JavaKid, Jayaram ganapathy, Jespdj, Johntabularasa, JulesH, Juliano, KardinalKill, Karl Dickman, Kazkaskazkasako, Kbolino, Kexyn, 

Kilo-Lima, King Mir, Kittybrewster, Kmorozov, Kwertii, Lkinkade, Loadmaster, MarSch, Marco255, Martin Fuchs, MartinDK, Mathieu, McNepp, Medinoc, Michael Trigoboff, Miffy900, 

Mikon, Mirror Vax, Molteanu, Mwn3d, Mysekurity, Neilc, Netoholic, Nono64, Orderud, OverlordQ, Owl order, Pascal.Tesson, Pcu123456789, Peterdjones, Peterl, Pfunk42, Rainwarrior, 

Ranjyad, Rdsmith4, Reckjavik, Rengolin, Requestion, Rjwilmsi, Rodrigostrauss, Root4(one), Sandahl, Saucepan, Schapel, SeverityOne, Sfmontyo, Sjc, SlitherM, Solarswordsman, Specs112, 

Spoon!, Squash, Super Quinn, Sussexonian, Tarquin, The Elves Of Dunsimore, The Thing That Should Not Be, Themusicgod1, Thenarrowmargin, Thymefromti, Tiagofassoni, Tim Starling, 

Timgurto, TobiasPersson, Tundra010, Urod, Veritas Blue, Vertexua, Vqwj, War Famine Pestilence Death, Weregerbil, Wesley, Wikitoov, Wrldwzrd89, Wtmitchell, XNinto, Ysangkok, Zertyz, 

Zzuuzz, Ævar Arnfjörð Bjarmason, 334 anonymous edits 

Comparison of the Java and .NET platforms Source: http://en.wikipedia.org/w/index.php?oldid=377659395 Contributors: ACSE, Aadnk, Adw2000, Alexander Abramov, AlonzoChurch, 

Andrewpmk, Audriusa, BorisDušek, Chip Zero, ChorizoLasagna, Crazycomputers, CritterNYC, Cyril, DH85868993, Danrah, Dethme0w, EdgeOfEpsilon, Edward, Erik Sandberg, Eriks81989, 

Evildeathmath, Fduch, Frap, Futurix, GoingBatty, Gordonrox24, Gracefool, HAl, Haoyao, Hervegirod, Hexene, Ike-bana, Inks.LWC, Iridescent, JavaKid, Jcarroll, Jzubeck, Kingboyk, 

Kubanczyk, LedgendGamer, Leotohill, MER-C, Maghnus, Meebey, Mernen, Mfb52, Mike Linksvayer, Mitch Ames, Mk*, Mrnatural, NaibStilgar, Ootachi, Paul Foxworthy, Powerlord, 

Ricvelozo, Rjwilmsi, SF007, Sebleblanc, Sedimin, Shadowjams, Starionwolf, Stetorvs, Superfly Jon, Svick, Tavilis, Tbjablin, Tokek, Torc2, Wtaa, Xpclient, Yozh, Yusnielb, ZacBowling, 73 


Constant interface Source: http://en.wikipedia.org/w/index.php?oldid=318583679 Contributors: BlindWanderer, Libsoc, Malcolma, Melchoir, Mister Farkas, Savastio, TreasuryTag, 1 


Java 4K Game Programming Contest Source: http://en.wikipedia.org/w/index.php?oldid=353912194 Contributors: Alynna Kasmira, Amalas, Dreftymac, Invader Zim, Jbanes, Kelly Martin, 

Kylu, Marasmusine, Morre, NapoliRoma, Renanse, Retired username, Rjwilmsi, Synergy, West.andrew.g, 22 anonymous edits 

CookXml Source: http://en.wikipedia.org/w/index.php?oldid=367970361 Contributors: Aboriginal Noise, Bryan Derksen, Coconut99 99, Elwikipedista, Gronky, Isilanes, Kl4m-AWB, 

Seraphimblade, Torc2, TubularWorld, 2 anonymous edits 

Cougaar Source: http://en.wikipedia.org/w/index.php?oldid=344288000 Contributors: Atlantima, CanisRufus, Dr Gangrene, Gvidaver, Khalid hassani, Malcolma, Midavalo, Network Inkling, 

Rob Cranfill, Ruud Koot, Waldir, Zootalures, 3 anonymous edits 

Deterministic Parallel Java Source: http://en.wikipedia.org/w/index.php?oldid=348783386 Contributors: Esfand30, Malcolma, Pointillist, R'n'B, 1 anonymous edits 

Devoxx Source: http://en.wikipedia.org/w/index.php?oldid=352925745 Contributors: Dawynn, Fabrictramp, HenkvD, Hu12, Michig, Pascal.Tesson, Shalom Yechiel, Sjabejug, Skittleys, Turb, 

Zqudlyba, 2 anonymous edits 

Doclets Source: http://en.wikipedia.org/w/index.php?oldid=338833861 Contributors: (:Julien:), Rolfedh, 1 anonymous edits 

Elastic Path Source: http://en.wikipedia.org/w/index.php?oldid=378169053 Contributors: Cander0000, Elasticpath, Nihiltres, R'n'B 

Electronic Disturbance Theater Source: http://en.wikipedia.org/w/index.php?oldid=370943445 Contributors: Badassant, CosineKitty, EagleFan, Paine Ellsworth, R'n'B, RoboHomo, SatyrTN, 

ShadowNano169, Woohookitty, 1 anonymous edits 

Event dispatching thread Source: http://en.wikipedia.org/w/index.php?oldid=372792428 Contributors: Auric, Doug Bell, Echawkes, FredSwartz, Hervegirod, Pearle, R. S. Shaw, Stolsvik, 

Ultimatepolo, 15 anonymous edits


Facelets Source: http://en.wikipedia.org/w/index.php?oldid=368769435 Contributors: Alainr345, Arjant, Gernhwak, HairyFotr, Hosamaly, MacGyverMagic, MatthewVanitas, Olekva, Penkeen, 

RHaworth, T@nn, Tassedethe, Tritium6, Tyraios, 43 anonymous edits 

final (Java) Source: http://en.wikipedia.org/w/index.php?oldid=377437826 Contributors: 16@r, Abdull, Aitias, AndrewHowse, Art187, Bluemoose, Calimo, Chetandandgey, Choas, Darend, 

Ezrarez, Fahadsadah, Genesis, Jann2005, Kingpin13, Kulandai, Looris, Max Schwarz, Muchness, Myncknm, Niclas Wiberg, Oleh Kernytskyi, P1h3r1e3d13, Psbsub, Randomblue, Rp, SAE1962, 

Sethrh, Smallman12q, Spoon!, Techman224, Tobyr2, Zolv, 45 anonymous edits 

FloodNet Source: http://en.wikipedia.org/w/index.php?oldid=345439463 Contributors: Badassant, Interiot, Kenb215, Malcolma, Rjwilmsi, 5 anonymous edits 

FormEngine Source: http://en.wikipedia.org/w/index.php?oldid=377446090 Contributors: Jpbowen, Rich Farmbrough, Ustark, Vbublitz, 2 anonymous edits 

Generics in Java Source: http://en.wikipedia.org/w/index.php?oldid=379190046 Contributors: 16@r, Adw2000, Alfe, BernardSumption, Buttermilchtrinker, Carlosayam, Chip Zero, 

Closedmouth, Cybercobra, Delirium, Dmyersturnbull, Dreish, Ed Poor, Eve Teschlemacher, Godbe, Gracenotes, Green caterpillar, Gryzlo, Hervegirod, Irrªtiºnal, Jagat321, Jjdawson7, 

Jluuwindsorca, John Vandenberg, KKI, Karl Stroetmann, Kauan, Maghnus, Matthew0028, Mstuomel, Nawaf.albadia, Neilc, Philip Trueman, Prodoc, Rheaghen, Ruakh, Sleske, Spoon!, Stagalj, 

Subanark, Tardis, Tbleher, Tuntable, Urhixidur, Zippanova, 73 anonymous edits 

G-java Source: http://en.wikipedia.org/w/index.php?oldid=367210806 Contributors: Blakeo x, Cynical, Elvis, Fedor GM, Frap, Fuzzie, Gm guru, IanManka, IsmAvatar, JLaTondre, John 

Vandenberg, Ketiltrout, Luiscubal, Malcolma, Markco1, Mike926908240680, OTAVIO1981, Pampas Cat, Sladen, XDanielx, 38 anonymous edits 

GlassFish Metro Source: http://en.wikipedia.org/w/index.php?oldid=368613545 Contributors: Anetode, Anthony Appleyard, Dockurt2k, Frap, Pxma, Sebleblanc, Shaun mcgrath, Tassedethe, 

UC Bill, 6 anonymous edits 

James Gosling Source: http://en.wikipedia.org/w/index.php?oldid=379579153 Contributors: Acerperi, Alainr345, Alansohn, AlistairMcMillan, Altenmann, AnOddName, Arathald, 

AutumnSnow, Avenged Eightfold, Bact, Badgernet, Bearcat, Bertport, Bhoeble, Blanchardb, Bobula101, Bondolo, Bosmon, Braiam, CDN99, CIreland, Cagecrawler, CharlotteWebb, 

Chithiraiyan, Chrislk02, Colinkem, D6, Daltenty, Dan100, Daniel, Darolew, DerHexer, Doug Bell, Ed Poor, EncMstr, EronMain, EugeneZelenko, Fieldday-sunday, FrenchIsAwesome, Ftiercel, 

Gary King, Geekler, Geni, GregorB, Gronky, Groogle, Guat6, Hholt01, Hooperbloob, Ibagli, J Milburn, J.delanoy, JamesTeterenko, Jarchitect, Jesse Viviano, John Vandenberg, Joolz, Jpbowen, 

Kaihsu, Katharineamy, LAAFan, Lamat, Luís Felipe Braga, M5mm5m, MarXidad, Martarius, Marudubshinki, Matt Crypto, Mav, Mayumashu, Michael Drew, Mirror Vax, Mre5765, Mrwojo, 

Ms2ger, Mxn, NapoliRoma, Neilc, Nolookingca, Nsaa, Per Abrahamsen, Peter Campbell, Prolog, RazorICE, RedWolf, Revence27, Rich Farmbrough, Scm83x, Section6, Seddon, Shadesofgrey, 

Shipmaster, Sionus, Snigbrook, Spinboy, Stephensuleeman, SteveSims, Stevertigo, Stolkin, Straxus, Sunray, THEN WHO WAS PHONE?, Taejo, Tanbace, The Thing That Should Not Be, 

TheParanoidOne, Tobias Bergemann, Toussaint, Traroth, Trialsanderrors, TrungH, Twimoki, Ugur Basak, UsefulDreams, Verner a, Vineetkrjoshi, Vprajkumar, Wayl, Webmink, Westpeter, 

Wikiwikiwikiwikiwiki, Woodjr, WulfTheSaxon, YUL89YYZ, 214 anonymous edits 

Gray Flimmer Source: http://en.wikipedia.org/w/index.php?oldid=331985933 Contributors: Malcolma, Rgopal, 4 anonymous edits 

Todd Greanier Source: http://en.wikipedia.org/w/index.php?oldid=368910388 Contributors: 1ForTheMoney, Alainr345, Anson2995, Bearcat, Jpbowen, Kyle1278, Oscarthecat, 4 anonymous 

edits 

Head First (book series) Source: http://en.wikipedia.org/w/index.php?oldid=338683996 Contributors: DoriSmith, Frecklefoot, Jerryobject, Kak, RayAYang, Tassedethe, 27 anonymous edits 

Jim Hugunin Source: http://en.wikipedia.org/w/index.php?oldid=368533905 Contributors: 1ForTheMoney, Alainr345, Andreas Kaufmann, Bruckie, Equarter, Hadrianheugh, Jacobolus, 

Jeodesic, Katharineamy, Sgodth, 10 anonymous edits 

Inner class Source: http://en.wikipedia.org/w/index.php?oldid=379495526 Contributors: Anwar saadat, Ashu8845, Brick Thrower, Ccarey, Daniel Brockman, Doug Bell, Green caterpillar, 

Harborsparrow, Hervegirod, Michael Slone, Mipper, Msyed, Nihiltres, Rich Farmbrough, Spoon!, Spug, Vald, Wootery, కిరణ్మయి, 21 anonymous edits 

Interface (Java) Source: http://en.wikipedia.org/w/index.php?oldid=364526965 Contributors: Agent Conundrum, Almost Anonymous, Andmatt, Anwar saadat, Cokoli, Corpx, Courcelles, 

Demitsu, Doug Bell, Dʒɑn, Ed g2s, EngineerScotty, Explanator, Fnielsen, Genpfault, Gmtress, Green caterpillar, GregorB, Hvn0413, Intgr, JaGa, Jamestochter, John Vandenberg, JonHarder, 

King of Hearts, Kulandai, Lexischemen, MER-C, Matthew0028, Mike0001, Moeron, Ordinant, Pcap, Pdelong, Petri Krohn, Phrenq, Piet Delport, Qwertyus, Radagast83, Sachinwfs, Sagaciousuk, 

Simeon, Spoon!, Telepheedian, Venkatsalem, Wigleboy, Wlievens, XDanielx, 101 anonymous edits 

Internet Foundation Classes Source: http://en.wikipedia.org/w/index.php?oldid=343164647 Contributors: DeXXus, Docu, Hervegirod, Jeepday, Marcobiscaro2112, Pegship, 5 anonymous 

edits 

JAD (JAva Decompiler) Source: http://en.wikipedia.org/w/index.php?oldid=377671774 Contributors: 2GooD, AlexWaelde, Daniel Roethlisberger, Dawynn, Green caterpillar, Ivmai77, 

Klausst, Merlin G., Midnight Comet, R'n'B, Tassedethe, Tomtheeditor, Yannick56, 20 anonymous edits 

JAD (file format) Source: http://en.wikipedia.org/w/index.php?oldid=368157547 Contributors: Amalas, Andrwsc, Bambinn, Coercorash, CyberSkull, David Haslam, Encyclopath, Excirial, 

Garas, Gurch, Jj137, JohnCD, Karsten.meier, Lauriwriter, Merbabu, Oda Mari, Patrick, Vegaswikian, Xaje, Zahakiel, 34 anonymous edits 

JAMWiki Source: http://en.wikipedia.org/w/index.php?oldid=375686267 Contributors: Audriusa, Dfisla, Ean5533, EvanProdromou, Gioto, Khartlage, Salamurai, Wrh2, 6 anonymous edits 

JGroups Source: http://en.wikipedia.org/w/index.php?oldid=297352083 Contributors: Alitokmen, John Vandenberg, Phatom87, Rigadoun, 7 anonymous edits 

JPicus Source: http://en.wikipedia.org/w/index.php?oldid=348860897 Contributors: Casablanca2000in, DanielRigal, Dv82matt, Katharineamy, Malcolma, Pavel.genevski 

Java Class Library Source: http://en.wikipedia.org/w/index.php?oldid=366545552 Contributors: Alainr345, Alansohn, Dxgriffiths, HamburgerRadio, Hervegirod, Hugh16, Phobos11, 

Romanc19s, ScottBlomquist, Tokek, Vocaro, Waldoalvarez00, 9 anonymous edits 

Java Classloader Source: http://en.wikipedia.org/w/index.php?oldid=378332996 Contributors: Aalvarez, Alainr345, Capn ed, Climbon, DenaDweller, Elpecek, GeoffMacartney, Ghettoblaster, 

Hervegirod, Isidore, Jengelh, JustAnotherJoe, Kreline, Krusch, Kwetal, MER-C, Michael Safyan, PaulRussell, Petri Krohn, Quarl, Romanc19s, Samkass, Sct72, Serpent's Choice, Timsabin, 

Urhixidur, Wikilolo, Wikimsd, Wknight94, 57 anonymous edits 

Java compiler Source: http://en.wikipedia.org/w/index.php?oldid=377671183 Contributors: Alansohn, AlonzoChurch, Caltas, CanisRufus, CesarB, Derek farn, Dogaroon, Doug Bell, Furrykef, 

HereToHelp, Hervegirod, Ike-bana, Joel12321ps, LittleDan, Oleg Alexandrov, Orderud, Pdwalker, Psycosonik222842, Quadell, Radagast83, Shanes, Spectre 25gt, TakuyaMurata, Thumperward, 

Tide rolls, Tomtheeditor, Tribaal, Tripleyew, Tvarnoe, 36 anonymous edits 

Java Development Kit Source: http://en.wikipedia.org/w/index.php?oldid=373992477 Contributors: Akendall, Alainr345, Alexey Izbyshev, Anantshayan, Apavlo, Bluemoose, Caowm, Centrx, 

Chochopk, Ctmt, DarkFalls, Dbabbitt, DeegC, Deineka, Dongiulio, Doug Bell, Easyas12c, Echawkes, Edknol, Elg fr, Epbr123, Feureau, Frap, Ftiercel, General Wesc, Graham87, Gronky, 

GrooveDog, Hervegirod, IOLJeff, Ike-bana, Improv, Isilanes, Itai, JLaTondre, JVz, John Vandenberg, JorgePeixoto, Kkm010, Kl4m-AWB, L daruwala, MIT Trekkie, Mark Renier, Melnakeeb, 

Michal.pise, Mmddyyyy, Mysdaao, Naradawickramage, Nixeagle, Nwbeeson, Octahedron80, Opticyclic, Philip Trueman, Plinkit, Ppntori, Qiq, RandomProcess, Rettetast, RossPatterson, Salsb, 

Saxifrage, Sfmontyo, Smyth, Softwaresavant, Soimort, Spoon!, Stefan h, Stephan Leeds, Swarm, TimTay, Toussaint, Valodzka, Vlad, Webmink, Wellithy, Winterst, WissensDürster, 

YUL89YYZ, Ylai, Yurikoles, 83 anonymous edits 

Java Interface Definition Language Source: http://en.wikipedia.org/w/index.php?oldid=354441014 Contributors: Alainr345, ChrisHibbert, Pammann, Shalom Yechiel, Sloman, 2 anonymous 

edits 

Java resource bundle Source: http://en.wikipedia.org/w/index.php?oldid=321826780 Contributors: Alansohn, J. Finkelstein, JLaTondre, Padrecamara, Rror, 3 anonymous edits 

Java TV Source: http://en.wikipedia.org/w/index.php?oldid=367075768 Contributors: Amareto2, IMSoP, Jandockx, Kathleen.wright5, Shalom Yechiel, Surachit, Tothebarricades.tk, 

WOSlinker, 6 anonymous edits 

Java Work Framework Source: http://en.wikipedia.org/w/index.php?oldid=328511613 Contributors: J04n, JLaTondre, Kosta.mosta, LilHelpa, Rror, Tassedethe, Tedickey 

Java annotation Source: http://en.wikipedia.org/w/index.php?oldid=372015952 Contributors: Abdull, Alelinuxbsd, Cafewalter, Cyde, Delirium, Dmccreary, Fatespeaks, Fred Bradstadt, 

JLaTondre, Jimmyzimms, Jwkpiano1, Kanonkas, Kesla, Nailbiter, Netizen, Ogai, Onjacktallcuca, Qutezuce, Sikon, Stagalj, Tchite, Techi2ee, Thumperward, Tyraios, W3bbo, 51 anonymous edits


Java collections framework Source: http://en.wikipedia.org/w/index.php?oldid=375536927 Contributors: Alainr345, Chrisahn, Chronodm, D, DenisKrivosheev, Eraserhead1, Explanator, 

Jespdj, Kamalraja, LINK3, Ohnoitsjamie, Prodoc, Qutezuce, Tassedethe, Toyota Dream House, Wikilolo, Wlievens, Wrp103, 10 anonymous edits 

Java concurrency Source: http://en.wikipedia.org/w/index.php?oldid=374383735 Contributors: Abortz, Alvin-cs, Anwar saadat, Black Pepper, Chowbok, JonHarder, M4gnum0n, 

Mati22081979, Veinor, Vonfraginoff, 8 anonymous edits 

Java syntax Source: http://en.wikipedia.org/w/index.php?oldid=378326840 Contributors: 16@r, Ahoerstemeier, Alainr345, Alexwright, AnOddName, Ash211, Aspects, Avenged Eightfold, 

AverageAmerican, AxelBoldt, Axlape, Barticus88, Benjiboi, Bigbluefish, Cairnarvon, CaptainVindaloo, Ceyockey, Chip Zero, Creidieki, D6, Dmyersturnbull, Doug Bell, Dvd Avins, Ed Poor, 

Edward, Excirial, Flash200, FreplySpang, Ftiercel, Gaius Cornelius, Geeman, Gilgamesh, Gortsack, Gracenotes, Hagerman, Hervegirod, HotXRock, Ikip, Jnc, Joe Schmedley, John of Reading, 

Jorge Stolfi, Karlzt, Kelly Martin, Ketiltrout, Kgwikipedian, Killy mcgee, King Mir, Leafyplant, LilHelpa, Lph, MBisanz, Maokart444, MarkSweep, Marvinscj, Max Schwarz, Maxwell Gerald 

Anderson, Mike.lifeguard, Montgomery '39, Mzanime, Neilc, Oysterguitarist, Princess Lirin, Quoth, Quuxplusone, RCX, RealBadApple, Remember the dot, Renesis, Ruud Koot, Salsia, Snowolf, 

Snowysquirrels, Someguy1221, SpaceLem, Sparky132, TakuyaMurata, Thumperward, Tobias Bergemann, Toussaint, Uncle G, Vihangvk, Wikimsd, Wiremore, Wtshymanski, ZeroOne, 148 


Java: View Technologies and Frameworks Source: http://en.wikipedia.org/w/index.php?oldid=366545291 Contributors: Fabrictramp, JonasMeinertz, Katharineamy, Matt5091, Mlavannis, 

Vendeka, Woohookitty, 7 anonymous edits 

JavaBeans Activation Framework Source: http://en.wikipedia.org/w/index.php?oldid=372079143 Contributors: NoNonsenseHumJock, Pammann, Shalom Yechiel, Stormbay, 1 anonymous 

edits 

JavaThreads Source: http://en.wikipedia.org/w/index.php?oldid=367334786 Contributors: 1ForTheMoney, Adimovk5, Andreas Kaufmann, Avalon, Fabrictramp, Katharineamy, Myjavaguru, 5 


javac Source: http://en.wikipedia.org/w/index.php?oldid=366877635 Contributors: Alansohn, Anwar saadat, Da rulz07, Frap, Hervegirod, Hgfernan, Ike-bana, Jonabbey, Oleg Alexandrov, 

Osndok, Ralmin, Spoon!, TakuyaMurata, Tkircher, 16 anonymous edits 

JavaFX Source: http://en.wikipedia.org/w/index.php?oldid=376249800 Contributors: AKA MBG, Alainr345, Anatolnsk, Arichnad, Arindamb, BenAveling, BlastStu, CapitalR, CardinalDan, 

Chase me ladies, I'm the Cavalry, Chekristo, Chowbok, Coty, Creek23, Cwlq, CyberSkull, Damiens.rf, Daniel newton, Darkfrog26, Deineka, Dotfx, DreamGuy, Dunkinacha, Faisal.akeel, 

Felixschrape, Ghettoblaster, GosiaCh, Gpvos, Grshiplett, HenryMinsky, Hervegirod, Hnarayanan, JavaKid, Jeshan, Jlweaver, Kinema, Kks krishna, Lkt1126, Local contributor, M1chu, 

M4gnum0n, Martarius, Mathiastck, Mugunth Kumar, Nabbia, Naku, Nurg, OssDev, Pqd, Publicly Visible, QBK2006, Raysonho, Rjwilmsi, Ronz, SaltyDawg, SamJohnston, Samdutton, Sherb, 

Shiki2, Simogasp, Sipoyraj, Sleske, Soumyasch, Surikov, Swarm, Tassedethe, Thumperward, Tokek, Toussaint, Van der Hoorn, Woodenfox, Wootery, Wwwwolf, ZZyXx, 115 anonymous edits 

Jawin Source: http://en.wikipedia.org/w/index.php?oldid=332020757 Contributors: MER-C, MZimmer, Pvss, Samir, Shalom Yechiel, Warren, 1 anonymous edits 

JExamples Source: http://en.wikipedia.org/w/index.php?oldid=380060395 Contributors: Alainr345, Andreas Kaufmann, Cwebster93, Eakle, Gennaro Prota, JLaTondre, Jonomacdrones, 

Kenb215, Midoladido, Nathan, RainbowCrane, Ronz, Tim1357, 8 anonymous edits 

Jfig Source: http://en.wikipedia.org/w/index.php?oldid=306624227 Contributors: Alpta, Benjaminevans82, Colonies Chris, EdGl, Hamitr, John Vandenberg, Kasjanek21, LQST, Rjsc, 5 


Jikes Source: http://en.wikipedia.org/w/index.php?oldid=366621186 Contributors: Chip Zero, Chruck, Delirium, Den fjättrade ankan, Doug Bell, Faisal.akeel, Fleminra, Frap, Greenrd, Greudin, 

Gronky, Grutness, Hervegirod, Interiot, Isilanes, Jarekadam, Kl4m-AWB, KnightRider, Lost-theory, Lumingz, Myork, Netizen, Segin, TakuyaMurata, Tedder, Thedaveshields, Wootery, Zil, 21 


jnSynch Source: http://en.wikipedia.org/w/index.php?oldid=333423646 Contributors: Janunezc, Kasjanek21, S. Ugarte, Uncle G, 2 anonymous edits 

Michael Kölling Source: http://en.wikipedia.org/w/index.php?oldid=365995556 Contributors: Artie p, DiablosDevil, Drbreznjev, Ed Fitzgerald, Gaius Cornelius, Garik, Gene Nygaard, JTA, 

JimVC3, John Vandenberg, John254, KarlFrei, Kraftlos, Lame Name, Lubiann, Possum, Rainalee au, Sky HIgh, Stephenchou0722, Timrollpickering, Tony Hunter, Utgard Loki, 27 anonymous 

edits 

List of Java keywords Source: http://en.wikipedia.org/w/index.php?oldid=376075258 Contributors: 16@r, Altenmann, Anwar saadat, Cheung1303, Chowbok, Creek23, Cybercobra, Doug 

Bell, Drae, DropDeadGorgias, Fx2, Gaius Cornelius, Green caterpillar, Henning Makholm, Jay, Jayzed882, Jinxed, KathrynLybarger, Kbdesai, Kusunose, M3tainfo, MarkSweep, Matt73, 

Muchness, Mzanime, Programming gecko, RCX, Rsrikanth05, Selket, Smyth, Spoon!, Thumperward, Tothwolf, Twi20Pi, Zhmort, Zwirello, 40 anonymous edits 

Marker interface pattern Source: http://en.wikipedia.org/w/index.php?oldid=352209532 Contributors: Ashutosh.shukla, Doug Bell, EALacey, Elf, Erechtheus, Jay, Jogloran, Jpp, Julesd, 

KevinTeague, MoraSique, NickBush24, OpenFuture, Piano non troppo, PolyGlot, Quagmire, RedWolf, SAE1962, Texture, Timwi, 26 anonymous edits 

Name mangling Source: http://en.wikipedia.org/w/index.php?oldid=376816035 Contributors: 16@r, AKGhetto, Abdull, Agnerf, AlistairMcMillan, Andreas Kaufmann, BB-Froggy, Benhoyt, 

Blaxthos, Bluetulip, Bovineone, BrokenBeta, Bvanderveen, Chmod007, Curps, DancingMan, Darkwind, David.Monniaux, DmitTrix, Doug Bell, Dysprosia, Eelis.net, Efa, Finlay McWalter, 

Fplay, Fredrik, Fresheneesz, Fumblebruschi, Gadfium, Gerbrant, Ghettoblaster, Itsme, Jalanpalmer, Jerryobject, Jesin, Jsmethers, Kate, Liangent, Marudubshinki, Matthew V Ball, Medinoc, 

Mirror Vax, Mr1278, Nimur, Orderud, PdDemeter, Percy Snoodle, Petri Krohn, Phatom87, Pinzo, Quuxplusone, Rich Farmbrough, Sam Hocevar, Solipsist, Stevenj, Strimo, Suruena, 

TakuyaMurata, Tausif.ik, Tedjn, TerraNova whatcanidotomakethisnottoosimilartosomeothername, Thecabinet, Thegeneralguy, TimBentley, VeryVeryTired, Wykypydya, Xezbeth, 63 anonymous 

edits 

Patrick Naughton Source: http://en.wikipedia.org/w/index.php?oldid=379356040 Contributors: 1ForTheMoney, Colonies Chris, Hervegirod, Jpbowen, Martarius, Merovingian, 

Moonriddengirl, MrStalker, 3 anonymous edits 

New I/O Source: http://en.wikipedia.org/w/index.php?oldid=379224036 Contributors: Aleksander Zawitkowski, Andyengle, Bluemoose, Bobo192, DJ Creature, DanielPitts, Doug Bell, 

Dthomsen8, Hervegirod, Julesd, KenFehling, Meonkeys, Noisy, Outlyer, Peter Grey, Plasticup, TakuyaMurata, Thegeneralguy, Tobias Bergemann, Uncopy, Urhixidur, Wragge, 38 anonymous 

edits 

Object type (object-oriented programming) Source: http://en.wikipedia.org/w/index.php?oldid=378790181 Contributors: Aj045, BenAveling, Brewthatistrue, Capricorn42, Chanlyn, 

ChanningWalton, Davidfstr, Doug Bell, Ed Poor, Egriffin, FlyHigh, Garyzx, Haakon, Jeff3000, Matt Crypto, Medinoc, Nuggetboy, Orderud, Pcap, R. S. Shaw, RJFJR, Rich Farmbrough, 

RockMFR, Rtistique, TakuyaMurata, Tobych, Workingonmygooglefu, Xaonon, 31 anonymous edits 

Omniscient Debugger Source: http://en.wikipedia.org/w/index.php?oldid=299648988 Contributors: Geni, John Vandenberg, Unforgettableid, Witchinghour, 1 anonymous edits 

OpenJDK Source: http://en.wikipedia.org/w/index.php?oldid=379455981 Contributors: 16@r, A.Lingo, Alainr345, Arifsaha, Audriusa, Bratch, Chealer, Choij, DStoykov, Dmyersturnbull, 

Dridus, Earthsound, EatMyShortz, Eugene Volchek, Euphoria, Flash200, Frap, Free Software Knight, Ghalas, Gnu andrew, Guyjohnston, Hervegirod, Jcarroll, Jimthing, Jm307, Lkt1126, 

LodeRunner, Mathiastck, Melnakeeb, Mranderson2008, Nabbia, NeMeSiS, Neustradamus, Phobos11, Pixel-fodder, Ramalho, Rjwilmsi, SF007, Specious, Stinerman, Theoneintraining, Tokek, 

Trasz, Two Bananas, WouterdeGroot, Wwwwolf, Yworo, ZeroOne, 63 anonymous edits 

PHP/Java Bridge Source: http://en.wikipedia.org/w/index.php?oldid=343363652 Contributors: AntPhillips, Etphonehome, Intgr, JLaTondre, JaGa, Methmann, MuffledThud, Steve carlson, 4 


Java package Source: http://en.wikipedia.org/w/index.php?oldid=363502245 Contributors: Akhristov, Alex43223, Anwar saadat, Blueharmony, Christan80, Clemens vi, Doug Bell, Dreadstar, 

Ed Poor, GeeJo, Grendelkhan, Henning Makholm, Hervegirod, ItsProgrammable, Jaxad0127, Jonik, Karl Dickman, LahiriB, Mandolinface, Markkauffman2000, Mbarbier, Mcorazao, Mentifisto, 

Mike Rosoft, Miko3k, Paramlaghane, Pearle, Pjvpjv, RedWolf, Ruchira37, Shadanan, Simeon, SonniWP, Vy0123, Willmtz, 40 anonymous edits 

Parboiled (Java) Source: http://en.wikipedia.org/w/index.php?oldid=367958629 Contributors: Ash, Elwikipedista, Rich Farmbrough, Sirthias, Tedickey 

Plain Old Java Object Source: http://en.wikipedia.org/w/index.php?oldid=366362072 Contributors: Adzinok, Alainr345, Alesj, Bachrach44, Bart Carny, Bertport, Besem, Bruguiea, 

Chillmann, China Crisis, Chronist, Coleopterous, DasAlbatross, Donsez, Dthomsen8, Ed Poor, Emmanuel.keller, Epbernard, Fred Bradstadt, Gracenotes, Graham87, Haakon, IWikediana, 

Iridescent, Jay, Johnny Kewl, Jpp, Kennardconsulting, Keylay31, Lunacrescens, MLRoach, Magioladitis, Mild Bill Hiccup, Mumia-w-18, Nburden, OlavN, Plugwash, Plumpurple, Raul Lapeira, 

Rbonvall, Rdvdijk, Rpawson, Sspecter, Stevage, WikiFan04, Zoquero, 99 anonymous edits


Pluggable look and feel Source: http://en.wikipedia.org/w/index.php?oldid=330618711 Contributors: Barnacles phd, Doczilla, Hervegirod, Julesd, Michael miceli, Pegship, RedWolf, Rjwilmsi, 

3 anonymous edits 

Primitive wrapper class Source: http://en.wikipedia.org/w/index.php?oldid=336364034 Contributors: Bovineone, Chip Zero, Doug Bell, Ed Poor, Ekamaloff, Hervegirod, John Vandenberg, 

Mareeswaran.m, Matthew0028, Naohiro19, Quilokos, Tobias Bergemann, Vedant lath, Wimt, 19 anonymous edits 

Project Semplice Source: http://en.wikipedia.org/w/index.php?oldid=354488754 Contributors: Cmdrjameson, Creek23, Greenrd, RTucker, 3 anonymous edits 

Quark Framework Source: http://en.wikipedia.org/w/index.php?oldid=370974561 Contributors: Btyner, CRGreathouse, ConalElliott, Gcom, Inferno, Iridescent, IvanAndreevich, Luke.evans, 

R'n'B, René Vincent Jansen, Tabletop, Tassedethe, Thumperward, 5 anonymous edits 

REPLAY (software) Source: http://en.wikipedia.org/w/index.php?oldid=361237690 Contributors: James R. Ward, LilHelpa, NJA, Oas777, SoWhy, Stuartyeates, 3 anonymous edits 

Real time Java Source: http://en.wikipedia.org/w/index.php?oldid=373239585 Contributors: Abdull, Buntfalke, CanisRufus, Dautelle, Dcoetzee, Donsez, Dusclaux, FlyHigh, Fultonm, 

Jamesjhunt, Jm307, John Gorn, Jsmethers, LaurentMeilleur, NapoliRoma, On5deu, Paddles, Pearle, Radagast83, RasputinAXP, Rror, Schoeberl, Skyemoor, Stemonitis, Tarret, Vörös, 31 


Resource (Java) Source: http://en.wikipedia.org/w/index.php?oldid=329573963 Contributors: Debresser, Fasten, JerroldProthero, John Vandenberg, Shyam, 2 anonymous edits 

Restlet Source: http://en.wikipedia.org/w/index.php?oldid=378167831 Contributors: Alainr345, Avi4now, JLaTondre, Malcolma, Robheittman, 14 anonymous edits 

Retrotranslator Source: http://en.wikipedia.org/w/index.php?oldid=332489708 Contributors: Davidedelvento, Fredrick Night, Hervegirod, 1 anonymous edits 

SLAMD Source: http://en.wikipedia.org/w/index.php?oldid=300258495 Contributors: Benfred, Blaxthos, C777, EagleOne, Ff1959, JLaTondre, NapoliRoma, Sshoaff 

SLAMD Server Source: http://en.wikipedia.org/w/index.php?oldid=302640824 Contributors: Dino, Ff1959, J04n 

SLF4J Source: http://en.wikipedia.org/w/index.php?oldid=373825379 Contributors: Ashik, Bostonvaulter, Cgulcu, M4gnum0n, Malcolmxl5, RickBeton, SzpakEng, Tassedethe, Tedickey, 

Tedyu002, 9 anonymous edits 

Bruno Souza Source: http://en.wikipedia.org/w/index.php?oldid=372286903 Contributors: Damiens.rf, Jpbowen, Kitudo, Mwalder, Rich Farmbrough, Vmeruck, 2 anonymous edits 

Static import Source: http://en.wikipedia.org/w/index.php?oldid=379160043 Contributors: Melchoir, Omahaprogrammer, 2 anonymous edits 

StormMQ Source: http://en.wikipedia.org/w/index.php?oldid=370843656 Contributors: Ranjithsutari, Raphcohn 

strictfp Source: http://en.wikipedia.org/w/index.php?oldid=367892479 Contributors: Atomota, Dddenton, Dmyersturnbull, Doug Bell, Enochlau, Faisal.akeel, Glasser, Iamnitin, JSMoller, 

Jackzhp, Mipadi, Rich Farmbrough, Thryduulf, 22 anonymous edits 

String Buffer Source: http://en.wikipedia.org/w/index.php?oldid=373917932 Contributors: Acdx, Alainr345, Andmatt, Evaders99, Joshporter, Malcolma, Michael Hardy, Rjwilmsi, RockMFR, 

TakuyaMurata, Vald, Voice of All, Wwwwolf, 8 anonymous edits 

Sun Web Developer Pack Source: http://en.wikipedia.org/w/index.php?oldid=336745405 Contributors: Alainr345, Ijevans, Rjwilmsi, 3 anonymous edits 

Swing (Java) Source: http://en.wikipedia.org/w/index.php?oldid=377420554 Contributors: ALFP, Abhinav.rajsingh, AnOddName, Anna Lincoln, Appraiser, Audriusa, Avitaltr, Bewildebeast, 

Blackbyrus, Bobgerac, BrianDuff, CAkira, CannotResolveSymbol, ChKa, Coconut99 99, Crosstimer, Darrien, Dave Messina, Davetron5000, Denizstij, Dgrant, Doug Bell, Dugwiki, Dxgriffiths, 

ESkog, EatMyShortz, Echawkes, Eghbali, Elf, Explanator, Faisal.akeel, Feezo, Furrykef, Garoad, Gobias industries inc, Harry Wood, Hem1234, Hervegirod, Hu12, Iamthenew!!, Ike-bana, 

Invalidname, Isnow, Jacek79, JackieBird, Jarsyl, Jaydeki, Jeshan, Jfrascencio, Jjaazz, Johnflan, Jokes Free4Me, JonHarder, Juancnuno, Justin W Smith, Kauczuk, Laterality, MC10, MIT Trekkie, 

MaNeMeBasat, Maxim.zakharenkov, Meegs, Michalis Famelis, Mikeshk, MinorContributor, Mjparme, Mucus, Mygerardromance, Ocatecir, Ojigiri, Peruvianllama, Plustgarten, Pmsyyz, Poccil, 

Prodoc, Prolog, Rafael.afonso, RedWolf, Rich Farmbrough, Rjwilmsi, Rockear, Rodhullandemu, Romanc19s, Rubicon, SJP, Saintamh, Salix alba, Sam Korn, Sebastian.Dietrich, Shinmawa, 

Sikon, Simonjl, SkiBumMSP, Spasemunki, Squiggleslash, Stacrd, Stolsvik, Tarquin, Thatfunkymunki, The wub, Themusicgod1, Thumperward, Toussaint, Traroth, Vnsd, Weichbrodt, Wellithy, 

Wootery, WreckLoose, 230 anonymous edits 

SwingLabs Source: http://en.wikipedia.org/w/index.php?oldid=364207864 Contributors: Alainr345, Hervegirod 

Synth Look and Feel Source: http://en.wikipedia.org/w/index.php?oldid=371233438 Contributors: Ghettoblaster, Hervegirod, Pegship, Powerlord, 6 anonymous edits 

TeachScheme! Source: http://en.wikipedia.org/w/index.php?oldid=369013022 Contributors: Cat Parade, Chriscorv4, Clements, Ilmari Karonen, Instinct, JLaTondre, JonHarder, Lexein, 

Matthias.f, Woohookitty, 23 anonymous edits 

The Java Posse Source: http://en.wikipedia.org/w/index.php?oldid=370922550 Contributors: Betacommand, Blue520, Doug Bell, FunHappySprinkles, Grstain, Gwern, Invalidname, JavaKid, 

Jlandin, Kenb215, MarsRover, Matt Crypto, Muzzamo, Shalom Yechiel, Vjosullivan, Wwiktorr, 16 anonymous edits 

Unified Expression Language Source: http://en.wikipedia.org/w/index.php?oldid=317810356 Contributors: Hannabee, Jérôme, Madalino, Pinanti, Weggie, 4 anonymous edits 

Java Virtual Machine Source: http://en.wikipedia.org/w/index.php?oldid=379985491 Contributors: @modi, A3csc300, AWendt, Aavviof, Abarnea 2000, Abu badali, Ahoerstemeier, 

Alainr345, Aldie, Alifakoor, Alphachimp, Alphax, AnOddName, Andre Engels, Angitha.t, Anwar saadat, Arrenlex, Atramos, Axlq, Bawolff, BeauPaisley, Blue Em, Boing! said Zebedee, Bryan 

Derksen, Burschik, CALR, Cactus.man, Calm, Chrismear, ClashTheBunny, Classicalecon, CodeMonk, Congruence, Conversion script, CyberSkull, Cyp, Dalvizu, Damian Yerrick, Danhicks, 

DataWraith, Dave Cohoe, David Gerard, DavidCary, Dbabbitt, Debackerl, Dejvid, Delirium, Derek farn, Dnstest, Doradus, Doug Bell, DougsTech, Dreish, Ds13, EatMyShortz, Epbr123, Frap, 

Fromageestciel, Furrykef, Gazpacho, Ghettoblaster, Gtoal, Gwernol, Haakon, Hairy Dude, Happysailor, Harborsparrow, Harp, Hdante, Headius, Hervegirod, Hfastedge, Hirzel, Hu12, Iane, 

Igoldste, Intgr, J E Bailey, JWB, Jabman, JacobBramley, Jason.grossman, Jim88Argentina, Jj137, Joaopaulo1511, Joehni, John of Reading, JokerXtreme, Jondel, Karl Dickman, Khalid hassani, 

Kishonti, Kks krishna, Krishan.sunbeam, Kuasha, Kungfuadam, Lee J Haywood, Liberty Miller, Livy the pixie, Lumingz, Ma8thew, Mariolina, Mav, Mboverload, Mfc, Miko3k, Mjscud, 

Moa3333, Modster, Moppet65535, Napi, Neilc, Nemti, Ng.j, Nickg, NoIdeaNick, Nuno Tavares, Oleg Alexandrov, Ortolan88, Paul Foxworthy, Pegasus1138, Phyzome, Plasticup, Poccil, 

Quaysea, Rakesh.usenet, Randolf Richardson, Raven4x4x, RedWolf, Rich Farmbrough, Rursus, SAE1962, SF007, SJP, Sander123, Schoeberl, Shadowjams, Sixth Estate, Slamb, Smarkflea, 

Smjg, Smyth, Square87, Stephen B Streater, Stw, Tagus, Takis, TakuyaMurata, The Anome, Thumperward, TimTay, TittoAssini, ToddFincannon, Toussaint, Tyomitch, UU, Underpants, 

Unsungzeros, VasilievVV, Versus22, Vicarious, Vinny, VladimirReshetnikov, Vy0123, Weregerbil, Whiner01, Whispering, Wikicrusader, Woohookitty, Wootery, Wrelwser43, Xevious, Yar2, 

Yozh, 258 anonymous edits 

Xerlin Source: http://en.wikipedia.org/w/index.php?oldid=367971010 Contributors: Beeblebrox, Elwikipedista, Iamthenewno2, Koavf, Ron Ritzman, Tassedethe, Tothwolf, WikiLaurent, 2 


XStream Source: http://en.wikipedia.org/w/index.php?oldid=367972218 Contributors: Alansohn, Andreas Kaufmann, Bryan Derksen, Den fjättrade ankan, DrHok, Elwikipedista, Fedor, 

Gronky, Haschuur, Isilanes, John Vandenberg, Kl4m-AWB, Laserprinter, M4gnum0n, Melab-1, Pegship, Rich Farmbrough, Rror, SmackEater, Xmlizer, 5 anonymous edits

Image Sources, Licenses and Contributors 313 

Image Sources, Licenses and Contributors 

File:Java logo.svg Source: http://en.wikipedia.org/w/index.php?title=File:Java_logo.svg License: unknown Contributors: Eastmain, MBisanz, Sophus Bie, The wub, TimTay, Tkgd2007, 

Webmink, 2 anonymous edits 

File:Wikibooks-logo-en.svg Source: http://en.wikipedia.org/w/index.php?title=File:Wikibooks-logo-en.svg License: logo Contributors: User:Bastique, User:Ramac 

File:Wave.svg Source: http://en.wikipedia.org/w/index.php?title=File:Wave.svg License: unknown Contributors: sbmehta converted to SVG from Sun Microsystems AI version. 

Image:JavaPlatform.png Source: http://en.wikipedia.org/w/index.php?title=File:JavaPlatform.png License: unknown Contributors: Sun Microsystems, Inc. 

Image:Wave.svg Source: http://en.wikipedia.org/w/index.php?title=File:Wave.svg License: unknown Contributors: sbmehta converted to SVG from Sun Microsystems AI version. 

Image:Agentsheets IDE.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Agentsheets_IDE.jpg License: Public Domain Contributors: User:Dragentsheets 

Image:AS-projects.jpg Source: http://en.wikipedia.org/w/index.php?title=File:AS-projects.jpg License: Public Domain Contributors: Dragentsheets 

File:Java applet.png Source: http://en.wikipedia.org/w/index.php?title=File:Java_applet.png License: Public Domain Contributors: User:Audriusa 

File:OpenAstexViewer.jpg Source: http://en.wikipedia.org/w/index.php?title=File:OpenAstexViewer.jpg License: GNU Lesser General Public License Contributors: Original uploader was 

Audriusa at en.wikipedia 

File:Cardiac cells applet.png Source: http://en.wikipedia.org/w/index.php?title=File:Cardiac_cells_applet.png License: GNU General Public License Contributors: Elizabeth Cherry and Flavio 

Fenton (see ) 

File:Mandelbrot java applet.png Source: http://en.wikipedia.org/w/index.php?title=File:Mandelbrot_java_applet.png License: GNU General Public License Contributors: Original uploader 

was Audriusa at en.wikipedia 

File:ChessApplet.png Source: http://en.wikipedia.org/w/index.php?title=File:ChessApplet.png License: BSD Contributors: Original uploader was Audriusa at en.wikipedia 

File:NASA World Wind.jpg Source: http://en.wikipedia.org/w/index.php?title=File:NASA_World_Wind.jpg License: unknown Contributors: Deadstar, WikipediaMaster 

File:Remoteconsoleapplet.png Source: http://en.wikipedia.org/w/index.php?title=File:Remoteconsoleapplet.png License: unknown Contributors: Audriusa 

Image:Aujac logo oficial.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Aujac_logo_oficial.jpg License: Creative Commons Attribution 3.0 Contributors: User:Jordi.pujol.ulied 

Image:Logo jjc 2003.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Logo_jjc_2003.jpg License: Creative Commons Attribution 3.0 Contributors: User:Jordi.pujol.ulied 

Image:Inauguracio.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Inauguracio.jpg License: Creative Commons Attribution 3.0 Contributors: User:Jordi.pujol.ulied. 

Image:Aujac cartell jjc2004.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Aujac_cartell_jjc2004.jpg License: Creative Commons Attribution 3.0 Contributors: 

User:Jordi.pujol.ulied 

Image:Aujac cartell jjc2005.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Aujac_cartell_jjc2005.jpg License: Attribution Contributors: User:Jordi.pujol.ulied 

Image:Aujac sun tech day sabadell.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Aujac_sun_tech_day_sabadell.jpg License: Creative Commons Attribution 3.0 Contributors: 

User:Jordi.pujol.ulied 

Image:Aujac soci honor 2003 jordi roig.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Aujac_soci_honor_2003_jordi_roig.jpg License: Creative Commons Attribution 3.0 

Contributors: User:Jordi.pujol.ulied 

Image:Aujac soci honor 2004 eduard elias.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Aujac_soci_honor_2004_eduard_elias.jpg License: Creative Commons Attribution 3.0 

Contributors: User:Jordi.pujol.ulied 

Image:javapolis1.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Javapolis1.jpg License: Creative Commons Attribution-Sharealike 2.5 Contributors: Sjabejug 

Image:javapolis2.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Javapolis2.jpg License: Creative Commons Attribution-Sharealike 2.5 Contributors: Sjabejug 

File:James_Gosling_2008.jpg Source: http://en.wikipedia.org/w/index.php?title=File:James_Gosling_2008.jpg License: Attribution Contributors: User:Peter Campbell 

Image:Java logo.svg Source: http://en.wikipedia.org/w/index.php?title=File:Java_logo.svg License: unknown Contributors: Eastmain, MBisanz, Sophus Bie, The wub, TimTay, Tkgd2007, 

Webmink, 2 anonymous edits 

Image:Java keywords highlighted.png Source: http://en.wikipedia.org/w/index.php?title=File:Java_keywords_highlighted.png License: Creative Commons Attribution-Sharealike 3.0 

Contributors: User:Programming gecko 

Image:JavaFX logo.jpg Source: http://en.wikipedia.org/w/index.php?title=File:JavaFX_logo.jpg License: unknown Contributors: GosiaCh, Salavat, Ysangkok 

Image:CALlogo3D.png Source: http://en.wikipedia.org/w/index.php?title=File:CALlogo3D.png License: Public Domain Contributors: Luke.evans 

File:Bruno_Souza.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Bruno_Souza.jpg License: Public Domain Contributors: Damiens.rf, Kitudo 

Image:Gui-widgets.png Source: http://en.wikipedia.org/w/index.php?title=File:Gui-widgets.png License: GNU General Public License Contributors: Alex.ryazantsev, Faxe, Sven, Theoteryi, 

Wutsje, 3 anonymous edits 

File:AWTSwingClassHierarchy.png Source: http://en.wikipedia.org/w/index.php?title=File:AWTSwingClassHierarchy.png License: Public Domain Contributors: Jakub Závěrka 

Image:Java-posse.jpg Source: http://en.wikipedia.org/w/index.php?title=File:Java-posse.jpg License: Creative Commons Attribution 2.0 Contributors: 

http://www.flickr.com/photos/joenuxoll/315005590/

License 314 

License 

Creative Commons Attribution-Share Alike 3.0 Unported 

http:/ / creativecommons. org/ licenses/ by-sa/ 3. 0/

Contents - Cultural View

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?