Next: Jn-Jz Up: Linux Software Encyclopedia Previous: In-Iz Contents

Ja-Jm

Last checked or modified: Aug. 16, 2000

Jabber: An instant messaging system similar to ICQ or AIM but which differs significantly from those systems. It is Open Source, simple, fast, extensible, modularized and cross-platform. It was designed from the ground up to serve the needs of users and to maintain compatibility with other systems (i.e. it can be used to transparently communicate directly with users of ICQ, AIM and other communication systems). The features of Jabber include:

distributed servers;

ISP-level service similar to other Internet services;

an XML-based protocol;

simple functionality that allows simple and pervasive clients; and

embeddability and extensibility in every way.

[http://jabber.org/]
JACAL: This is a symbolic mathematics system for the simplification and manipulation of equations and single and multiple valued algebraic expressions constructed of numbers, variables, radicals, and algebraic differential, and holonomic functions. JACAL is written in Scheme and uses the SLIB Scheme library as a portable platform. A Scheme implementation is needed to run JACAL, one of which is an interpreter called SCM available at the same location, although a compiler such as MIT Scheme would make things run much faster.
[http://ftp-swiss.ai.mit.edu/~jaffer/JACAL.html]
jack: A Python front-end for ripping CDs and encoding in MP3 format. This was designed for making MP3s with no worries, i.e. any incomplete rip will be noticed by various error checking methods. The features include:

ripping virtual CD images like those created by CDRDAO;

displaying cdparanoia information for all tracks;

allowance for overlapping ripping/encoding, i.e. starting both the first track encoding and second track ripping upon completion of ripping the first track;

use of disk space management for scheduling ripping and encoding;

checkpointing for completing work after interruptions; and

support for different rippers and encoders.

This requires Python 1.5.2 and several non-standard modules.
[http://www.home.unix-ag.org/arne/jack/]
Jacl/Tcl Blend: The JAva Command Language and Tcl Blend are two systems for the integration of Tcl and Java. The former is a Java implementation of Tcl 8.0 and the latter a package for Tcl 8.0 that allows you to load and interact with the Java VM. These systems allow extensions to Tcl to be written in cross-platform Java code. They also offer a new set of Tcl instructions that allow Java objects to be created, called and manipulated directly from Tcl. The new APIs are useful for the rapid prototyping and testing Java interfaces - allowing access to Java's libraries without having to leave Tcl.
The features of one or both of these packages include:

support for the Linux port of JDK (versions 1.1 and 1.2);

the capability of running with the Kaffe VM;

creating hybrid applications comprising both legacy and Java code, i.e. porting legacy applications to Java;

an argument matching system that automatically determines which Java method a user intended to invoke based on the argument types; and

a command for changing the type of Java references at runtime.

Source code distributions for both packages are available. Requirements include Java 1.1 or newer for both, as well as a JVM that supports the official JNI, a native thread version of Java, and Tcl 8.0 for Tcl Blend. The package is documented in some online HTML documents and in a technical report available in PostScript format. See also jTcl.
[http://www.scriptics.com/java/]
JACOB: Just A Compiler for OBeron-2 is a standalone Oberon compiler which compiles a single Oberon-2 module together with its imported modules and then links everything together to create an executable program. The features include a full implementation of the Oberon-2 language, external modules which are allowed to write library modules in other languages, a garbage collector which uses the mark-and-sweep algorithm, and command line options for enabling and disabling NIL, index, range, and assertion checks. A binary version of JACOB is available for Linux Intel platforms.
[http://user.cs.tu-berlin.de/~sepp/jacob.html]
JacORB: An object request broker written in Java that partially implements the CORBA standard. The features of JacORB include:

an IDL compiler and stub generator;

support for both CORBA IDL and Java-only distributed programming;

support for multithreaded clients and servers;

IIOP;

an Interface Repository;

a Dynamic Invocation Interface (DII) and Dynamic Skeleton Interface (DSI);

request- and message-level interceptors (i.e. filters and transformers);

COSS-compliant name service; and

a request gateway for applets.

The distribution contains the source code, examples and extensive documentation and is available under the GPL.
[http://www.inf.fu-berlin.de/~brose/jacorb/]
Jade: A programmer's text editor which is fully configurable via a built-in Lisp-style programming language. It emulates a subset of the Emacs keybindings with some commands altered to suit Jade, e.g. opening a new window opens a new X Window instead of just splitting one.
A source code for Jade is available. It is written in C and can be compiled and used on most UNIX platforms. A 200+ page user's manual and programmer's guide in Texinfo format is included in the distribution.
[http://sunsite.unc.edu/pub/Linux/apps/editors/X/]
Jade: James' DSSSL Engine is an implementation of the DSSSL style language. The features of Jade include:

an abstract interface to an interface called groves which which designed to be implementable on top of a database;

a in-memory implementation of this interface built with SP and called spgrove;

a style engine which implements the DSSSL style language; and

a command-line application called jade which combines the style engine with the spgrove interface and backends for generating an XML representation of the flow object tree, RTF, TeX, MIF and SGML.

A UNIX version of Jade is available in source code form. It contains a compatible version of SP which may not be identical to the latest release of that package. The Jade source can be compiled using gcc 2.7.2 or later. The documentation is a bit sketchy as yet (4/97).
[http://ftp.jclark.com/jade/]
JadeTeX: A TeX backend for Jade.
[http://tug.org/applications/jadetex/]
[http://www.tug.org/applications/jadetex/isug/isug.html]
JAFMAS: The Java-based Agent Framework for Multi-Agent Systems provides a generic methodology for developing speech-act based multi-agent systems, an agent architecture, and a set of classes to support the implementation of these agents in Java. It defines a generic methodology for multiagent application development and provides a set of services that prevent having to program cooperation mechanisms from scratch and guarantee that essential interoperation, communication and cooperation services will exist to support applications. JAFMAS provides communication, linguistic and coordination support via sixteen Java classes, with communication support provided for both directed communication and subject-based broadcast communication. This allows the development of scalable, fault-tolerant, self-configurable and flexible multiagent systems.
A source code distribution of JAFMAS is available which requires JDK 1.1 or greater. Example applications are included in the distribution. A thesis describing JAFMAS which also includes a user's manual is available in PostScript format.
[http://www.ececs.uc.edu/~abaker/JAFMAS/]
JAI: The Java Advanced Imaging API is designed to provide a high performance, platform-independent and extensible image procesing framework for Java. The functionality of the package includes:

over 80 image processing opertations, most of which are native optimized;

a wide range of image formats and data types;

image file I/O supporting BMP, GIF, JPEG, PNG, PNM and TIFF;

support for RMI and IIP for remote imaging; and

interoperability with the Java 2D API for mixing overlay graphics data with images.

[http://java.sun.com/products/java-media/jai/]
Jam: A replacement for make that makes building simple things simple and building complicated things manageable. The features include:

an expressive language that makes Jam files compact;

portability across most platforms; and

building large projects spread across many directories in a single pass without recursing.

A source code distribution is freely available.
[http://www.perforce.com/jam/jam.html]
Jam!: A general purpose agent architecture which supports both top-down, goal-based and bottom-up, data-driven reasoning. Jam! is a BDI-theoretic (Belief-Desire-Intention) agent architecture based on a PRS (Procedural Reasoning System) wherein the concepts are explicitly represented within the agent code such that when you implement agents you specify beliefs (facts known to the agent), desires (goals for the agent to achieve), and capabilities (plans and primitive actions) with intentions dynamically determined by the agent at runtime based on its known facts, current goals, and available plans.
Jam selects goals and plans based on user-developed metalevel reasoning if it exists and on maximal priority if it doesn't. The conceptualization of goals and goal achievement makes the distinction between plans to achieve goals and plans that simply encode behaviors, with available goal types including achievement, maintenance, and peformance. Jam! supports the execution of simultaneous goals with suspension and resumption capabilities for each goal thread. Plans have explicit precondition and runtime attributes that restrict their applicability, a postcondition attribute, and a plan attributes section for specifying plan/domain-specific features. Available plan constructs include sequencing, iteration, subgoaling, atomic plan segments, n-branch deterministic and non-deterministic conditional execution, parallel execution of multiple plan segments, goal-based or world state-based synchronization, and explicit failure-handling section, and Java primitive function definition.
A source code distribution of this Java package is available. A user's manual is available in HTML format. This is related to the UMPRS package.
[http://members.home.net:80/marcush/IRS/]
JAM: Java Agents for Meta-learning is a project to develop pattern-directed inference systems using models of anomalous or errant transaction behaviors to forewarn of impending threats to financial institutions. The system will have two key component technologies: local fraud detection agents that learn how to detect fraud and provide intrusion detection services within a single information system and a secure, integrated meta-learning system that combines the collective knowledge acquired by the individual local agents. A library of Java classes implementing some of the ideas of the project is available.
[http://www.cs.columbia.edu/~sal/JAM/PROJECT/]
JAMA: A basic linear algebra package for Java that provides user-level classes for constructing and manipulating real, dense matrices. This is meant to provide sufficient functionality for routine problems and is intended to serve as the standard matrix class for Java. The six Java classes comprising JAMA are:

Matrix, providing the fundamental operations of numerical linear algebra;

CholeskyDecomposition, for symmetric and positive definite matrices;

LUDecomposition, for Gaussian elimination of rectangular matrices;

QRDecomposition, for rectangular matrices;

SingularValueDecomposition, for both symmetric and nonsymmetric square matrices; and

EigenvalueDecomposition, for rectangular matrices.

A source code distribution is available.
[http://math.nist.gov/javanumerics/jama/]
jamal: Just Another MAcro Language is a Perl script for creating multi-page documents using macros that define styles. The features include:

macro definition using arguments;

inclusion of code, HTML and macro files;

text creation via arithmetic calculations;

creation of text in a loop for files in a directory or for numerical or textual values;

conditional macros;

automatic insertion of time and date values; and

definition of simple macros on the command line.

A source code distribution of jamal is available.
[http://peter.verhas.com/progs/perl/jamal/]
Janus: A C++ template library of data structures and algorithms that simplifies the fast and efficient implementation of grid- and mesh-based scientific applications. Janus provides reusable components as well as an extensible conceptual framework within which the complex spatial structures that occur in scientific computations can be dealt with. It is implemented as a thin layer on top of STL and MPI.
[http://www.first.gmd.de/~jens/janus/]
Janus (security): A package for running processes in a restricted execution environment or sandbox, with the goal being to prevent or minimize the amount of damage suspect programs can do to your system. Janus consists of two parts:

the program janus for running sandboxed applications; and

the kernel module mod_janus used by janus to accomplish its task.

The janus program's functionality includes creating and managing an application sandbox as well as tracing system calls. Within the Janus sandbox environment:

commands are started in a ``clean'' state in which the descriptor space and environment are cleared;

resource limits are set before a processes begins running to prevent it from using an undesirable amount of memory, processes, etc.;

all interactions with the OS are regulated via system call interposition, i.e. when a sandboxed processes makes a system call, then that processes is paused while janus decides whether or not to allow the call to proceed;

if janus allows the call then execution resumes as normal, but if it denies the call then EPERM is returned;

if janus exists for any reason, all processes running in the sandbox are killed.

[http://www.cs.berkeley.edu/~daw/janus/]
JAPE: Just Another Proof Editor is an interactive tool designed to help with learning, teaching and using formal reasoning. JAPE takes a description of a logic as a system of inference rules and supports the development of proofs in that logic. A tactic language is used to control the display of proofs and to perform simple searches. Several logic encodings are supported including:

natural deduction;

single- and multiple-conclusion sequent calculus;

aximatic set theory;

equational reasoning in functional programs;

Hindley-Milner polymorphic type assignment; and

Hoare logic.

Binary versions of JAPE are available for Linux Intel platforms.
[http://www.comlab.ox.ac.uk/oucl/users/bernard.sufrin/jape.html]
Jasmin: A Java assembler interface which takes ASCII descriptions for Java classes written in a simple assembler-like syntax and the Java Virtual Machine instruction set and creates binary Java class files suitable for loading into an interpreter. This was created because creating a Java class file manually is an imposing task and the author wanted something which would make it easy for a student to explore the Java Virtual Machine. Also, Sun has not yet (7/97) defined an assembler format. Jasmin uses both the Java Cup and JAS packages. A user's guide is available in HTML format. Jasmin was written as companion software for Meyer and Downing (1997). See also Lindholm and Yellin (1997)
[http://found.cs.nyu.edu/meyer/jasmin/]
JAT: The Java Agent Template is written in Java and provides a fully functional template for constructing software agents which communicate peer-to-peer with a community of other agents distributed over the Internet. The agents do not migrate but have a static existence on a single host (although portions of the code which define each agent are portable). All agent messages currently use KQML as a top-level protocol or message wrapper The JAT includes functionality for dynamically exchanging resources which can include Java classes, data files, and information inlined in KQML messages. The agents can be executed as either standalone applications or as applets, with both configurations supporting graphical and non-graphical agents. An Agent Name Server provides coordination for all agents.
A source code distribution of JAT includes the core JAT packages, packages which support a remote service paradigm, and various example applications. A user's guide is included in HTML format as well as automatically generateed documentation on the various classes.
[http://cdr.stanford.edu/ABE/JavaAgent.html]
Java: An object-oriented programming language developed at Sun to solve a number of problems in modern programming practice and to provide a language for the Internet. It is compiled into machine independent bytecodes, which means that applications written in Java can migrate transparently over the Internet. It is presently available only for Sun platforms. As for Linux, there is a mailing list for those involved in porting Hot Java to Linux platforms. It can be joined by sending a subscribe message to java-linux-requestjava.blackdown.org. Or you can just take a peek at the Java Linux Porting Project site, where they have a Linux port of the Java Developer's Kit (JDK), i.e. a compiler for Java programs. Another salient site for Linux aficionados is the Linux Java Tips and Hints Page. The easiest way to run Java applets at present (1/15/96) on Linux platforms (and most other platforms) is to obtain a copy of the Netscape browser that is version 2.0b2 or later. The just released (4/96) Atlas series (numbered as 3.0+) of Netscape browsers are now reportedly capable of running most Java applets.
Popular Java sites (other than the Sun home site given in the title URL above) are Gamelan, The Java Developer, Team Java site, and the Java FAQ archives. There is also a usenet group called comp.lang.java which currently sees about 300-400 posts per day. See Appel (1997a), Arnold and Gosling (1996), and van Hoff et al. (1995).
Other Java-related entries include:

AnyTool,

AppGEN,

AwkTools,

BAYDA,

Biss,

Bongo,

BuildIT,

CACAO,

c2j,

c2j++,

Demeter,

DOGMA,

EPP, an extensible Java preprocessor;

FastCGI,

Free Builder,

GCJ,

GJ,

GnuJSP,

GraphPanel,

Guavac,

Habanero,

Harissa,

hashjava,

HDF-Java,

HORB,

HotEqn,

HotTEA,

II,

ILU,

Jacl,

JAM,

JAS,

Jasmin,

JAT,

JAVAB,

JavaCC,

Java Cup,

JavaFIG,

JavaParty,

JAVAR,

JavaSci,

JCC,

JConfig,

JDK,

Jetty,

JHV,

JIGL,

Jigsaw,

Jikes,

JKP,

JLAPACK,

JOS,

jPVM,

JPython,

JSCC,

jSSL,

Jsync,

jTcl,

JUMP,

JVerge,

Kaffe,

Kafka,

Kawa,

Kiev,

Koala,

Korfe,

Lava Rocks,

Mica,

Mocha,

MOWS,

Muffin,

MuLaW,

NetRexx,

NetComponents,

NetSolve,

NinjaRMI,

Object REXX,

ObjectSpace JGL,

OpenJava,

OROMatcher,

PerlTools,

Pizza,

plonk,

TextTools,

Toba,

TurboJ,

TYA,

VermelGen,

Voyager,

VRwave,

WebCanal,

WebEQ,

WebMacro,

Web-O-Matic,

WipeOut,

W-Prolog, and

Yassl.

[http://java.sun.com/]
[http://www.kr.tuwien.ac.at/~gernot/java-linux.html]
[http://www.w3com.com/paulcho/javalinux/]
JAVAB: A prototype bytecode tool which can automatically detect and exploit implicit loop parallelism in Java bytecode. The implicit parallelism is made explicit by means of the multi-threading mechanism provided by the Java Virtual Machine (JVM). This automatic exploitation is performed independently from the source program and platform from which the bytecode is obtained as well the the platform on which it will run. The parallelized bytecode remains architecturally neutral and may exhibit a speedup on any platform supporting the true parallel execution of JVM threads. A source code distribution of JAVAB is available. It is written in Java.
[http://www.extreme.indiana.edu/~ajcbik/JAVAB/index.html]
JavaCC: The Java Compiler Compiler is a parser generator for use with Java applications, i.e. a tool that reads a grammar specification and converts it to a Java program that can recognize matches to the grammar. JavaCC also provides other standard capabilities related to parser generation such as tree building, actions and debugging.
The features of JavaCC include:

generation of top-down (i.e. recursive descent) parsers to allow the use of more general grammars and ease debugging;

lexical and grammar specifications written to a single file;

a tree building preprocessor called JJTree;

many different options for customizability;

a translator that converts grammar files to documentation files;

a wide range of exapmles including Java and HTML grammars;

internationalization for handling full Unicode input;

syntactic and semantic lookahead to resolve shift-shift ambiguities;

allowance for extended BNF specifications;

lex-like lexical state and lexical action capabilities;

case-insensitive lexical analysis;

extensive debugging capabilities; and

very good error reporting.

A source code distribution of JavaCC is freely available. The most recent version (5/98) requires JDK version 1.1 or later. Extensive documentation is available online and in the distribution.
[http://www.metamata.com/JavaCC/]
Java Cup: An LALR parser generator for Java. It serves the same purpose as YACC but is written in Java, uses specifications including embedded Java code, and produces parsers which are implemented in Java. A user's manual is available.
[http://www.cs.princeton.edu/~appel/modern/java/CUP/]
JavaFIG: A graphics and diagram editor based on the Xfig graphics editor for X11. This is intended for the creation and editing of technical diagrams and drawings. It is missing some of the functionality but also has some additional features not found in Xfig including:

loading documents and embedded pictures via URLs over the Internet;

embedded hyperlinks in drawings;

unlimited undo;

an increase in internal resolution to 2400 dpi;

an additional (solder dots) arrow style;

native Java printing support; and

native GIF export.

This can be used as either a standalone application or an applet. A source code version of the class archive is available. It requires at least JDK 1.1.3.
[http://tech-www.informatik.uni-hamburg.de/applets/javafig/]
JavaNumerics: A site with links to projects and/or packages that combine the Java programming language with numerical methods. Interesting projects include:

Horizon, a set of Java packages and interfaces for supporting and manipulating most image formats;

JAMA, a basic linear algebra package for Java;

JLAPACK, a Java version of LAPACK;

JUMP, a library for arbitrary precision mathematical computations;

NetCDF for Java, a Java interface for NetCDF; and

VisAD, a library for the interactive and collaborative visualization and analysis of numerical data.

[http://math.nist.gov/javanumerics/]
JavaParty: An extension to Java that transparently adds remote objects purely by declaration while avoiding the disadvantages of explicit socket communication, the programming overhead of RMI, and the disadvantages of the message passing approach. JavaParty is specifically targeted towards and implemented on clusters of workstations. It serves as both a programming environment for cluster applications and a testbed for research into optimization techniques for improving locality and reducing communication times. A source code distribution of JavaParty is available. It is documented in several technical reports.
[http://wwwipd.ira.uka.de/JavaParty/]
JavaPVM: The name of this has been changed to jPVM to keep the lawyers away.
JAVAR: A prototype Java restructuring compiler which can be used to make implicit parallelism in Java programs explicit by means of multi-threadings. It does not provide a complete Java front-end and should only be used with programs that have been tested on a full Java compiler. JAVAR can also generate HTML representations of Java programs.
[http://www.extreme.indiana.edu/~ajcbik/JAVAR/index.html]
JavaSci: The name of this has been changed to JSci to keep the ravenous lawyers away.
JavaView: A 3-D geometry viewer and numerical software library written in Java. The library focuses on problems in differential geometry and is extensible for further numerical experiments and capabilities. The features of the viewer include:

rotation, translation, zooming, camera control and picking;

inspection of geometries and material properties;

selective display of vertices, edges, faces and vector fields;

import/export of geometries in multiple data formats;

animation, auto rotation, keyframes and textures;

export in PostScript, GIF and PPM formats; and

viewing and animation of Mathematica graphics.

The core packages/classes of JavaView include:

jv.anim, interfaces and implementations of animation classes;

jv.function, interactively editable functions;

jv.geom, geometry classes for curves, surfaces and volumes;

jv.loader, loader for geometry files in various formats;

jv.number, basic classes for integers, doubles, colors, vectors and arrays;

jv.object, base class of JavaView;

jv.objectGui, additional GUI-related base classes;

jv.project, classes related to projects;

jv.vecmath, vector and matrix classes with simple linear algebra functionality; and

jv.viewer, classes to handle 3-D drawing and managing the control window.

[http://www-sfb288.math.tu-berlin.de/vgp/javaview/]
jaw3d: A 3-D model viewer which allows the viewing and rotation of solid texture-mapped, Lambert/Gouraud lightsource-shaded, and wire-frame objects in real time. The features include:

free rotation around all three axes;

moving and zooming of objects;

polygon sorting via Painter's algorithm;

a rotatable lightsource;

several rendering and shading methods including texture and environmental texture mapping, Gouraud shaded polygons, fake Phong shading, flat Lambert-shaded polygons, wire frame, and mode switching on the fly; and

reading of jaw files and converters for 3DS and MLD formats.

The jaw3d package is available in ELF binary format for Linux platforms.
[http://www.jawed.com/jaw3d/]
jaZip: A program for maintaining Iomega Zip and/or Jaz drives and disks under Linux. JaZip combines the command line utility ziptool with Jaz drive support, an X11 interface, and additional utilities which allow the easy mounting and unmounting of disks. Features include support for and identification of both Jaz and Zip drives, changing the write protection status of a disk, querying the write protection status of a disk, mounting and unmounting disks as an ordinary user, autodetecting the format of the disk in the drive, and ejecting a disk. Future plans include disk formatting and cataloguing features.
The jaZip package will only work on Linux Intel systems. It is available as source code, as an ELF binary, or as an RPM package. Compilation from source requires the XForms library. It is documented in a FAQ and in some ASCII documents in the distribution.
[http://www.scripps.edu/~jsmith/jazip/]
JAZZ++: A powerful MIDI sequencer with many features for Linux and a GM/GS sound-card module. JAZZ will work with any general MIDI sound-module/synthesizer, but it is customized for a GS-compatible setup like the SoundCanvas SC-55 module or the SC-1 sound card or the MU-80.
The features of JAZZ include:

two main windows which display tracks and single MIDI events; record/play;

powerful and easy event editing;

volume, pan, chorus, reverb, program, name for each track;

track status, e.g. mute, solo, play;

operations include quantize, velocity, notelength, transpose, copy, replicate, erase, merge, move, meterchange, etc.;

loading/saving of MIDI standard files (format 1);

multiple undo;

graphical editing of pitch (velocity, modulation, controllers);

support for all 317 GS sounds;

a mixer window (with slider control of volume, pan, chorus, and reverb);

sound alteration (e.g. cutoff frequency, resonance, vibrato, pitch wheel sensitivity/actions, modulation depth/actions, after touch actions, etc.);

partial reserve editing;

GS reset;

individual drum instrument parameter editing;

context specific help on all windows and dialogs;

a graphic toolbar;

support for MTC and MIDI songpointer synchronization;

FSK tape sync support;

a harmony browser with file load/save;

a random rhythm generator with file load/save; and

Linux drivers for MPU-401 (intelligent mode) and OSS;

Binary versions of JAZZ are available for a 30 day free evaluation period, after which a license must be purchased. A binary is also available for Linux Intel platforms. A user's guide and reference manual is available in HTML and PostScript format.
[http://www.jazzware.com/cgi-bin/Zope.cgi/jazzware/]
JBIG: The Joint Bi-level Image experts Group is a group of experts working on image coding for the lossless compression of bi-level images. The standard can also be used for coding grayscale and color images with limited numbers of bits per pixel. It is similar to facsimile encoding, e.g. Group 3 or 4 FAX, offering from 20-80% improvement in compression over these methods. The so-called JBIG1 standard is IS 11544 (ITU-T T.82).
A JBIG2 standard is currently (12/98) under development. It is also a format for bi-level image compression and offers significant advantages over JBIG1 and other compression formats including:

a significant increase in compression performance, e.g. 2-4 times better than JBIG1;

special compression methods for text, halftones, and other binary image content;

lossy and lossless compression;

multi-page document compression;

a flexible format designed for easy embedding in other formats; and

high-performance decompression.

[http://www.jpeg.org/public/jbighomepage.htm]

JBIG-KIT

A package which implements a highly effective data compression algorithm for bi-level high-resolution images such as fax pages or scanned documents using the JBIG standards. JBIG-KIT provides a portable library of compression and decompression functions with a documented interface which can be easily included into image or document processing software. It also provides ready-to-use compression and decompression programs with a simple command line interface.
The JBIG-KIT package is available as source code. It is written in ANSI C and should compile on generic UNIX platforms. It is fully documented in a user's manual available in PostScript format.
[http://www.cl.cam.ac.uk/~mgk25/]
jBoss: A open source application server for the J2EE platform that uses JMX (Java Management eXtension) for software integration. The components of jBoss include:

Server, an implementation of the EJB container specification that supports both EJB Session and Entity Beans and features both dynamically, run time-generated stub and skeleton classes and automatic hot deploy and redeploy;

spyderMQ, an implementation of the Java Messaging Service (JMS) specification;

Jaws, an API for mapping EJB objects to relational database persistent stores;

Zola, the application programming model for jBoss;

Zoap, an implementation of SOAP;

Castor, an application providing Java to XML binding, Java to SQL/LDAP persistence, and more;

Tomcat, an implementation of Java servlets and JavaServer Pages (JSP); and

Test, a test suite for the jBoss environment.

[http://www.jboss.org/]
JBuilder: A cross-platform Java development tool with a feature-rich editing environment and rapid compilation using and advanced dependency checking system and an intuitive debugging environment. The features include:

building pure Java applications for Java 2 with support for the latest standards including Java 2, Java 2 JFC/Swing, Java2D, Java Collections, Accessibility APIs, etc.;

visual development using the JFC/Swing components for UI development;

an integrated application browser combining a project manager, compiler, debugger, class browser, visual designers and a source code editor;

visual Java 2 Designers for drag-and-drog JFC/Swing application development;

visual manipulation of Layout Managers for rapid UI development;

a visual menu designer;

a help system with full text search;

an integrated JavaDoc viewer;

a built-in API browser for class file methods and data;

project folders and resource management;

an API for integrating custom tools;

a source code editor with CUA and Emacs keybindings, advanced search-and-replace options with pattern matching, syntax highlighting for several file types, customizable smart key options, and customizable key bindings;

CodeInsight features to speed up coding and reduce syntax errors; and

a graphical debugger with breakpoints, stepping and watching along with a thread-lock detector.

A free distribution of the JBuilder Foundation is available, although you have to complete a survey and jump through some other hoops to get a license file for it to work.
[http://www.borland.com/jbuilder/]
JCC: A direct Java to C translator that processes Java source code directly rather than converting Java class files. Entire programs are converted at a time which, although a lengthy process, allows several optimizations to be performed to increase the performance of the resulting C code. Translated code is typically 10-20 times faster than the original Java code run with the JVM 1.0.2. This was last updated in May 1997.
[http://www.geocities.com/CapeCanaveral/Hangar/4040/jcc.html]
jcd: A Java CD player. The features include:

all the usual CD playing features;

tracking/indexing via direct access by entry into the numeric display;

programmed, continuous/single, and shuffle playing modes; and

remote access of CD information via the CDDB protocol.

A source code distribution of this application is available.
[http://metalab.unc.edu/pub/Linux/apps/sound/cdrom/]
[http://www.linuxgazette.com/issue28/hamilton.html]
JConfig: A cross-platform Java class library that supplements the core Java API by allowing interaction with files, web browsers, processes, file types, and other system-level items in a more advanced way than in the standard libraries. The functionality of the library includes:

enumerating disk drives and obtaining extended information on files, directories, volumes and filesystems;

launch a file or URL in a Web browser;

obtaining information about video monitors;

creating external processes, sending basic commands to external processes, obtaining the PSN or NWND of a created process, and obtaining information about currently running processes; and

finding applications associated with a given file type or by name.

A binary distribution of JConfig is freely available for personal use. It requires JDK 1.1.6 or better on Linux boxes. The distributions also contain a program developed using JConfig called ImageMeister, an extensible disk browser. A source code license is also available.
[http://www.tolstoy.com/samizdat/jconfig.html]
JDBC: An API for accessing virtually any tabular data source from Java. JDBC provides cross-DBMS connectivity to a wide range of SQL databases as well as other tabular data sources such as spreadsheets or flat files. The features and functionality include:

scrollable result sets that provide the ability to move the cursor forward and backward to a specified position or a position relative to the current position;

batch updates providing the ability to send multiple updates to the database to be executed in batch mode;

programmatic updates providing the ability to perform updates using the JDBC API rather than SQL statements;

methods for allowing character data to be retrieved from or sent to databases as streams of Unicode characters; and

support for advanced data types including SQL object data types.

See also the complementary JDO.
[http://java.sun.com/products/jdbc/]

Town

An improved and extended version of the Village Java API for working with the JDBC API. The additional and improved features include:

abstraction away from SQL Connection objects, i.e. datasets are constructed using JDBC connection strings rather than Connection objects;

additional connection pooling; and

conversion of SQLExceptions to IOExceptions.

[http://www.working-dogs.com/town/]

Village

A Pure Java API that sits on top of the JDBC API, making it easier to interact with a JDBC-compliant relational databse. Village makes it possible to execute and manage select, insert, update and delete SQL statements without having to write SQL code. An improved and extended version of this is called Town.
[http://www.working-dogs.com/village/]
JDK: The Java Developer's Kit is a package that allows you to write Java applets and applications which conform to the Java Core API. With the JDK you can develop applets which will run on browsers supporting Java as well as develop Java applications which can run without a browser, i.e. stand-alone applications. The JDK contains a java runtime package, source files, various tools, and documentation and demos. The runtime package contains the Java Core Classes classes.zip and a Java interpreter java which can execute Java bytcodes, i.e. run programs written in Java. The source files are those used to create the classes in the Java Core Classes. They don't include either the private java.* classes or the sun.* classes and therefore cannot be compiled into a complete classes.zip file. The documentation includes Release Notes, an API Reference, a Guide to New Features, Tools Documentation, and a Tutorial along with a couple of dozen demos.
The Java tools include:

javac, which compiles Java programs into executable bytecodes;

appletviewer, which is used for testing and running applets without a browser;

jdb, a Java debugger;

javap, which disassembles compiled Java files and prints out a representation of the bytecodes;

javadoc, which parses the declarations and documentation comments in source files and produces a set of HTML pages describing the code;

javah, a C header and stub file generator for attaching native methods to Java;

jar, an archive tool which combines many Java files and other resources into a single jar file;

javakey, a digital signing tool;

native2ascii, which converts a native encoding file to an ASCII file;

rmic, an RMI stub converter which generates objects from the names of compiled Java classes which contain remote object implementations;

rmiregistry, a Java remote object registry which creates and starts a remote object registry on the specified port of the current host;

serialver, a serial version command;

updateAWT, an AWT conversion tool which updates old AWT names to new ones;

and various C libraries and include files.
Each new release of the JDK by Sun is extensively modified by very clever volunteers so they will work on Linux Intel systems. The latest (5/97) available Linux version is JDK 1.1.1. The second URL below links to a version of the JDK (1.1.6 as of this writing, i.e. 7/98) developed for Linux by the Open Group.
[http://www.blackdown.org/]
[http://www.gr.opengroup.org/java/jdk/linux/]
JDO: Java Data Objects is an API for transparent database access that enables Java code to be written that can transparently access an underlying data store without using database-specific code. It allows Java classes to be used for database access rather than copying data being different data models, e.g. it hides SQL details from the programmer. See also the complementary JDBC.
[http://java.sun.com/products/jdbc/related.html]
JDQR/JDQZ: A set of Matlab and Fortran programs implementing the Jacobi-Davidson (JD) method for eigenproblems. It is an iterative subspace method for computing one or more eigenvalues and eigenvectors of an eigenproblem. Two extensions of the JD method are available which incorporate an effective restart strategy:

JDQR, for computing solutions of the standard eigenproblem; and

JDQZ, for computing solutions of the generalized eigenproblem.

Documentation includes a manual and various technical reports. Some of the codes can be obtained online and some must be requested via email.
[http://www.math.ruu.nl/people/bomhof/jd.html]
[http://www.math.uu.nl/people/sleijpen/JD_software/JDQR.html]
JED: An editor for the X Window environment. The features of JED include:

color syntax highlighting on color terminals;

folding support;

emulation of other editors including Emacs, EDT Wordstar, and Brief (with the Emacs emulation the best of any non-Emacs editor);

extensibility and complete customizability;

reading GNU info files from within the info browser;

a variety of programming modes (e.g. C, C++, Fortran, TeX, HTML, SH, IDL, DCL, NROFF, etc.);

editing TeX files with AUC-TeX and BibTeX support;

asynchronous subprocess support;

built-in support for the GPM mouse driver on the Linux console;

abbreviation Dynamic abbreviation modes;

8 bit clean with mutekey support; and

many editing functions (e.g. rectangular cut/paste, regular expressions, incremental searches, search/replace across multiple files, multiple windows, multiple buffers, shell modes, a directory editor, mail, ispell, etc.).

The source code for JED, written in Slang, is available and can be installed on UNIX, VMS, MS/DOS, OS/2 and MS/Windows platforms. The Slang library is not included in the distribution and must be obtained and installed separately. The documentation is available in Texinfo and LaTeX formats.
[http://space.mit.edu/~davis/jed.html]
jEdit: A text editor written in pure Java. The features include:

extensive use of GUI dialogs and mouse-based commands for ease of use;

syntax coloring for C, C++, Java, JavaScript and more;

autoindent for C, C++ and Java;

a command for bracket matching;

commands for compiler invocation;

parsing and saving of compiler errors;

support for both soft and hard tabs;

commands for previewing files in a Web browser;

regular expression search and replace;

automatic gzip compression and decompression; and

markers (i.e. named locations in a file) and anchors (i.e. floating markers that can be used for selecting large regions of text or jumping between two locations in a file).

A source code distribution is available.
[http://jedit.sourceforge.net/]
Jeep: A LaTeX style file that customizes the standard article and report styles. This allows more general specification of such parameters as page size, chapter, section and theorem heads, numbering, headers and enumerated lists. It also creates a literatim environment, an extension of the verbatim environment that allows equations used to be used within it.
[http://www.cs.umd.edu/~stewart/]
jeLLRap: A graphical tool written in Java for parsing strings using a variety of algorithms, e.g. LL1, LL2 or LR1. This is the author's previous LLParse and LRParse packages combined into a single tool. A source code distribution is available as is documentation in Javadoc format.
[http://www.cs.duke.edu/~rodger//tools/jellrap/]
JERED: JErome's Renamed EDitor is a terminal-based editor for UNIX systems based on the E editor for DOS and OS/2 from IBM. The features of JERED include:

editing several files simultaneously;

a highly configurable user interface;

syntax highlighting for C and C++;

support for five non-computer languages;

recording and playing macros;

keys remappable to text, actions or macros;

help dynamically generated according to key mappings; and

automatic saving of modified files.

A source code distribution is available.
[http://cortex.unice.fr/~jerome/jered/jered.html]
JetSpeed: An open source implementation of an open protocol groupware product. The backend will be based on other open source packages with JetSpeed being the frontend. A 1.0 release is currently (2/00) under development with the planned features including:

mail client support (e.g. IMAP, POP3 and SMTP);

discussion topics, i.e. topics that get created on the fly in a manner similar to that seen on Slashdot;

news and discussion groups as well as notes via NNTP;

a calendar and appointment scheduler;

voting and polling;

news and chat support;

todo/workflow/task lists and notes;

collaboration and sharing;

support for skins (e.g. CSS and GIF);

per user authentication and settings;

vCard/vCalendar;

an extensible data store;

sharing calendar and scheduling information;

personal database technology and a knowledge base, e.g. highlighting source code, bookmarks, text highlighting and annotation, etc.;

portal features, e.g. metasearch, DejaNews filter, news and weather filters, etc.;

an HTML administrative interface; and

contact/address book support and server-side public folders (via LDAP.

[http://java.apache.org/jetspeed/]
Jetty: An Open Source HTTP servlet server written in Java designed to be embeddable, extensible and flexible for serving dynamic HTTP requests from any Java application. The features of Jetty include:

standard HTTP file serving including default index files and directory listings;

support for the javax.servlet API defined by JavaSoft;

extensible HTTP request handlers for, e.g. authentication, translation, forwarding, proxying, etc.;

an extensible exception handler mechanism;

a rich HTML generation package;

a number of server side inclusion mechanisms;

server push support;

client session tracking;

a mechanism for filters to be conditionally inserted into the output stream of a response to a request;

request forwarding;

a proxy handler for configuring it as a proxy server for both FTP and HTTP requests;

flexible configuration options; and

telephony and SmartCard support.

A source code distribution of Jetty is available as is documention for the API.
[http://www.mortbay.com/software/Jetty.html]
JFC: The Java Foundation Classes aare a comprehensive set of GUI components and foundation services for implementing the look and feel of Java applications. The JFC features include:

the Swing components for constructing application GUIs;

a pluggable look and feel that allows the look and feel of an application to be changed without either restarting it or requiring the developer to subclass the entire component set;

an accessibility API providing an interface for including assistive technologies in applications;

the Java 2D API for fancy paint styles, defining complex shapes, controlling rendering processes, etc.; and

a drag and drop specification allowing interoperability between Java and non-Java applications.

[http://java.sun.com/products/jfc/]
JFS: IBM's Journaled File System is designed for high-throughput server environments. It was released as open source in 02/00 and is being developed for Linux platforms.
The distinguishing features of JFS include:

journaling for improved structural consistency and recoverability and much faster restart times;

extent-based addressing structures and aggressive block allocation policies to produce compact, efficient and scalable structures for mapping logical offsets within files to physical addresses on the disk;

variable block sizes on a per-file basis for optimization of space use based on the application environment;

dynamic allocation of space for disk inodes as required;

two different directory organizations, with one used for small directories and the other for larger ones; and

support for both sparse and dense files on a per-file basis.

[http://oss.software.ibm.com/developerworks/opensource/jfs/]
JFS: A TCP/IP-based network filesystem protocol that allows Java applets running in a Web browser to load and save files on a remote server as well as send email and print through the JFS server. This provides a way for applets to store state information since they cannot access the filesystem of the machine on which they are running. This works by running a JFS server along with a Web server, and when a JFS-capable applet is downloaded from the Web server it establishes a connection with the JFS server, sends a username and password, and then sends request to the JFS server to do things like create directories, obtain user information, send email and load, save and delete files. The files accessed through the JFS server are stored on the server host in files and directories beneath the root directory. The server maintains a list of users and groups for the filesystem as well as a completely separate set of permissions for each JFS file.
A source code distribution of JFS is available. Several demonstration applets are available including text and image editors, a file browser, a file tree, and a JFS shell. The distribution contains a JFSclient class containing methods for communication with a JFS server, a JPFcomponent class that all handler program must inherit from, and several JFS utilities for adding/deleting users and files and logging into a JFS server. This is freely available for non-commercial uses.
[http://www.webmin.com/jfs/]
JHV: The Java-based HDF Viewer is an interactive tool for viewing an HDF data file. The tool is written in Java and will let a user view an HDF file as a tree; display the HDF objects which are file annotations; display generic raster images, scientific datasets, vdata and vgroup data directly; and make a viewable spreadsheet of some or all of the raw data contained within the HDF file. The current (5/97) version of JHV works with JDK 1.02. See also SDB.
[http://hdf.ncsa.uiuc.edu/java-hdf-html/jhv/]
JIAJIA: A distributed shared memory (DSM) whose features include:

combining the physical memories of multiple workstations to form a larger shared space;

a lock-based cache coherence protocol for scope consistency;

a NUMA-like memory organization scheme that eases the management of shared memory;

a flexible shared memory allocation call for controlling the distribution of shared locations;

a tree structure broadcast mechanism to reduce system overhead; and

a selection of message passing functions.

A source code distribution is available which is supported on several platforms including Linux Intel. Documentation includes a user's manual in PostScript format.
[http://www.ict.ac.cn/chpc/dsm/dist.html]
JIGL: The Java Image and Graphics Library is a Java library for image processing developed to provide both processing power for research and simplicity for teaching. JIGL is built around a set of pixel-addressable image buffer classes that support pixel access, simple arithmetic on individual pixels, image-wide operations, and image-image operations. Image types handled include grey, real, color and complex. A set of utility classes provides convolution, FFTs, and various other operations. A source code distribution is available.
[http://rivit.cs.byu.edu/jigl/]
Jigsaw: An HTTP server written in Java. This was produced by W3C and its design goals were portability (in that it will run on any machine running Java), extensibility (in that the server can be extended by writing new resource objects using a mechanism to replace or at least complement CGI), and efficiency (in that it has been designed to minimize file system accesses).
[http://www.w3.org/pub/WWW/Jigsaw/]
Jikes: A program that compiles Java source code into bytecodes. Source code and binary distributions are available, with one of the latter being for Linux Intel.
[http://www.research.ibm.com/jikes/]
Jini: Jini is a set of APIs and runtime conventions (built on top of Java and RMI) that facilitate the building and deploying of distributed systems. It is a package providing a simple infrastructure for delivering services in a network and for creating spontaneous interaction between programs that use these services regardless of their hardware/software implementation. Any kind of network made up of services (applications, databases, servers, devices, information systems, mobile appliances, storage, printers, etc.) and clients (requesters of services) of those services can be easily assembled, disassembled, and maintained on the network using Jini. Services can be added or removed from the network, and new clients can find existing services - all without administration.
Jini defines a runtime infrastructure that resides on the network and provides mechanisms that enable you to add, remove, locate, and access services. The runtime infrastructure resides on the network in three places: in lookup services that sit on the network; in the service providers (such as Jini-enabled devices); and in clients. Lookup services are the central organizing mechanism for Jini-based systems. When new services become available on the network, they register themselves with a lookup service. When clients wish to locate a service to assist with some task, they consult a lookup service.
The runtime infrastructure uses one network-level protocol, called discovery, and two object-level protocols, called join and lookup. Discovery enables clients and services to locate lookup services. Join enables a service to register itself in a lookup service. Lookup enables a client to query a lookup service for services that can help the client accomplish its goals.
[http://www.sun.com/jini/]
Jipe: The Java Integrated Programming Environment is an IDE for Java.
[http://e-i-s.co.uk/jipe]// [http://jipe.sourceforge.net]
Jitterbug: A Web-based bug tracking system originally developed by the Samba team to handle bug tracking, problem reports and queries from Samba users. Jitterbug operates by receiving bug reports via either email or a Web form, with authenticated users able to reply to it, move it, or add notes to it. It is not unlike a Web-based email system.
The features of Jitterbug include:

usable from almost any browser since it's HTML 3.2 compliant, i.e. no extraneous Java, frames, or similar annoyances;

a built-in SMTP mail client for sending replies and notifications;

requests for email notification of changes can be made by each user;

FAQ editing and creation are built in to the mail composition page;

tracking of replies and follow-ups;

search and message selection controls;

setting of personal preferences for colors, screen layout and other personal details;

ease of customization;

authenticated users can add arbitrary notes to messages; and

an audit trail is kept for each message.

A source code distribution of Jitterbug is available. It is a single program written in C which runs as a CGI script. Documentation is contained within an ASCII text file included in the distribution.
[http://jitterbug.samba.org/]
JKP: The Java KIF Parser is a parser for a subset of the KIF language called SKIF. It is written in Java.
[http://www.cs.umbc.edu/kse/kif/jkp/]
JLAPACK: The Java LAPACK package is a translation of LAPACK into the Java language. This is the first release of the f2j or Fortran 2 Java project, whose primary motivation is to provide numerical linear algebra software originally written in Fortran as Java class files. The two facets of the project are to produce compilable, verifiable, correctly running Java source code from Fortran source code, and to translate Fortran to Jasmin assembler opcode for assembly into class files.
[http://www.cs.utk.edu/f2j/download.html]
jmake: An automated alternative to creating make files for software development. With just a few basic assumptions jmake can build libraries and executables for multiple concurrent platforms with minimal effort. Those assumptions are:

all source code files are compiled into object files;

the current directory is the target executable, i.e. the target has the same name as the directory and all objects and subdirectories are linked into the target;

each subdirectory becomes an individual library with all objects in that subdirectory linked into the library; and

directories beginning with an underscore are reserved for jmake to use for configuration files, objects, libraries, etc.

A source code distribution is available.
[http://nub.arlut.utexas.edu/~jmake/]
jMax: A programmable environment for interactive multimedia and musical applications. The GUI features a visual programming language that allows patches to be built by connecting modules with patch cords (analogous to the physical equivalent with modular analog synthesizers), with the connections representing data paths on which control messages or signals are passed between modules. The modules can be processing units with capabilities ranging from simple arithmetic computations to complex transformations. They can also represent data containers like signal buffers or matrices as well as system inputs and outputs, e.g. for audio and MIDI. The modules can be either primitives (called objects) or patches themselves - giving patches hierarchical capabilities. The jMax architecture consists of two main parts: a real-time execution engine written in C and a GUI implemented using Java.
The jMax real-time server (FTS) supports sound samples and controls computations. The features and functionality include:

an object system that handles execution, editing and controlling patches;

an optimized interpreter of signal processing functions; and

an I/O manager organized around a device abstraction that encapsulates hardware dependencies in an interface independent of the platform.

Both jMax components are extensible by the user, and the user interface includes a scripting language with which complex actions can be scripted. The primitive objects available with the package include those for simple arithmetic, time handling, input/output, reading/writing real-time sound files, filters, equalizers, mixers, event detection, FFTs, oscillators and modulators, delays and reverberation, and classical effects like ring modulators, harmonizers, flangers and a chorus.
Libraries of objects and templates dedicated to building musical applications are also available including:

a virtual room acoustic processor,

a real-time version of a physical modeling sythesis; and

an additive, real-time implementation of analysis and synthesis by inverse FFT algorithms.

A source code distribution is available as Open Source under the GPL. Documentation is scattered about on the site.
[http://www.ircam.fr/equipes/temps-reel/jmax/]
jmtk-cgi: A C library designed to simplify the creation of dynamic Web applications via CGI. The features of jmtk-cgi include:

transparent handling of ISINDEX, GET and POST methods;

parsing data from these methods into variable equals value pairs;

functions for querying and retrieving the pairs;

collection of CGI-specific environment variables;

encapsulation of the initialization of an HTML page;

CGI debugging; and

various utility functions for displaying CGI environment data, escaping strings for system calls, encoding strings for URLs, and loading external files into a document.

A source code distribution is available.
[http://www.cs.hun.edu.tr/turkce/diger/yardim/jmtk/]

Next: Jn-Jz Up: Linux Software Encyclopedia Previous: In-Iz Contents

Manbreaker Crag 2001-03-08