Programming languages for the Java Virtual Machine JVM

The JMatch language extends Java with support for abstract iterable pattern matching: a mechanism for pattern matching that is compatible with the data abstraction features of Java and also makes iteration abstractions convenient to use and to implement. JMatch provides abstract pattern matching; patterns are not tied to algebraic data constructors as in ML. A single JMatch method may be used in several modes that may share a common implementation as a boolean formula. JMatch provides modal abstraction that simplifies the specification and implementation of abstract data types. JMatch also makes the specification, implementation, and use of iteration abstractions convenient, by automatically finding multiple solutions to a formula or pattern.

Jam is an extension of the Java language supporting mixins, that is parametric heir classes. A mixin declaration in Jam is similar to a Java heir class declaration, apart that it does not extend a fixed parent class, but simply specifies the set of fields and methods a generic parent should provide. In this way, the same mixin can be instantiated on many parent classes, producing different heirs, thus avoiding code duplication and largely improving modularity and reuse.

Kanaputs is an interpreter for Java. With Kanaputs you can use Java as an interpreted language: no more compilation, each instruction is executed when you write it. Kanaputs allows to create Java objects and call methods on them. The grammar of the Kanaputs language is very close to the Java grammar. One big difference is that any variable handled by Kanaputs is type-less. There is no variable declaration nor type casting needed. Depending on the variable value, and where it is used, Kanaputs chooses the best internal Java basic type and tries the most appropriate type castings. When a variable handles a Java object, its type is the class of the Java object. Another key feature of Kanaputs is the reactivity. If the variable ‘c’ was defined like this c = a + b; and if the reactivity of ‘c’ is set (c.reactive = true;), each time the value of ‘a’ or ‘b’ changes then the value of ‘c’ is updated as the result of the addition.

Join Java is creating a superset of the Java language which is built on a process algebra, the join calculus. It provides the following features that are either absent or poorly supported in Java: * Asynchronous calls * Message passing * A real inheritance for concurrency in Object Oriented programming Separating of concurrency from synchronization using abstraction Rigorous linkage with formal methods including join calculus, Petri nets and statecharts

Janino is a compiler that reads a JavaTM expression, block, class body, source file or a set of source files, and generates JavaTM bytecode that is loaded and executed directly.

ObjectTeams is a light extension to Java that provides support for advanced modularization. Role based programming provides the means to separate concerns, while features of aspect orientation provide a powerful adaptation/extension facility. An OpenSource, Eclipse-based IDE (currently based on Eclipse 3.2) supports designing, editing, refactoring, compiling, executing and debugging. Object Teams programs run on a standard Java VM.

Polyglot is a highly extensible compiler front end for the Java programming language. It is implemented as a Java class framework using design patterns to promote extensibility. Using Polyglot, language extensions can be implemented without duplicating code from the framework itself. Polyglot has been used to implement domain-specific languages, to explore language design ideas, to simplify Java for pedagogical purposes, and for various code transformations such as optimization and fault injection.

J& (pronounced “jet”) is an extension of Java that increases code extensibility and reuse using nested inheritance. Nested inheritance supports inheritance of packages and classes while allowing classes nested within to be overridden.