This Java 6 compatible Java Runtime Environment is based on OpenJDK 6
and IcedTea 6.

It contains a Java virtual machine, runtime class libraries, and an
Java application launcher that are necessary to run programs written in
the Java progamming language. It is not a development environment and
does not contain development tools such as compilers and debuggers. For
development tools, see the java-1_6_0-openjdk-devel package.

The Java 6 Runtime Environment is intended for software developers and
vendors who wish to redistribute their applications.

Linux beats them ALL! While all other OS's are TALKING about direct
support of Java Binaries in the OS, Linux is doing it!

You can execute Java applications and Java Applets just like any other
program after you have installed this package.

java-cup is a LALR Parser Generator in Java. With v0.11, you can: *
use CUP in an Ant-Target

* start CUP by a simple command like java -jar java-cup-11a.jar
myGrammar.cup

* use generic parametrized classes (since Java 1.5) as datatypes for
non terminals and terminals

* have Your own symbol classes

java-cup is a LALR Parser Generator in Java. With v0.11, you can: *
use CUP in an Ant-Target

* start CUP by a simple command like java -jar java-cup-11a.jar
myGrammar.cup

* use generic parametrized classes (since Java 1.5) as datatypes for
non

* terminals and terminals

* have Your own symbol classes

Java Compiler Compiler (JavaCC) is the most popular parser generator
for use with Java applications. A parser generator is a tool that reads
a grammar specification and converts it to a Java program that can
recognize matches to the grammar. In addition to the parser generator
itself, JavaCC provides other standard capabilities related to parser
generation such as tree building (via a tool called JJTree included
with JavaCC), actions, debugging, etc.

Java Compiler Compiler (JavaCC) is the most popular parser generator
for use with Java applications. A parser generator is a tool that reads
a grammar specification and converts it to a Java program that can
recognize matches to the grammar. In addition to the parser generator
itself, JavaCC provides other standard capabilities related to parser
generation such as tree building (via a tool called JJTree included
with JavaCC), actions, debugging, etc.

JavaHelp software is a full-featured, platform-independent, extensible
help system that enables developers and authors to incorporate online
help in applets, components, applications, operating systems, and
devices.

This is a time zone compiler for opensource Java Virtual Machine
derived from openjdk6 source code.

Dom4j depends on a jaxen build with dom4j support. This package must
only be installed in the rare event of having to rebuild dom4j.

The jCIFS SMB client library enables any Java application to remotely
access shared files and directories on SMB file servers(i.e. a
Microsoft Windows "share") in addition to domain, workgroup, and server
enumeration of NetBIOS over TCP/IP networks. It is an advanced
implementation of the CIFS protocol supporting Unicode, batching,
multiplexing of threaded callers, encrypted authentication,
transactions, the Remote Access Protocol (RAP), and much more. It is
licensed under LGPL which means commercial organizations can
legitimately use it with their proprietary code(you just can't sell or
give away a modified binary only version of the library itself without
reciprocation).

Class, field, and method level annotations for describing thread-safety
policies.

Java-based codings helper classes for Joni and JRuby.

Collection of classes used by Object Refinery Projects, for example
jfreechart

JDepend traverses a set of Java class and source file directories and
generates design quality metrics for each Java package. JDepend allows
you to automatically measure the quality of a design in terms of its
extensibility, reusability, and maintainability to effectively manage
and control package dependencies.

JDOM is, quite simply, a Java representation of an XML document. JDOM
provides a way to represent that document for easy and efficient
reading, manipulation, and writing. It has a straightforward API, is
lightweight and fast, and is optimized for the Java programmer. It is
an alternative to DOM and SAX, although it integrates well with both
DOM and SAX.

jEdit is a cross-platform programmer's text editor written in Java.

Some of jEdit's features include:

* Built-in macro language (BeanShell)

* Extensible plug-in architecture with more than 80 plug-ins
available

* Plug-ins can be downloaded and installed from within jEdit using
the plug-in manager feature

* Syntax highlighting for more than 80 languages

* Supports a large number of character encodings including UTF8 and
Unicode

* Autoindenting of source code

* Folding (indent and marker based)

* Word wrap

* Unlimited undo and redo

* Highly configurable and customizable

* Every other feature, both basic and advanced, that you would expect
to find in a text editor

Jemmy is a Java UI testing library. Jemmy represents the most natural way to
test Java UI - perform the testing right from the Java code. Jemmy is a Java
library which provides clear and straightforward API to access Java UI. Tests
are then just java programs, which use the API. Having the tests in Java allows
to use all the flexibility of high level language to capture test logic and
also do any other operations needed to be done from test.

The clean-room JSSE API is quite complete, absent some better
documentation comments. The provider contains most of the necessary
code for the core of the SSL and TLS protocols, and development is
currently focused on stability and the standard extensions to the TLS
protocol.

Jetty is a 100% Java HTTP Server and Servlet Container.
This means that you do not need to configure and run a
separate web server (like Apache) in order to use java,
servlets and JSPs to generate dynamic content. Jetty is
a fully featured web server for static and dynamic content.
Unlike separate server/container solutions, this means
that your web server and web application run in the same
process, without interconnection overheads and complications.
Furthermore, as a pure java component, Jetty can be simply
included in your application for demonstration, distribution
or deployment. Jetty is available on all Java supported
platforms.

JFlex is a lexical analyzer generator for Java written in Java. It is
also a rewrite of the very useful tool JLex which was developed by
Elliot Berk at Princeton University. As Vern Paxson states for his
C/C++ tool flex: they do not share any code though.

Design goals The main design goals of JFlex are:

* Full unicode support

* Fast generated scanners

* Fast scanner generation

* Convenient specification syntax

* Platform independence

* JLex compatibility

JFlex is a lexical analyzer generator for Java written in Java. It is
also a rewrite of the very useful tool JLex which was developed by
Elliot Berk at Princeton University. As Vern Paxson states for his
C/C++ tool flex: they do not share any code though.

Design goals The main design goals of JFlex are:

* Full unicode support

* Fast generated scanners

* Fast scanner generation

* Convenient specification syntax

* Platform independence

* JLex compatibility

This project is derived from Sun's implementation of java.util.Formatter. It
is designed to allow compile time checks as to whether or not a use of format
string will be erronous when executed at runtime.

This code is derived from the OpenJDK implementation, jdk1.7.0-b35. As such,
it is licensed under the same license as OpenJDK, GPL v2 + the Classpath
exception.

This project is preliminary, and the API is subject to change. The library
produced by compiling this project is used by the FindBugs project. To avoid
any licensing questions due to incompatible licenses (FindBugs is licensed
under the LGPL), it is broken out as a separate project. While there may be
some confusion/discussion about the licenses, the FindBugs project does not
interpret the FindBugs LGPL license to be any stronger than GPL v2 + the
Classpath exception.

JGroups is a toolkit for reliable multicast communication. (Note that
this doesn't necessarily mean IP Multicast, JGroups can also use
transports such as TCP). It can be used to create groups of processes
whose members can send messages to each other. The main features include

* 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)

To use JGroups one needs:
commons-logging.jar
log4j.jar

To run JGroups you need to have an XML parser installed on your system.
If you use JDK 1.4 or higher, you can use the parser that is shipped with it.

If you want to use the JGroups JMS protocol ( org.jgroups.protocols.JMS ),
then you will also need to place jms.jar somewhere in your CLASSPATH.

Place the JAR files somewhere in your CLASSPATH , and you're ready to start
using JGroups.

Jikes(TM) is a compiler that translates Java(TM) source files as
defined in "The Java Language Specification" into the byte code
instruction set and binary format defined in "The Java Virtual Machine
Specification."

You may wonder why the world needs another Java compiler, considering
that Sun provides javac free with its SDK. Jikes has four advantages
that make it a valuable contribution to the Java community:

* Open source. Jikes is OSI Certified Open Source Software. OSI
Certified is a certification mark of the Open Source Initiative.

* Strictly Java compatible. Jikes strives to adhere to both "The
Java Language Specification" and "The Java Virtual Machine
Specification" as tightly as possible and does not support
subsets, supersets, or other variations of the language. The FAQ
describes some of the side effects of this strict language
conformance.

* High performance. Jikes is a high performance compiler, making it
ideal for use with larger projects.

* Dependency analysis. Jikes performs a dependency analysis on your
code that provides two very useful features: Incremental builds
and makefile generation.

Note that you must set CLASSPATH correctly to use jikes.

Jisp uses B-Tree and hash indexes for keyed access to variable-length
serialized objects stored in files.