Up: Linux Software Encyclopedia
Last checked or modified: Dec. 13, 1999
- The Enhanced Network Block Device is
a kernel module designed to make the already existing NBD
more robust and useful.
ENBD can be thought of as a long pair of wires that make a remote
disk on another machine act as though it were a local disk, i.e.
it looks like a block device on the local machine where it will
typically show up as /dev/nda.
The remote device can be a whole disk, a partition, or even just a file.
The intended use for this is for RAID over a
network, e.g. you can make an NBD device part of a RAID mirror to
get real time mirroring to a distant backup.
The enhancements over the 2.2 kernel NBD include:
- block-journaled multichannel communications;
- internal failover and automatic balancing between channels;
- the client and server daemons restart, authenticate and reconnect
after dying or loss of contact; and
- the code can be compiled to take the networking transparently
over SSL channels.
- A pair of efficient algorithms for enclosing a zero of a continuous
function. These use both quadratic and inverse cubic interpolation.
This is TOMS algorithm 748 and is documented
in Alefeld et al. (1995).
- The EvolutioNary COmputation REpository
network is a repository of information on evolutionary
computation. It contains information about and links to software
classifier systems (CFS),
evolutionary programming (EP),
evolution strategies (ES),
genetic algorithms (GA),
genetic programming (GP),
and evolutionary algorithms (EA).
- An Open Source
server and development environment.
This was developed in response to requirements for scalable,
manageable and maintainable N-tier client/server applications.
It offers development tools and common object services capable of
supporting rapid development by teams of interface designers and
The Enhydra package consists of three
- Application Framework, an architecture for everything from
how the application source is laid out to a series of object services
that simplify common programming chores including:
- a presentation server for executing pre-compiled presentation
- page redirection for robust error handling;
- configurable session management that provides data persistence
within and between sessions;
- comprehensive user session management providing user
authentication and in-session persistence;
- database connection management supporting connection caching;
- a file server servlet providing basic resource serving abilities; and
- a CGI servlet for launching CGI programs;
- Multiserver, a servlet running environment whose features include:
- a graphical administration console for logging application behavior,
adding and removing applications, and manipulating individual
application attributes; and
- support for several connection options including HTTP,
WAI, CGI and RMI; and
- Development Environment, a clean, consistent, pre-structured
server development environment whose features include:
- a 100% object-oriented design;
- a Jolt compiler for constructing highly maintainable dynamic
HTML presentation objects of integrated HTML and server-side Java;
- access to dynamic data and decoded CGI parameters via Jolt Fields;
- debugger and monitor servlets;
- an XMLC tool that uses the XML approach
to support an object-oriented way of improving the interface between
presentation and content;
- DODS, a graphical design tool for generating data
objects-to-relational database code;
- a predefined layout of source code and associated objects to facilitate
the organization of the application source code components; and
- an application wizard designed to quickly bootstrap the development
A source code distribution of Enhydra is available under
a FreeBSD-style license.
Various online and PDF format documentation
is available including developer's and adminstration guides.
- The Network Improv Template Language is a
scripting language engine for
C++ applications that require flexible,
user-configurable output generation and internal scripting.
The engine is embeddable, extensible, fast,
thread-safe, cross-platform and
The eNITL engine can be useful for server-based Web applications
SGML and other text-based
protocols and data formats.
The significant features of eNITL include:
- embeddability and extensibility;
- use of templates for increased comprehensibility and usability
by end users;
- templates with mixed literal text and eNITL statements;
- the usual flow control structures;
- C-style expression syntax;
- calling templates with a variable number of parameters;
- string processing functions;
- acess to a library of developer-defined functions;
- multiple output streams possible within one template; and
- dynamic execution capabilities.
An Open Source version of the eNITL
package is available for
UNIX and Windoze platforms.
The documentation thus far (2/99) includes online user's and
- A window manager that also provides
a graphical shell in which to work.
This manager is completely configurable via a process called
developing themes, i.e. general styles around which various
details are added.
This is currently (6/96) in a heavy rewrite stage.
- A program which calculates a host of properties of a given
machine, e.g. word length, byte order, minimum and maximum
values for a range of types, etc.
It also creates and outputs the environment enquiry header
files float.h and limits.h which are not available
on some machines and have incorrect values on others.
It also has an option which allows you to check that your
compiler reads the header files correctly (which occasionally
is a problem on some machines).
The source code for Enquire is available. It is written in
C and should be compilable on most available C compilers.
The program is documented in a manual available in both
HTML and PostScript formats.
See Goldberg (1991).
- A GNU package which converts text files
to PostScript format and either spools
the generated output to a printer or prints it to a file.
Enscript supports several different input text encodings
and supplies a choice of several fonts for the output.
Many other command line options are available for handling
unprintable characters, choosing output paper size,
specifying which pages to print, and aligning input files.
The features of enscript include:
- support for many input encodings including ISO-8859/1 through 3 and
5, IBM PC, 7 bit ascii, Mac, VMS Multinational, HP Roman-8, Adobe
Standard Cyrillic, PostScript default encoding, the PostScript
interpreter's ISO Latin 1 encoding, etc.;
- support for AFM files;
- AFM files for the most common PostScript fonts included
in the distribution;
- PostScript font downloading;
- a wide range of output media with new types easily added;
- support for user-defined fancy headers;
- language-sensitive highlighting for over 20 languages;
- N-up printing;
- and various other special features including inlined EPS images,
changing body and color fonts on-the-fly, comments, and
support for PostScript's statusdict and page device.
A source code distribution of enscript is available.
It is written in C and can be compiled and installed on
many different platforms via the autoconf
files supplied with the distribution.
Its use is documented in a man page.
- A front-end to the configuration files for
enscript which provides an easy way
of configuring the many options without having to edit to configuration
- A group communication toolkit project representing the next generation of
the Horus project.
Both projects focus on process group communication structures that arise
in settings involving cluster computing, scalable servers, groupware
and conferencing, and various other related applications.
coordination of control, and various other related applications.
This project focuses on underlying communication systems support for
this model, simplifying and standardizing the interface with the
support environment, and making the model as transparent as
possible for the user.
The Ensemble system can be considered as several things, e.g.
- a general purpose communication system intended for constructing
reliable distributed applications;
- a flexible framework for carrying out research in groupware
- a large-scale, system-style implementation built in a state of the
art programming (i.e. ML) language; and
- a mathematical object amenable to formal analysis and manipulation.
The Ensemble architecture consists of:
- the network, i.e. a medium for transmitting messages between
processes (with send and receive operations although no timing
or reliability guarantees);
- processes, i.e. the unit of state and computation provided by
the underlying OS for executing programs;
- endpoints corresponding to the state and computation associated
with a unique endpoint identifier, and which are used to structure
the communication of processes;
- groups, i.e. the central Ensemble concept and structuring
mechanism, corresponding to computational resources distributed across
some endpoints, each of which coordinates with the others to
provide a service;
- messages, i.e. the objects that are transmitted over the network
(for inter-process communication) and the most basic data structure;
- events, i.e. another data structure used for intra-process
- view states, i.e. data structures used for configuring protocol
- layers, i.e. a component with which high-level protocols are
- stacks, i.e. linear compositions of layers that implement
high-level protocols; and
- applications, i.e. the handlers for one endpoint in one
group (usually considered everything in the process outside
Ensemble is implemented in Objective Caml,
a dialect of ML, and supports application
development in that language as well as in
The distribution provides a library of protocols for building complex,
It primarily uses UDP/IP sockets
and supports IP multicast, although supporting new protocols is
Source and binary distributions of Ensemble are available,
with one of the latter being for Linux platforms.
It can be compiled on platforms supporting
Objective Caml and its UNIX library.
The distribution contains several demo applications including
a collaborative whiteboard demo and a remote process management
demo similar to rsh.
Documentation includes a tutorial and several technical reports.
- A security module for the TCP/IP stack
that provides encryption and authentication of packets on the
IP layer between two or more machines.
SKIP, or Simple Key Management for Internet Protocols, secures
a network at the IP packet level. It is unique in that an Internet
host can send an encrypted packet to another host without requiring
a prior message exchange to set up a secure channel.
The advantages of SKIP include:
no connection setup overhead,
high availability in that encryption gateways that fail can reboot
and resume decrypting packets instantly without having to
renegotiate existing connections,
allowing uni-directional IP (e.g. broadcast via satellite or cable),
scalable multicast key distribution, and
the possibility of configuring gateways in parallel to perform
A source code version of ENskip is available.
It must be compiled as part of the kernel on Linux platforms.
Quite a bit of documentation in the form of techincal reports
and conference papers is available at the given URL.
- A program that applies various tests to sequences of bytes stored in files
and reports the results of the tests.
This is useful for evaluating pseudorandom number generators for encryption
and statistical sampling applications as well as compression algorithms.
The values calculated by the program include:
A source code distribution of this C program is available and it is
documented in a man page.
- the information density or entropy of the file contents expressed
as a number of bits per character;
- a chi-square test to check the randomness of the data;
- the arithmetic mean of the file contents;
- a Monte Carlo evaluation of pi; and
- a serial correlation coefficient that measures the extent to which
each byte in a file depends on the previous byte.
- A software package for the storage, management, manipulation, and
display of large multi-dimensional arrays of numerical data.
Envision is a distributed application, i.e. it is composed of several
separate processes that communicate with each other by passing
messages back and forth. It was designed this way to easily
enable users connecting their own software packages to Envision.
The two main components of Envision are the data manager, which reads and
writes data files, keeps track of what data is where, and passes
data to and from client processes, and the user interface which
displays metadata about the data being managed, e.g. types and
dimensions of variables.
Data is stored in
or HDF files, and
data visualization is performed via interfaces to NCSA
Collage and XDataslice and to IDL.
The source code is available as well as binaries for
IBM, HP, Sun and SGI and DEC Alpha platforms.
Installation from source on platforms for which no binary
exists is a bit more involved than installing the binaries.
It requires that additional packages such as the HDF and
(for data storage and message passing, respectively) be
first installed. I haven't yet tried to install this on
my Linux box.
- A C++ library for evolutionary computation (EC) which
is template-based and ANSI C++ compliant.
EO contains classes for all types of EC except genetic programming, especially
for genetic algorithms.
The features of EO (with all being user-definable) include
- chromosomes including binary, floating
point and string classes;
- genetic operators that can be unary, binary or n-ary
with several floating point, bitstring and generic operators already defined;
- selection procedures with steady state and rank based
procedures already supplied;
- reproduction procedures including predefined random, lotery, and
- fitness- and generation-based termination conditions;
- several algorithms including easy GA, SimpleGA, and simulated
- utilities for command-line parsing and random number generation;
- a GTK-based interface; and
- several examples.
A source code distribution of EO is available. It is written in C++
and has been successfully compiled on Linux platforms using the
A user's guide is available in HTML format.
- A set of Fortran codes for performing
various types of empirical orthogonal function (EOF) analysis.
This codes include:
See Kim and North (1997) and
Kim et al. (1996).
- eigen, a 2-D EOF algorithm for a discrete dataset for when the
spatial dimension is less than the temporal dimension;
- eigenx, a 2-D EOF algorithm for a discrete dataset for when the
spatial dimension is greater than the temporal dimension;
- reof, for rotating regular EOFs to produce a set of
orthogonal, rotated EOFs;
- ceof, for computing complex EOFs where the spatial dimension
is greater than the temporal dimension;
- ceofx, for computing complex EOFs where the spatial dimension
is less than the temporal dimension;
- exteof, for computing 2-D extended EOFs when the spatial dimension
is greater than the temporal dimension;
- exteofx, for computing 2-D extended EOFs when the spatial dimension
is less than the temporal dimension;
- peeofx, for computing 2-D periodically extended EOFs;
- cseof, an exact algorithm for computing 1-D CSEOFs;
- cseof_h, a 1-D CSEOF algorithm based on
the harmonizable assumption;
- cseof_h2D, a 2-D CSEOF algorithm based on the harmonizable
assumption that uses a spectral representation, i.e spherical harmonics;
- cseof_h2D_g, a 2-D CSEOF algorithm for discrete data
sets for situations when the spatial dimension is less than the time
- cseof_h2D_gx, a 2-D CSEOF algorithm for discrete data
sets for situations when the spatial dimension is greater than the time
- pop, for computing principal oscillation patterns (POPs) when
the spatial dimension is greater than the temporal dimension;
- popx, for computing POPs when the spatial dimension is less than
the temporal dimension;
- popcyc, for computing cyclostationary POP patterns when the
spatial dimension is greater than the temporal dimension; and
- popcycx, for computing cyclostationary POP patterns when the
spatial dimension is less than the temporal dimension.
- A shareware Eiffel compiler available
in binary format for Linux.
- The Electronic Object Simulator allows the design of
electronic circuits with logical parts. Parts are chosen from a
selection bar and placed anywhere in a circuit wherein the connections
between them can also be established.
The available logical parts include:
A source code distribution of EOS is available which requires the
GTK package for compilation.
- ANDs and ORs;
- sources and viewers;
- tristate buffers;
- registers/D-Flip Flops;
- XORs and negation;
- blackboxes for embedding saved circuits in other circuits;
- clocks; and
- multiplexers and demultiplexers.
- A protocol analyzer for Ethernet networks.
It allows received frames to be displayed in either an overview
or frame detail mode, and can also compile some statistics.
The supported network media on Linux platforms are Ethernet,
token ring, SLIP, PPP, ISDN, ARCnet, local loopback and
Source and binary distributions are available for Linux Intel.
- A set of C++ libraries featuring a novel concept
of memory management and error handling along with sockets,
multitasking, semaphores, pipes, etc.
The component libraries currently (7/99) include:
Several other libraries are also currently (7/99) available with
more on the way. Most of the documentation is in French, although
it is gradually being translated into English.
These have been successfully compiled with
- BTR, for binary trees;
- CSM, for client/server management;
- CTN, for creating and handling containers;
- ERR, for handling errors;
- FAM, for fast allocation of memory;
- FGM, for dealing with fragmented memory;
- FLW, for input and output flows;
- FNM, for file name management;
- MDR, for memory driving;
- MMG, for memory merging;
- MMI, for multi-memory indexing;
- MTK, for multitasking;
- PIP, for using pipes;
- SCK, for using sockets;
- SHM, for shared memory;
- SPH, for semaphores;
- STK, for using stacks; and
- STR, for working with strings.
- A program which operates on an ASCII file containing Perl 5 statements
and ASCII data by evaluating the Perl 5 statements and ignoring
the ASCII data. It can thus be used as both a standard UNIX filter
for file generation and as a Web server scripting language for
dynamic HTML page programming.
The ePerl program is simply a Perl 5 interpreter which uses a
different source file format.
It is written in C and can be compiled and used on most
generic UNIX systems.
It is documented via an extensive man page.
- A system for the management, display, and analysis of
oceanographic data. EPIC was developed at NOAA's PMEL to manage
the large numbers of hydrographic and time series oceanographic
in-situ data sets collected as part of NOAA programs such as
EPOCS and TOGA.
It provides data archival, retrieval, display, and analysis
procedures for such data, with users able to select data by
data type, latitude, longitude, time range, or other identifying
characteristics. There is also a complete suite of routines
for graphical display and data analyis.
The EPIC system comprises several distinct elements:
- an I/O library lets a programmer work with generic data
file open, read, and write statements with the manipulations
performed by a library module with the primary data format supported
- a data base module based on mSQL which is
used to select data via some desired attribute or attributes;
the PlotPlus scientific graphics
package is used for all graphical needs;
- a suite of data display and analysis programs written in
Fortran and C which can be used to perform a wide range of
manipulations on all types of data as well as to view data
independently of the PlotPlus package;
- a graphical user interface written using the Motif
widget library which allows interactive access to and manipulation
of data sets via a point-and-click interface;
- several utilities for accessing data and graphics via the
Web (written in Perl and Java); and
- a prototype data selection utility written in Java.
A source code distribution of each of the various components
of EPIC is available.
A UNIX distribution is available which is written completely
in C and portable to most UNIX systems.
Extensive documentation is available in the form of man
pages and various user's manuals in
- EPIC (IRC)
- An IRC II client.
The features of EPIC4 include:
A source code distribution is available.
- safety, i.e. no trap doors;
- programmability with additional functionality not included in
the IRC II standard set;
- support for bots;
- full compatibility with the RFC 1459 standard; and
- full ANSI C compliance.
- An extensible preprocessor for
This can be used to introduce new language features, e.g.
a user can specify plug-ins at the top of Java source code to
incorporate various extensions.
The resulting source code can be compiled by ordinary Java
- Perl programs for splitting an
Encapsulated Postscript (EPS) file into several smaller
EPS files, and for doing the opposite.
- A Fortran program that uses explicit
two-step Runge-Kutta methods for parallel computers with shared
memory to solve the initial value problem for nonstiff systems of
EPTRK implements 5- and 8-order methods with stepsize control
The code contains parallel compiler directives for the Convex
Exemplar machines which will be ignored by other machines.
A source code distribution is available which requires and uses
both the BLAS and
- The Embedded Predictive Wavelet Image Coder
is a grayscale image compression utility. It is based on a
wavelet pyramid decomposition whose
coefficients are encoded using a static arithmetic encoder which
uses a generalized Laplacian or Gaussian model of the first-order
statistics of the subbands.
A source code distribution is available. It is written in C and
includes an encoder, a decoder, and a progressive viewer for
- A open source, web-based groupware application similar in functionality
to the Microsoft Outlook and Outlook Web Access products.
The current and planned features include:
ERIDU is written using PHP.
- connecting to IMAP or POP
- MIME and attachment support;
- multiple file attachment support;
- inline attachment viewing;
- an address book;
- a searchable global address list;
- a calendar with event recurrence, meeting request and MIME support;
- sortable do lists; and
- links among all components.
- A programming language
designed specifically for building fault-tolerant,
distributed systems with a large number of concurrent processes.
Erlang is a high-level functional language combining attributes
of declarative languages with constructs for supporting concurrency,
distribution and error detection.
The Erlang Development Environment (EDE) consists of the Erlang
runtime systemi (ERTS), a window-based interface for program development,
and application development tools.
The runtime system consists of:
- an Erlang virtual machine that runs on top of a host OS and
which features memory allocation and real-time garbage collection,
light-weight concurrency and support for thousands of simultaneous
tasks, transparent cooperation among all computers in the system, and
location and encapsulation of run-time errors;
- a kernel that provides low-level services for handling errors
and performing I/O operations;
- a standard library containing a large number of reusable software
modules to aid in program development.
The application development tools and libraries are divided into
four categories. The first category is the runtime system and the
second contains Open Telecom Platform (OTP)
- eva, an event and alarm handling application for
protocol-independent fault management;
- ic, an IDL compiler;
- mesh, a measurement handler application for protocol-independent
- mnesia, a distributed database management system
appropriate for telecommunications applications that require continuous
operation and soft real-time properties;
- mnenosyne, the query language of the mnesia DBMS;
- mnesia session, for accessing mnesia from other
- orber, a CORBA ORB;
- os mon, for monitoring OS system disk, memory usage, etc.;
- sasl, the system application support libraries for alarm
and release handling; and
- snmp, a bilingual SNMP agent featuring
a MIB compiler and facilities for implementing SNMP MIBs.
The third category of Erlang applications are interface and communications
The last category of applications are various tools such as:
- ans1, a compile- and run-time package supporting
ASN.1 basic notation;
- gs, a graphics system containing routines for writing GUIs;
- inets, a set of Web applications such as a server and
an FTP client;
- jive, an interface for intercommunications with
- ig, an interface for communicating with C programs.
- appmon, a utility for supervising applications executing on
more than one node;
- debugger, a debugger for Erlang programs;
- parsetools, a set of parsing and lexical analysis tools;
- pman, a process manager for inspecting the state of the system;
- toolbar, for simplifying access to the tools;
- tools, a set of programming tools including a coverage
- tv, an ets and mnesia graphical table visualizer;
- xerl, an integrated development environment (IDE); and
- xref, which performs statistical analysis on programs.
The source code of the Erlang system has been (12/98) released as
Open Source. It is planned
to also have binary distributions for
Linux and other platforms.
Over a dozen user-supplied applications are also available
at the site.
Voluminous amounts of documentation for each component of the
system are available online. See also the
ETOS Erlang to Scheme compiler.
See Armstrong et al. (1996).
- A set of tools including a C/C++ beautifier, a lexical/syntactic parser
generator with backtrack, and a syntaxic tree manipulation tool.
The tools are:
A source code distribution is available which is documented in a set
of manuals in PostScript format.
- metagen, a parser generator that can handle all grammars using
a backtrack mechanism and which includes, on demand, the function
calls needed to build a tree structure;
- metachop, a tool that provides
a set of functions for displaying and manipulating trees; and
- cpb, a tool for prettyprinting source code.
- A graphical front-end to
mkisofs whose features include:
- writing data and audio CDs and ISO images on the fly;
- drag-and-drop support;
- an informative output window; and
- autoselection of files to fill CDs.
- The Extremely Reliable Operating System
attempts to merge old ideas with newer ones about performance and
resource management to develop a small, secure, real-time
OS that provides orthogonal persistence.
The key features of EROS include:
A distribution is available that can be booted on x86 platforms.
It is currently (12/98) in the throes of some licensing problems but
should be available soon.
- a pure capability architecture wherein authority in the system is
conveyed exclusively by secure capabilities;
- orthogonal global persistence wherein all user states are
transparently saved on a periodic basis;
- kernel-mode threads to enable kernel functionality to be
preempted by higher priority user activities;
- persistent processes that can hold authorities in their own right
rather than inheriting them from the user;
- a minimal kernel size.
- A set of tools for the analysis of discrete event systems.
ERS contains tools for creating graphical representations of discrete
event systems, analyzing the systems and computing performance
measures, and transforming systems from one representation to another.
The tools in the package include:
- acacyc, performs spectral analysis of a deterministic matrix;
- mat2c, transforms the description of a random product of
matrices into a C program that will simulate it;
- mat_sim, performs the simulation of specific types of
- eigenfig, represents eigenvectors and attraction domains
for matrix operators of dimension 2 or 3;
- gen_gr, generates interaction graphs of given size and
- gr_bound, implements bounds on the Lyapunov exponent of
an interaction graph;
- gr2mat, transforms an interaction graph into a Bernoulli
product of matrices;
- gr2c, transforms an interaction graph into a C program
that will perform the simulation of the corresponding stochastic
- gr_sim, simulates the stochastic recurrence equation
corresponding to the evolution of an interaction graph;
- gr2tetris, transforms an interaction graph into a Heap of Pieces;
- tet_bound, computes bounds on the growth rate of a random
Heap of Pieces;
- gen_fc, generates Petri nets with a free choice topology
in the PNL language;
- pn_read, reads a Petri net in a PNL file, performs
neighborhood analysis and dumps the information;
- pn2eg, writes a description in the ECL language of a Petri
net in the PNL language;
- pn2graph, converts a Petri net into graph representation format;
- pn_bound, computes bounds on the marking of places or subnets
of a Petri net;
- pn2lin, computes bounds on the throughput of a Markovian
- live_fc, performs liveness tests on Petri nets;
- fc2totmatrix, converts a Petri net into matrices for liveness
- pn2qnap, transforms a Petri net into an equivalent queueing
network in the form of a QNAP program;
- pn2c, transforms a Petri net into an equivalent queueing
network in the form of a C program;
- live_eg, a topological analysis tool that checks for the
liveness of an event graph;/
- eg2c, converts an event graph into a C program that simulates
- eg2qnap, converts an event graph in the ECL language into a
queueing network with the same behavior;
- eg_sim, simulates an event graph;
- gen_eg, generates event graphs with regular structures of
arbitrary size and stochastic properties;
- eg2eg, transforms an event graph into another event graph
- eg2pn, converts an event graph into an equivalent Petri net in
the PNL language;
- eg2tg, converts an event graph into the same Petri net described as
an equivalent repetitive task graph in the TCL language;
- eg2matrix, translates an event graph into a matrix;
- eg2graph, transforms an event graph into a FIG graphics file;
- m_eg, computes the distribution of the waiting time in a
deterministic event graph driven by a Poisson source;
- tg_read, reads a task graph in a TCL file, performs
neighborhood analysis, and dumps the file;
- tg_crit_path, computes the critical path in a task graph;
- tg_sim, performs a simulation of a task graph;
- tg2qnap, transforms a task graph into a QNAP program;
- tg_read, reads a task graph in the TCL language;
- md1, computes the stationary waiting time distribution in a queue;
- mk1, computes the distribution of the waiting time in a single
server queue with Poisson inputs and known service times;
- mrouted1, computes the value of the average waiting time of
customers in a queueing system;
- onoff_sim, simulates a fluid queue with a single on/off source
and constant capacity;
- mc_solve, numerically attempts to find a stationary
distribution of a Markov chain;
- mc_sim, simulates the evolution of a Markov chain;
- gen_id, generates samples of random variable sequences;
- moment, computes the empirical moment of a sample;
- distrib, computes the empirical distribution of a sample; and
- laplace, computes the empirical Laplace transform of a sample.
The graphical interfaces available in ERS include:
- pned, an editor for Petri nets;
- tged, an editor for task graphs;
- gred, an editor for interaction graphs;
- teted, an editor for Heaps of Pieces;
- Mtool, an application navigator;
- ERS, an editor for Petri nets;
- pnanim, a trace-based animator for Petri nets;
- TGED, an editor for task graphs;
- tganim, a trace-based animator for task graphs; and
- marktool, a Maple interface for solving Markov chains.
Source code and binary distributions of ERS are available, with
one of the latter being for Linux platforms.
The package is documented in a 150+ page user's manual.
- The extensible shell
combines some of the capabilities of functional languages
with those of UNIX shells. Many
internal capabilities of the
shell are available as built-in functions in the language,
and program fragments can be passed around as arguments to
functions. It provides first class functions, lexical scoping,
an exception system, and fucntions that can return values
other than just numbers. Online documentation includes:
- Es: A shell with higher-order functions
- A visual database editor which extends the SQL model of storage and
presentation of data by simple or flat tables.
ESCHER adds stronger structuring facilities such as nested tables,
lists, sets, and graphics to extend the relational model with new
forms of interaction.
This editor prototype includes tree-like storage structures, methods
of visual presentation, query techniques for complex objects, a
cursor concept called fingering, and a self-referencing meta scheme.
Escher is written in C for the X Window enviroment.
A source code distribution is available. A separate file containing
patches for Linux Intel platforms is available in the same
directory as the main source code distribution.
Documentation is included in the distribution.
- The Evolution Scheduling and Evolving
Processes software implements the concept of evolution
scheduling, a mechanism for providing better scheduling for
competing processes in the ready and blocked queues on Linux
platforms. It coexists with the existing priority scheduler
and either can be used, with switching back and forth between
them a simple task.
ESEP substitutes queue and process dispatching for round robin,
priority, and FIFO scheduling, with each evolving process
having the capability of improving its adaptation to the
environment via a fitness function which includes such system
variables as CPU usage rate, I/O throughput load, current time, the
number of processes, the amount of swapping, the amount of disk access,
A genetic algorithm is used to decide the priorities in the queues,
although it is simplified quite a bit to overcome time constraints.
A source code distribution of ESEP is available. It is
written in C and can be compiled and installed on Linux
Intel platforms. It's use is documented in a man page as
well as in a technical report in HTML format.
- The easy shell was created to fill a need for a simple
and lightweight shell for UNIX.
It deviates from most other shells in that it has a
Lisp-like syntax which allows a very small
size in terms of both lines of code and memory consumption while
retaining flexibility and programmability.
A source code distribution of this C program is available as
is a user's manual.
- A simplified Linux distribution (based on Red Hat) that will convert
a PC into a communications server and gateway, e.g. it will provide
email, web hosting, file sharing, etc.
The specific features and functinality include:
- routing and security via IP masquerading;
- the Qmail email server providing
SMTP, POP3 and
- the Apache web server;
- a local network DHCP server;
- the ProFTPD FTP server;
- the Squid web proxy cache;
- a DNS server;
- information sharing sites called i-bays that can be accessed
locally or publicly;
- cross-platform file exchanges via Samba
- support for LDAP;
- a web-based adminstration interface;
- a server-only mode; and
- support for a dynamic DNS service.
- The European Southern Observatory-Munich
Data Analysis System is
a package which provides general tools for image processing
and data reduction with an emphasis on astronomical applications
including imaging and special reduction packages for ESO instrumentation
at La Silla. It also contains packages for stellar and surface
photometry, image sharpening and decomposition, statistics, and
various other tasks.
ESO-MIDAS is designed for the easy integration of complex analysis
algorithms as well as for facilitating interactive use in the creation
of user specific procedures from the basic building blocks provided.
The basic ESO-MIDAS system was designed to work on a single
computer with appropriate peripherals. It consists of the Monitor,
the Applications, and the Interfaces.
The Monitor includes the user interface and the routines for administration
of tasks and local variables. The monitor functions include:
The Applications are what perform actual operations on the data and
can be written in Fortran, C, or Midas Control Language (MCL).
The core applications are split into several groups including:
- displaying on-line help with different levels of detail,
- keeping a log of each session,
- serving as a command interpreter,
- preprocessing input strings to translate user-defined symbols, and
- executing applications in a subprocess.
The Interfaces bind the applications to the monitor and define the
possible interactions with the application task and monitor.
There are standard interfaces for I/O and image access, table
interfaces for access to table structures, and graphics interfaces
for the inclusion of graphical representations of the MIDAS data
- Image Display, which contains the functions expected from
a mature image processing system;
- Graphics Display, which provides the functionality needed for
data presentation in graphical form as well as for interactive
- General Image Processing, which includes operations like filtering,
resampling, interpolation, rotation, FFT, etc.;
- Table File System, which provides a complete set of functions to
process tabular data;
- Fitting Package, which contains tools to fit nonlinear functions and
to model data distributions; and
- Data I/O, which transfers data from and to tape or disk.
The MIDAS Control Language (MCL) provides tools to construct complex
command procedures from existing commands. All MIDAS commands are
MCL procedures themselves.
MCL provides the basic features of a programming language like
parameter definition, looping, conditional statements and branching,
global and local variables, procedure calls with parameters, and
It is an interpreted language for which a debugger is supplied.
The source code for ESO-MIDAS is available.
It is written in C and Fortran and can be compiled on most
UNIX platforms. It has been successfully installed and tested
on DEC OSF/1 and Ultrix, HP-UX, IBM AIX, SGI IRIX, Sun SunOS and
Solaris, VAX/VMS, and Linux Intel systems. A binary distribution
is also available for these platforms.
The AGL graphics library is needed for compilation but is included
in the distribution. The NAG library is also needed for some
calculations, although most of the package can be used without it.
The documentation includes installation and user's guides,
an AGL manual, and several ancillary documents, all of which are
available in PostScript format.
- The Extended Surface Photometry software is
a Starlink Project package
for determining the photometric properties of galaxies and
other extended objects.
It includes applications for:
- detecting flatfielding faults;
- removing cosmic ray events;
- median filtering of images on a defined scale;
- determining whole image statistics including median count, modal count,
kurtosis, and skewness;
- determining local background values on different parts of an image;
- performing galaxy profiling using intensity analysis and contour analysis;
- fitting 2-D Gaussian profiles to galaxies;
- generating pie slice cross-sections of galaxies;
- detecting faint diffuse objects in an image; and
- displaying profiling results.
A binary distribution of ESP is available for DEC OSF/1,
Linux Intel, and Sun Solaris platforms. It is documented
in an 83 page user's guide available in
- A mailing list manager designed as a
replacement for majordomo. This
also has additional features including:
- Web-based list management;
- integrated support for MHonArc and
- support for banned users.
- Emacs Speaks Statistics is an
Emacs-Lisp interface for interactive statistical
programming and data analysis.
The languages supported include dialects of S including
ViSta, and SAS.
The features include:
The most recent (6/98) version of ESS requires Emacs 19.29 or later
or XEmacs 19.14 or later.
- source code editing features such as syntactic indentation and
source code highlighting, partial evaluation of code, and source
code revision maintenance;
- process interactions including command-line editing, a searchable
command history, transcript recording, command-line completion, and
an interface to the help systems; and
- transcript manipulation including editing transcripts and
re-evaulating commands from transcript files.
- A language for programming reactive systems as well as a compiler
which translates Esterel programs into finite-state automata.
Esterel is part of a family of synchronous languages particularly
well suited to programming reactive systems, e.g. real-time systems
and control automata.
The compiler generates either C code which can be embedded in
a larger program which handles the interface and data manipulations
or hardware in the form of netlists of gates which can be embedded
in a larger system.
Separately available Esterel ancillary programs include:
An Emacs mode for Esterel is also available.
- sccheck, a constructive causality checker which checks
the constructiveness of the reaction as well as the respect of
single signal emission contraints for any reachable state and
- Xeve, a GUI environment for the symbolic analysis and verification
of Esterel programs which features finite state machine (FSM) model
construction as well as FSM minimization and verification of safety
properties expressed by observers;
- fc2symbmin, which analyzes Mealy FSM under the form of fc2 automata
produced from Esterel;
- basicopt, a tool for the optimization of controllers synthesized
from Esterel which can optimize either the critical-path of the hardware
circuit or the size of the generated C code; and
- occ, an ANSI C code generator.
Binary distributions of the Esterel compiler
and all of the separate programs are available for
DEC Alpha, Sun SunOS and Solaris, and Linux Intel programs.
The documentation includes a primer and a user's guide available
in PostScript format as well as
several technical reports.
See Berry and Gonthier (1992).
- Embedded Tk is a tool for making stand-alone executable
programs from a mixture of C or C++ and Tcl/Tk.
ET can be used to invoke a short Tcl/Tk script in the middle of a C
routine or a C routine in the middle of a Tcl/Tk script. It also
bundles external Tcl/Tk scripts into the executable so it can be
run on other binary compatible machines which don't have Tcl/Tk
- A color VT102 terminal emulator
for use as an xterm replacement for those using
Enlightenment or for those who want a more aesthetically pleasing
- A Fortran 77 Earth tide analysis package for
the analysis of hourly Earth tide observations for gravity and tilt.
ETERNA can be used for
adjusting tidal and meteorological parameters from Earth tide
observations, the computation of Fourier spectra, and the visualization
of observations, residuals and spectra.
- The result of an international project (the NTS Project) whose aims
are to perpetuate and develop the spirit and philosophy of
respecting Donald Knuth's wish that TeX should remain frozen.
This package is an evolutionary descendant of TeX which is directly
derivable from the TeX sources.
The e-TeX package contains 35 new primitives for added functionality,
29 of which are extensions (which do not affect the semantics of
existing TeX documents) and 6 of which are associated with an
enhancement. Additional functionality was also added to some
The new features include those that provide:
- additional control over expansion (e.g. the protected,
detokenize, and unexpanded commands);
- for re-scanning already read text (e.g. the readline and
- for environmental enquiries (e.g. the eTeXrevision,
eTeXversion, currentgrouplevel, currentgrouptype,
ifcsname, ifdefined, and lastnodetype commands);
- for the generalization of the mark concept (e.g. the
marks, botmarks, firstmarks, topmarks,
splitfirstmarks, and splitbotmarks commands);
- for bi-directional typesetting such that the conventional
left-to-right typesetting direction can be reversed for all or
part of a document (e.g. the TeXXeTstate, beginL,
beginR, endL, endR, and predisplaydirection
- for additional debugging features (e.g. the
interactionmode, showgroups, showtokens,
tracingassigns, tracinggroups, tracingifs,
tracingscantokens commands and additional detail for
- and miscellaneous primitives (e.g.
everyeof, middle to specify that a delimiter is to
serve as both a left and right delimiter, and unless to allow
the sense of all Boolean conditionals to be inverted).
The e-TeX system is supplied as a change-file which needs to
be applied to TeX.Web in the normal way (with further gory
details provided at the Web site).
The e-TeX software is completely TeX-compatible and thus only
one instance should be needed, but the change files and binaries
will be produced such that both TeX and e-TeX can coexist as
separate binaries on the same system.
- Enhanced Trival File Transfer
Protocol is an adaptive transmission protocol for radio-based
This implementation is available in both source code and
- A Fortran 90 program for calculating Earth tides.
ETGTAB computes tables of Earth tide values (tidal potential, accelerations,
tilts) for specific stations, and can use any of three different
tidal potential developments or observed tidal parameters.
The routines comprising ETGTAB are:
- ETASTE, computes the astronomical elements;
- ETGCOF, computes the geodetic coefficients;
- ETGREG, computes the Gregorian date;
- ETJULD, computes the Julian date;
- ETMUTC, computes the difference between UTC and TDT;
- ETLOVE, computes elastic parameters;
- ETPOTA, computes tidal amplitudes, frequencies and phases from
the tidal potential development; and
- GEOEXT, computes and prints the execution time.
- A network protocol analyzer that allows you to examine data from a live
network or from a capture file on disk. This is designed to have
functionality similar to NetXRay or EtherPeek.
The features of Ethereal include:
A source code distribution is available which requires both
libpcap for compilation.
- reading live data from Ethernet,
PPP or token ring interfaces;
- browsing captured data via a GUI;
- printing packet data to a file or a printer with output in plain
text or PostScript;
- refining the data display using a tcpdump-style
- saving all or part of each captured packet to disk; and
- support for over a dozen interfaces and packet types.
- A package for booting x86-based machines over a network.
This is used to load both Linux and DOS although the protocol and
boot file format is general enough to load arbitrary images.
This can be used for maintaining a cluster of equally configured
workstations, a low-cost X11 terminal, various kinds of remote
servers, routers and various other specialty tasks.
The components needed by EtherBoot for network booting are:
A source code distribution is available.
- a bootstrap loader which is usually an EPROM on a NIC card but
could be put anywhere in the address space in which the BIOS probes
(and can even be run from a floppy in some situations);
- a bootp or DHCP server for assigning
IP addresses and other information when sent
an Ethernet card address, i.e. a MAC address;
- a TFTP server for sending the kernel
images and other files required in the boot process;
- an NFS server for providing the disk
partitions mounted if Linux is being booted;
- a Linux kernel configured to mount the root partition via NFS; and
- optional compiled-in support for mounting a swap partition via
- A type of network cabling and signalling specification
technically known as a CSMA/CD computer communications network
over coaxial cabling.
CSMA/CD (i.e. Carrier Sense Multiple Access, with Collision
Detection) is the media access control mechanism used by Ethernet
which determines how a packet of data is place on the wire.
It listens to find if another device is transmitting and, if not,
startings sending data packets while simultaneously listening for
another device to start sending simultaneously (i.e. a collision).
Linux (and other) platforms interface to the Ethernet via
network cards designed for the task.
Spurgeon (2000) and
Related software packages include:
- btng, a package of network measurement software;
- Card Services, a PCMCIA support package
for Linux platforms;
- EPAN, a protocol analyzer for Ethernet networks;
- GASH, a shell for network adminstration;
- IPTraf, a network monitor and statistics
- NOCOL, a network monitoring package; and
- Sniffit, a packet sniffer.
- An Ethernet card driver for various 3Com-based
cards including the PCI/EISA Etherlink III Vortex series (3C590, 3C592,
3C595 and 3C597), the PCI Etherlink XL Boomerang series (3C900 and 3C905),
the Cyclone series (3C905B) and the Tornado (3C905C).
- A driver for various 3Com Ethernet cards
including 3C900B, 3C905B, 3C905C, 3C980, 3C980B and 3C980C.
This driver is available under the GPL.
- A special network interface available in Linux kernel 2.1.x or greater.
It allows the direct sending and receiving of
Ethernet-like frames in a stream that
is processed by the kernel.
- A TCP/IP application that allows
Ethernet tunnels to be created using
the EtherTap device in the newer
This is a single-threaded program that can be a client or a
standalone or INETD-based server.
The connection is encrypted using the
mcrypt package, with both hosts required
to authenticate the other.
- Tunnel Vision
- Creates an encrypted Virtual Private Network (VPN) between two Tunnel
Vision-capable sites on the Internet. Realistically, that
means sites with a Linux server running
Tunnel Vision or with a Worldvisions Weaver acting as their Internet gateway.
This requires kernel 2.2.X and uses the
EtherTap network interface.
RSA and Blowfish encryption are used to authenticate remote servers.
- Ethernet Phone
- A package providing real time point-to-point voice communications
over the Internet. The features include:
Source and Linux binary distributions are available.
Documentation is available in a technical report.
- real time voice communications via the Internet;
- point-to-point rather than client/server mode;
- a daemon that informats the user when someone is attempting
- an X11 GUI; and
- virtual duplex voice communication.
- A database-centered package for running threaded discussion
forums. It uses an SQL backend and supports
multiple completely customized forums off the same scripts.
The features and functionality include:
- running on multiple servers for redundancy and spreading the
- Web-based forum setup;
- incremental thread expansion;
- full customizability of forums;
- support for moderated forums;
- language-independent coding; and
- support for image sets.
- A library and set of utilities for working with ext2 filesystems on
The library is designed to allow user level programs to manipulate
an ext2 filesystem. It is divided into sections based on functionality
including filesystem level, inode, directory, bitmap, ext2 data abstraction,
byte-swapping and miscellaneous functions.
The utilities included in e2fsprogs include:
A source code distribution is available.
- badblocks, searches for bad blocks on a device, e.g. a partition;
- chattr, changes the file attributes on a Linux ext2 filesystem;
- debugfs, a debugger that can be used to examine and change the
state of an ext2 filesystem;
- dumpe2fs, prints the superblock and blocks group information for
- e2fsck, checks an ext2 filesystem;
- e2label, displays or changes the filesystem label on an ext2
- fsck, checks and optionally repairs ext2 filesystems;
- lsattr, lists the file attributes on an ext2 filesystem;
- mke2fs, creates a Linux ext2 filesystem;
- mklost+found, creates a lost+found directory in the
current working directory on an ext2 filesystem; and
- tune2fs, adjust tunable filesystem parameters.
- A compiler that transforms Erlang
programs into Scheme programs.
The generated code takes advantage of special features of
the Gambit Scheme compiler.
A source code distribution is available.
- A C program that translates human readable
electronic texts prepared according to a set of document
preparation guidelines into LaTeX,
HTML or ASCII.
A source code distribution is available.
- A numerical laboratory with an interpreted programming language.
The features of Euler are:
- real, complex, and interval scalars and matrices;
- a programming language with local variables, default values for
parameters, variable parameter numbers, and function passing;
- 2- and 3-D plotting capabilities;
- marker, density and contour plots;
- numerical integration and differentiation;
- statistical functions and tests;
- differential equation solvers;
- interval methods with guaranteed inclusions;
- function minimizers and the Simplex algorithm;
- interpolation and approximation;
- polynomial root finding; and
- calling functions in external DLLs.
A source code distribution of Euler is available as is
a binary for Linux Intel platforms.
An extension user's guide is available in HTML format.
- An explicit extrapolation integrator for non-stiff systems of
ordinary first-order differential equations.
It is based on explicit Euler discretization with h-extrapolation.
EULEX is written in
Fortran 77 and documented via comment statements
in the source code.
This is part of CodeLib.
See Deuflhard (1983a).
- A member of the Lisp family of languages which more closely
resembles Scheme than
The distinguishing features of EuLisp are
the integration of the classical Lisp type system and the object
system into a single class hierarchy, the complementary
abstraction facilities provided by the class and the
module mechanism, support for concurrent execution
via light-weight processes,
and an integrated object system
and meta-object protocol.
EuLisp was developed by a loose consortium of industrial and
academic users around Europe who thought that Scheme wasn't
enough and Common Lisp was too much for their needs.
The main features of the language include:
- classes that are first-class objects, i.e. the class structure integrates
the primitive classes describing fundamental datatypes, the predefined
classes, and user-defined classes;
- modules together with classes are the building blocks of both the
language and of applications written in the language;
- multiple control threads can be created in EuLisp and the
concurrency model has been designed to allow consistency across
a wide range of architectures;
- both functions and continuations are first-class in EuLisp, although
the latter are not as general as in Scheme since they can only be
used in the dynamic extent of their creation;
- a condition mechanism which is fully integrated with both classes
and threads which allows for the definition of generic handlers and
supports both propagation of conditions and continuable handling; and
- the creation of dynamically scoped bindings, although their
use is restricted as in Scheme.
An implementation of EuLisp
- An integrator for stiff systems of
ordinary differential equations.
It is based on semi-implicit Euler discretization with h-extrapolation.
EULSIM is written in
Fortran 77 and documented via comment statements
in the source code.
This is part of CodeLib.
See Deuflhard (1983a) and Deuflhard (1985).
- An emulator for the Oric computer.
- An integrated programming system for research on intelligent robots
based on Common Lisp
and object-oriented programming.
EusLisp is an object-oriented Lisp which implements an extensible
solid modeler and includes such features as intertask communication,
an X Window user interface, and a foreign language interface to support
mixed language programming.
EusLisp features include:
- single-inheritance object-oriented programming
in which all data types except numbers are represented by objects whose
behaviors are defined in their classes;
- a compiler that speeds up execution
speeds from 3 to 30 times over the interpreter;
- memory management using
the efficient Fibonacci buddy method;
- a number of geometric primitives
provided as built-in functions;
- the capability of defining solid models
from primitive bodies using CSG set operations;
- hidden-line and-surface eliminated drawing to the screen
or to PostScript files;
- edge-based image processing;
- the modeling of robot manipulators;
- the binding of most UNIX system calls
and library functions to Lisp functions; and
- multithreaded programming.
The EusLisp package can be obtained either as source code or
in binary format for SGI IRIX, Linux Intel, Sun SunOS, and Windows 95
platforms. The documentation is contained within a user's guide
in PostScript format.
- A program implementing an evaluation method for protein sequence
alignment. Evalign compares computer with structural alignments
and determines how correct a sequence alignment program is.
It uses a parameter called the position shift rate (psr) derived
from the number of incorrect alignment positions compared to the
correct structural alignments to quantify the comparison of
A source code distribution is available for this
Perl 5 program.
- A freeware auction package that makes it easy to set up an online
The features include:
Version 1.5 of EveryAuction has been released under
- a comprehensive user interface that simplifies navigation;
- auction classifieds or a more traditional auction setting;
- support for HTML front-ends;
- unlimited categories and items;
- category listings that list items, closing time, and current bid;
- an automated email validation registration system;
- system-generated passwords sent to users via email;
- user-updated contact information;
- item posting by any registered user;
- posting item images along with descriptions;
- reserve prices for setting minimum sell prices above minimum bids;
- seller-determined minimum bid increment and auction length;
- unique ID numbers and URLs for each item;
- listing of bidding history and product information;
- outbid emails automatically sent by system with a link back to the
- sniper protection via closing auctions at a configurable time after
the last bid and the designated closing time;
- an integrated search engine for searching by username or keyword;
- deletion or updating of auction items by administrator;
- email automatically sent to high bidder and seller at close of
- fast reposting of unsold items;
- an advanced file locking system that eliminates the risk of data
corruption even during heavy bidding; and
- all features contained within a single, fast
- A state-of-the-art formal methods tool that incorporates a unique
set of technologies including:
Binary distributions are available for several platforms including
Linux Intel. Documentation includes a user's manual and several
- a language called Verdi that is a formal notation based on a version
of untyped set theory that can be used to express rigorous mathematical
concepts, thus providing an alternative to higher-order languages;
- a proof obligation generator that automatically emits the
assertions that must be proven to demonstrate certain important
properties including that the code is in consonance with the
- an automated deduction system called NEVER, i.e. an interactive
theorem prover capable of automatically performing large proof steps
as well as being finely directed by the user;
- an interpreter; and
- a compiler.
- The Enterprise Volume Management System
is a type of Logical Volume Management (LVM) architecture designed
to allow the recognition of different LVMs among operating systems.
It consists of two basic components:
A salient feature of EVMS is the ability to accept plug-in modules.
The architecture calls for five classes of these for performing the
needed range of tasks:
- the LVM Runtime that runs in kernel space and allows the
operating system to access and use properly configured volumes; and
- the LVM Engine for the creation, configuration, and management
of volumes, volume groups, partitions and the disks on which they reside.
- Device Managers for communicating and managing the storage devices
available to the systemi, e.g. local storage or SAN managers;
- Partition Managers for recognizing and manipulating the partition
information on a device, e.g. DOS or Macintosh partition managers;
- Volume Group Emulators for volume group support and emulating
volume group-based LVMs, e.g. an AIX VGE for accessing and manipulating
volume groups created by the LVM in the AIX OS;
- Features for assembling volumes and providing specific capabilities
on the volumes, e.g. drive linking, RAID, mirroring, encryption, etc.; and
- Filesystem Interface Modules for performing basis tasks such as
formatting, checking, and resizing as well as gathering information
about the filesystem in use on a volume before performing operations
that would effect the filesystem.
The levels of abstraction in the basic EVMS architecture include:
- Logical Disks, an abstraction introduced to provide a standard,
consistent method for accessing the storage devices available to the
- Logical Partitions, a generic memory management system for tracking
metadata, partitions and free space on logical disks introduced to ensure
that EVMS wasn't tied to any particular partitioning scheme;
- Volume Groups, constructed from one or more logical disks and/or
partitions and introduced to allow EVMS to emulate volume group based
LVMs found on other operating systems;
- Logical Volumes, the final layer of abstraction and what is
visible to the operating system.
EVMS is open source and available under the
GPL version 2.
The documentation currently available includes a couple of white
- A set of C++ libraries (developed using the egcs
compiler) for creating intelligent systems, i.e. software and entities
that can behave in an intelligent manner.
The goal is to create a generic component that allows any other
object to evolve in a way similar to that observed in nature.
The Evolvuton package currently (3/98) consists of four components:
- evolvuton, a set of C++ templates and classes that allow
objects to evolve which allows implicit or explicit fitness, doesn't
require a numeric fitness function, and provides a decoupled generic
- investbot, a component that automatically invests in the
stock market using evolutionary computation;
- stock, a component to read stock information; and
- ookit, a collection of commonly used components including
memory management templates, data classes, design patterns, and various
other classes to cache objects, handle exceptions, test functions, and
generate random numbers.'
A source code distribution of Evolvuton is available. It is written
in C++ and developed using the advanced template
capabilities of the egcs compiler.
Documentation is available in PostScript format.
- A database-enabled Web application framework written in
Perl. It provides an extensible class framework
and an easy-to-use embedded scripting syntax.
EvoScript features include:
A source code distribution is freely available. The documentation
is available in HTML format.
- tag-based scripting that simplifies form and
table generation and includes conditionals, looping and ohter
constructs for easy embedding of application logic in HTML pages; and
- an OOP database interface providing retrieval and content
handling capabilities and that can generate database-specific SQL
statements on the fly.
- A tool for the simulation of complex systems which consists
of an object based
C++ class system and various analysis tools.
It has a Tcl/Tk interface and makes
extensive use of [incr Tcl] for
object-oriented capabilities. This provides a largely
parallel class hierarchy that embodies the interface-relevant
parts of a given model world.
EvoX is organized into five separate C++ libraries, i.e.
- CppTcl, which implements a Tcl interpreter stream class and
classes to implement the glue which connects Tcl commands to objects;
- CppTclExtra, which builds on CppTcl to give the user
a simple way to have class members easily accessible from Tcl;
- EvoXLib, which contains a number of useful utility procedures
and Tcl objects used by the rest of the code;
- EvoXTclExtra, which contains useful utility procedures; and
- EvoXBaseClasses, containing base classes from which the
standard EvoX hierarchy is descended.
- The Elasto-Viscous-Plastic sea ice dynamics
model is a code developed at LANL.
It reduces to the standard viscous-plastic dynamics model at
time scales associated with wind forcing while at short time
scales the adjustment process takes place by a numerically
more efficient elastic wave mechanism. This leads to a fully
explicit numerical scheme which improves the model's computational
efficiency as well as makes it more amenable for use on parallel
machines, although the present (4/97) code is designed for use
on parallel machines.
The EVP distribution includes the source code, written in
Fortran 77, and a technical
report describing its details
- A tool based on Tcl/Tk for creating
presentations. The features include a GUI editor, use of plain
text data, and a viewer.
This requires Tcl 7.6 and Tk 4.2 or greater.
- A MacOS emulator
which features fast CPU Emulation (75 MHz 486DX4 approximates 25 MHz
68040) and allows many Macintosh applications, including
Word 5 and Excel 4 to run without requiring anything
from Apple. It reads, writes and formats 1.4 MB
Macintosh formatted floppies, reads and writes SCSI
Macintosh disks, and reads Macintosh formatted CD-ROMs.
It has color support and prints to PostScript printers, and includes
demo applications so you can run it with no Macintosh
experience. The demo has a 10-minute limit.
- A mail transport agent (MTA) developed
at the University of Cambridge for use on UNIX
systems connected to the Internet.
Its features are similar to those of Smail 3 although more
extensive, including features for defence against mail bombs
and unsolicited junk mail in the form of options for refusing
message from particular hosts, networks, or senders.
Exim takes a similar approach to Smail 3 in that mail is
delivered via indpendent delivery processes rather than by
a central process. It differs in that these delivery processes
share data in the form of hints kept in DBM files while make
delivery more efficient in some cases.
Exim uses the sendmail interface so it can be a straight replacement
for /usr/lib/sendmail and implements all the relevant sendmail options.
The main features of Exim include:
- many configuration options which can be given as expansion strings;
- the availability of regular expressions in a number of configuration
- domain lists which can include file lookups which makes it possible
to support a large number of local domains;
- flexible retry algorithms applicable to routing as well as delivery;
- header and envelope rewriting facilities;
- acceptance of unqualified addresses only from specified hosts or networks;
- multiple deliveries down the same SMTP channel
after deliveries to a host have been delayed;
- configuration to do local deliveries immediately and delay remote
deliveries until the message is picked up by a queue-runner process;
- remote delivers which can be done in parallel if copies of a message
are to be delivered to more than one remote host;
- support for optional checking of incoming return path and receiver
- locking out of SMTP calls from specific idents and SMTP messages from
- control over which hosts may use the Exim host as a relay;
- the freezing and thawing of messages on the queue;
- control of maximum message sizes;
- handling of a number of independent local domains on the same machine
via virtual domains;
- an optional built-in mail filtering facility which enables users to
set up their own mail filtering without having to run an external
- support for multiple user mailboxes controlled by prefixes or suffixes
on the user name;
- human-readable delivery failure messages; and
- an optional monitor which displays inofrmation about Exim
processing in an X Window.
The source code for Exim is available. It is written in ANSI C
and supports IBM AIX, BSDI, FreeBSD, HP-UX, IRIX, Linux, NetBSD,
Digital UNIX, SCO, SunOS, and Ultrix platforms.
It is documented in an overview, a specifications manual, and
a filter guide, each available in
- An X11 interface for MH
mail which allows you to view messages in a folder, read them,
delete them, and file them. In addition, the interface handles
arbitrary nesting of a folder hierarchy.
Exmh can sort arriving mail into different folders before it
is even read, and it can be sorted with the MH maildelivery
mechanism, procmail, or any system that adds new messages to
the unseen sequence of a folder. It highlights which folders
have new mail, and highlights messages that haven't been read
within a folder. MIME format messages
are parsed and displayed by exmh, and there is some support
for composing MIME messages.
Exmh is written in Tcl/Tk and thus can
be customized on several levels: the 20 modules that comprise
exmh each have a few aspects that can be changed in a preference
interface; the button and menu structure is defined via X
resources and more can be added to change its appearance;
Tk widget attributes such as colors, fonts, and cursors are
also controlled by X resources and can be changed;
new functionality can be added via a personal library of
The latest distribution (2.0) requires Tk 4.1 or higher and
includes the complete source code for exmh. Documentation is
available onsite as well as in the distribution.
- A project to create a set of integrated tools with a common,
coherent, and customizable interface which allow the management
of UNIX systems (especially Linux) running the
X Window graphical environment.
The tools will be separately usable and won't require a
specific window manager.
Applications currently (5/97) under development in the eXode
Check the site often to see what's currently available.
- eXode, the desktop itself;
- Fred's Own Filemanager (fof), a expandable
filemanager with a powerful GUI;
- System Info's Managing Processes (SIMP), a front-end for
the /proc filesystem;
- XntHelp, a widget for the eXode help application;
- Quaids' Editor, a mini Xaw-based editor for X to
edit configuration files;
- Motif-based Resource Editor (MRE), an
X resources management project which uses the editres protocol to
interactively edit the X resources; and
- a main configuration tool.
- The EXtensible Object-oriented Database
System toolkit has been superceded by the
- An exokernel-based OS that runs on x86 hardware.
The exokernel concept eliminates the notion that an operating system
should provide abstractions on which applications are built.
It concentrates instead solely on securely multiplexing the raw
hardware. Application-level libraries and servers directly
implement from hardware primitives traditional OS abstractions
specialized for appropriateness and speed.
The current (12/98) system consists of an exokernel called
XOK which runs on PC hardware and a library operating system
The exopc distribution contains the source tree for the XOK
kernel, the ExOS library OS, and various user-level programs
and tools for building the system.
This can be build on Linux or OpenBSD with libc6.
- The EXtensible simulatOR is an object-oriented digital
circuit simulator and scheme editor. The editor is hierarchical
and the number of inputs, depth of hierarchy, and number of scrollable
views on the desktop environment are unlimited.
The features include:
A source code distribution is available. This runs on top
of Oberon 3.
- simple and powerful editor functions;
- interactive simulations;
- gates, flip-flops, multiplexers, demultiplexers, counters and decoders;
- tri-state, open-collector, and totem-pole outputs;
- no limit on inputs and outputs;
- extensible element libraries;
- a library management tool;
- high, low and undefined logical and impedance levels;
- a digital scope; and
- error detection.
- A scriptinglanguage
to talk to interactive programs like
ftp, telnet, fsck, and others that cannot be automated from a
shell script. This runs on top of
the Tcl/Tk toolkit and as such requires
its installation. It should easily install on any UNIX platform
on which Tcl/Tk already exists. The source code is available.
See Libes (1994).
- A Python extension to
Expect that incorporates a built-in C type
with methods as well as support for Perl-compatible
The module is written completely in C for faster performance.
- A set of routines for computing matrix exponentials of the kind
that arise frequently in control theory problems, e.g. in physical
systems governed by the Chapman-Kolmogorov system of differential
Expokit computes either a small matrix exponential in full, the action
of a large sparse matrix exponential on an operand vector, or
the solution of a system of linear ODEs with constant inhomogeneity.
At the core of the sparse routines are Krylov subspace projection
methods which allow the handling of very large matrices.
Expokit can handle real and complex matrices and provides
specific routines for symmetric and Hermitian matrices.
Distributions of the Expokit routines are available in both
Fortran and Matlab versions.
Compilation and use of the former requires the prior installation
of both BLAS and
A user's manual is available in PostScript format.
- A C++ template library providing arrays designed
for efficient numerical computations.
The features include:
- completely automatic memory handling using reference counting, i.e.
no memory leaks;
- efficiency via no temporary objects in expressions and the
parenthesis operator for fast elementwise access;
- arbitrary rank and element types in template arguments, e.g.
the size and index ranges of an array can be changed at runtime and
dimensions may be permuted and reversed;
- passing pointers to Fortran routines if
they are declared as Fortran arrays and indexed as usual; and
- extensibility to allow the definition of new types of specialized
arrays, e.g. banded or sparse matrices.
- The extended X-ray scientific analysis
system is for the interactive analysis of X-ray and XUV data
with particular emphasis on data from the ROSAT mission.
This is based on the ESO-MIDAS image
processing system and consists of packages for data preparation,
spatial analysis, spectral analysis and timing analysis.
The data preparation pacakge is for filtering, formatting and
correcting data for further processing.
The spatial analysis package handles source detection as well as
single spatial analysis tasks.
The source detection tasks performed include:
Single spatial analysis tasks include:
- the creation of images and masks for source detection;
- local, map and maximum likelihood source detection, i.e.
source parameter determination;
- source detection of ROSAT HRI data;
- local and map detection on ROSAT WFC data; and
- determining the extent and galactic coordinates of a source.
- creating images adapted for spatial analysis tasks;
- background estimation and source detection;
- handling source tables;
- estimation of source parameters;
- calculation of intensity profiles and point spread functions;
- coordinate transformations; and
- creating and labelling contour plots.
The eXsas spectral analysis package allolws the reduction of a spectrum
of single counted photons to a selection of paramters such as temperature,
spectral index, photon or energy flux, and luminosity that describe
the energy state of the radiating object. It is designed so all instrument
features are separated into standard and extensible modules to make it
as instrument-independent as possible.
The timing analysis package includes commands for:
- arrival time correction;
- power spectrum, autocorrelation and cross-correlation analysis and
- detecting signals in power spectra;
- frequency-time image handling, conversion and display;
- plotting Kolmogorov-Smirnov output;
- integration of chi-square distributions; and
- plotting light curves, accepted times intervals and folded
A source code distribution of eXsas is available as are binary
packages for several platforms including Linux Intel.
It is written in Fortran except for
various MIDAS-compliant components written in C.
A user's guide and various other documentation are available
in several useful formats.
- A port scanner that uses the
strobe scanning technique wherein only
a chosen subset of all ports are scanned.
In addition to port scanning it can also:
A source code distribution is available.
- find the users on finger;
- find the server version on HTTP;
- display information returned by the server (e.g. server type and
version) for FTP, SMTP, etc.); and
- remotely identify the OS type.
- An operating system (OS) boot selector whose
This works with Linux, FreeBSD and some
other OS types.
- booting any OS on any hard disk recognized by the
BIOS if the target OS supports it;
- booting an OS from an extended partition;
- no usage of disk space beyond the first sector;
- independence of any OS on the hard disk, i.e. it can operate with
with OS combination;
- booting an OS even if its partition isn't marked as bootable; and
- works from a floppy disk as well as from a hard disk.
- A program for automatically detecting objects on an astronomical
image and building a catalog of their properties.
This was developed and is particularly suited for the reduction
of large-scale galactic survey data, but can work with other
- A package for translating XML documents into other
formats or representations. It can output text, sound or anything
else that can be manipulating via Python.
- The Second Extended File System is currently (10/99) and has been the
most widely used filesystem for Linux platforms.
An initial alpha version of ext2fs was released in January 1993
to solve problems encountered when using
the Extended File System, i.e. its precursor.
It solved most of the problems and was designed with extensibility in
mind, containing hooks that can be used to add new features.
It included the standard features one expects from UNIX filesystems as
well as several advanced features including:
- file attributes that allow users to modify the kernel behavior when
acting on a set of files;
- selecting either BSD or System V Release 4 semantics
at mount time;
- optional BSD-like synchronous
updates, i.e. a mount option for metadata to be written synchronously
on the disk when they are modified;
- an option to choose the block size when creating the filesystem;
- fast symbolic links that don't require data blocks on the filesystem,
i.e. the target name is stored in the inode;
- a special field in the superblock used by the kernel code to keep
track of the status of the filesystem, i.e. to decide whether the state
is ``clean'' or ``not clean'' at boot time;
- two mechanisms for forcing filesystem checks at regular intervals: both
a mount counter and last check/maximal check interval times maintained
in the superblock;
- an attribute for secure deletion of files wherein random data is
overwritten on the disk blocks previously allocated to the deleted file; and
- new filetypes inspired by the 4.4 BSD including
immutable files that can only be read and append-only files that can be opened
in write mode but into which data can only be appended.
A library called libext2fs was developed along with the filesystem
to allow user mode programs to manipulate the control structures of an
This library has been used to create a set of utility programs called
e2fsprogs for working with the filesystem.
- A package which allows OS/2 to access Linux ext2 formatted disc
partitions from OS/2 as if they were standard OS/2 driver letters.
The goal of this software is to be able to use the ext2 file system
as a replacement for FAT or HPFS, although for the moment (8/97)
it lacks support for OS/2 extended attributes.
The EXT2-OS2 package consists of:
- a 32-bit OS/2 file system driver which allows read/write access
to a Linux ext2 filesystem,
- a filter driver which allows OS/2 to see type 83 partitions and
allows the reordering of all hard disk drive letters,
- a pair of special drivers which allow OS/2 to boot from a Linux
ext2 file system; and
- an OS/2 port of the Linux ext2 file system utilities (i.e.
- A program for resizing ext2 filesystems, hopefully in a nondestructive
This is not intended for on-the-fly resizing of mounted filesystems,
but instead requires unmounting the filesystem, resizing it, and then
- Exuberant Ctags
- An improved implementation of ctags, which
generates an index (or tag) file of C language objects found in C
source and header files that allows them to be quickly and easily
located by a text editor or similar utility. A tag is defined as
a C language object for which an index entry is available.
This can also generate a cross-reference file which lists information
about the objects found in C language files.
This implementation improves upon the original by finding all types of
C language tags, handling preprocessor conditional constructs better,
supporting the output of Emacs-style tags files, and
printing out lists of selected objects found in source files.
Source code and binary distributions are available.
- Eye of Gnome
- An image viewer and image cataloging program for the
- A configurable IRC proxy whose features include
password protection and remote administration and access control.
It can listen and connect on different virtual hosts on a machine
and has a detach features that allows clinets to disconnect from the
proxy while keeping their IRC session active (with the option of
A source code distribution is available.
- A graphics server that sits between an application program and the
X server and allows both existing and new programs easy access to
structured graphics. In structured graphics application-defined
graphical objects are ordered into drawings by the application.
Drawings are displayed by mapping them into windows, with multiple
drawings capable of being mapped onto a window and a drawing capable
of being mapped onto multiple windows.
Pan and zoom operations are performed by remapping a drawing, and
PostScript renderings of the contents of a window are produced
via a single command.
Objects in drawings can be made interactive by making them
sensitive to mouse and keyboard events. An application supplied
Scheme expression is evaluated when an
event occurs on such an object.
The expression may simply relay the event to the application, or
the entire application can be written in Scheme and embedded
in the server.
A source code distribution of ezd is available. It is written in
Scheme and requires the
Scheme-to-C compiler since the
ezd source must be compiled to C and then linked with a system
specific version of the Scheme-to-C runtime library.
The package is documented in a technical report available
in PostScript format.
- A program designed to make is easy to get PPP
running under Linux.
You supply a name for an ISP, a login name, a password and a phone
number and eznet supplies the rest of the information needed to
properly configure the PPP setup.
A source code distribution of this C program is freely available.
- A web-based application suite built using PHP.
The features include:
- advertising with statistics;
- article publication and management;
- bug handling and reporting;
- calendar functionality for creating appointments and events;
- contact handling for keeping track of people and businesses;
- a file manager for keeping track of uploaded files;
- moderated discussion forums;
- an image manager for keeping track of uploaded images;
- a link manager for categorizing links;
- fetching news and headlines from other sites;
- a poll module;
- a session module for keeping track of users and preferences;
- a statistics module for information about page views and visitors;
- a to-do module for assigning tasks;
- a trade module for online shopping with shopping carts and wish lists;
- user management for registration and access;
- speed enhancements via data caching and reduced database connections;
- support for cookie-less sessions; and
- support for several languages.
- The EZ Widget and
is written under Xlib and implements both
widgets and some OpenGL-like
Currently (5/96) implemented widgets include labels, buttons,
radio buttons, listboxes, textwidgets, sliders, menus, notebooks
and a 3DCanvas for the graphics library.
The GL features include zbuffer, gouraud and flat shading,
dithering, lighting, polygon, line, point and string rendering,
and support for mouse and keyboard input devices.
EZWGL is released under the GPL and has been tested on
Sun SPARC, SGI Indigo, DEC Alpha and Linux platforms.
[ home /
Up: Linux Software Encyclopedia