Next: Fa-Fm Up: Linux Software Encyclopedia Previous: Ea-Em Contents

En-Ez

Last checked or modified: Dec. 13, 1999

ENBD: 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.

[http://www.it.uc3m.es/~ptb/nbd/]
ENCLOFX: 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).
[http://www.acm.org/calgo/contents/]
[http://www.netlib.org/toms/index.html]
ENCORE: The EvolutioNary COmputation REpository network is a repository of information on evolutionary computation. It contains information about and links to software which implements classifier systems (CFS), evolutionary programming (EP), evolution strategies (ES), genetic algorithms (GA), genetic programming (GP), and evolutionary algorithms (EA).
[ftp://ftp.cs.wayne.edu/pub/EC/Welcome.html]
[ftp://alife.santafe.edu/pub/USER-AREA/EC/]
Enhydra: An Open Source Java/XML application 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 software engineers.
The Enhydra package consists of three main parts:

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 objects consisting of Java, JavaScript and HTML;

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 process.

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.
[http://www.enhydra.org/]
eNITL: 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 Open Source. The eNITL engine can be useful for server-based Web applications using HTTP, SMTP, HTML, XML, 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 developer's guides.
[http://networkimprov.com/enitl/enitl.html]
Enlightenment: 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.
[http://www.rasterman.com/e.html]
[http://www.enlightenment.org/]
Enquire: 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).
[http://www.cwi.nl/ftp/steven/enquire/]
enscript/genscript: 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.
[http://people.ssh.fi/mtr/genscript/]
[http://www.gnu.org/software/enscript/enscript.html]

Enscriptconfig

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 file.
[http://www.cs.columbia.edu/~etgold/software/]
Ensemble: 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 protocols;

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 communication;

view states, i.e. data structures used for configuring protocol stacks;

layers, i.e. a component with which high-level protocols are implemented;

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 of Ensemble).

Ensemble is implemented in Objective Caml, a dialect of ML, and supports application development in that language as well as in C, C++ and Java. The distribution provides a library of protocols for building complex, distributed applications. It primarily uses UDP/IP sockets and supports IP multicast, although supporting new protocols is relatively simple.
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.
[http://www.cs.cornell.edu/Info/Projects/Ensemble/]
ENskip: 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 instant failover.
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.
[http://www.tik.ee.ethz.ch/~skip/]
ent: 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:

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 source code distribution of this C program is available and it is documented in a man page.
[http://www.fourmilab.ch/random/]
Envision: 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 NetCDF 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 DTM libraries (for data storage and message passing, respectively) be first installed. I haven't yet tried to install this on my Linux box.
[http://www.atmos.uiuc.edu/envision/envision.html]
EO: 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 rank-based procedures;

fitness- and generation-based termination conditions;

several algorithms including easy GA, SimpleGA, and simulated annealing;

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 egcs compiler. A user's guide is available in HTML format.
[http://geneura.ugr.es/~jmerelo/EO.html]
EOFPACK: A set of Fortran codes for performing various types of empirical orthogonal function (EOF) analysis. This codes include:

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 dimension;

cseof_h2D_gx, a 2-D CSEOF algorithm for discrete data sets for situations when the spatial dimension is greater than the time dimension;

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.

See Kim and North (1997) and Kim et al. (1996).
[ftp://flow.tamu.edu/pub/kykim/eigen/]
eon: A shareware Eiffel compiler available in binary format for Linux.
[http://sunsite.unc.edu/pub/Linux/devel/lang/eiffel/]
EOS: 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:

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 source code distribution of EOS is available which requires the GTK package for compilation.
[http://www.ist.org/eos/main.html]
EPAN: 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 dummy device. Source and binary distributions are available for Linux Intel.
[http://packetstorm.securify.com/sniffers/]
Epeios: 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:

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.

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 GCC 2.8.1.
[http://www.epeios.org/]
ePerl: 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.
[http://www.engelschall.com/sw/eperl/]
EPIC: 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 being NetCDF;

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 PostScript format.
[http://www.pmel.noaa.gov/epic/details.html]
EPIC (IRC): An IRC II client. The features of EPIC4 include:

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.

A source code distribution is available.
[http://epicsol.org/]
EPP: An extensible preprocessor for Java. 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 compilers.
[http://www.etl.go.jp/~epp/]
epssplit/epsmerge: Perl programs for splitting an Encapsulated Postscript (EPS) file into several smaller EPS files, and for doing the opposite.
[http://134.219.44.207/~jens/software/epssplit/]
EPTRK: 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 first-order ODEs. EPTRK implements 5- and 8-order methods with stepsize control by embedding. 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 LAPACK libraries.
[http://www.mathematik.uni-halle.de/institute/numerik/software/]
EPWIC: 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 X11 platforms.
[http://www.cis.upenn.edu/~butch/EPWIC/]
ERIDU: 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:

connecting to IMAP or POP servers;

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.

ERIDU is written using PHP.
[http://www.eridu.org/]
Erlang: 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) applications including:

eva, an event and alarm handling application for protocol-independent fault management;

ic, an IDL compiler;

mesh, a measurement handler application for protocol-independent measurement management;

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 programming langauges;

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 applications including:

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 Java; and

ig, an interface for communicating with C programs.

The last category of applications are various tools such as:

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 analyzer, etc.;

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).
[http://www.erlang.org/]
erltools: 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:

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 source code distribution is available which is documented in a set of manuals in PostScript format.
[http://metalab.unc.edu/pub/Linux/devel/lang/c/]
ERoaster: A graphical front-end to cdrecord and 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.

[http://eclipt.uni-klu.ac.at/projects/eroaster]
EROS: 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 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 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.
[http://www.cis.upenn.edu/~eros/]
ERS: 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 matrix systems;

eigenfig, represents eigenvectors and attraction domains for matrix operators of dimension 2 or 3;

gen_gr, generates interaction graphs of given size and structure;

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 recurrences;

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 Petri net;

live_fc, performs liveness tests on Petri nets;

fc2totmatrix, converts a Petri net into matrices for liveness tests;

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 it;

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 with modification;

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.
[http://www-sop.inria.fr/mistral/soft/ers.html]
es: 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
[http://www.webcom.com/~haahr/es/es-usenix-winter93.html http://www.webcom.com/~haahr/es/es-usenix-winter93.html]

[ftp://ferut.sys.toronto.edu/pub/es/]
[http://www.gnu.ai.mit.edu/order/ftp.html]
[http://www.webcom.com/~haahr/es/es-usenix-winter93.html]
ESCHER: 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.
[http://www.db.informatik.uni-kassel.de/~escher/Welcome.en.html]
[ftp://ftp.uni-kassel.de/pub3/inf-db/escher/]
ESEP: 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, etc. 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.
[http://www.iit.edu/~linjinl/esep.html]
esh: 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.
[http://esh.netpedia.net/esh.html]
e-smith: 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 IMAP protocols;

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 and Netatalk;

support for LDAP;

a web-based adminstration interface;

a server-only mode; and

support for a dynamic DNS service.

[http://e-smith.org/]
ESO-MIDAS: 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:

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 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:

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 data reduction;

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 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 structures.
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 built-in functions. 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.
[http://http.hq.eso.org/midas-info/midas.html]
ESP: 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 PostScript format.
[http://star-www.rl.ac.uk/store/storeapps.html]
eSquire: A mailing list manager designed as a replacement for majordomo. This also has additional features including:

Web-based list management;

autoresponders;

integrated support for MHonArc and HyperMail; and

support for banned users.

[http://www.gamerz.net/esquire/]
ESS: Emacs Speaks Statistics is an Emacs-Lisp interface for interactive statistical programming and data analysis. The languages supported include dialects of S including R, XLispStat, ViSta, and SAS. The features include:

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.

The most recent (6/98) version of ESS requires Emacs 19.29 or later or XEmacs 19.14 or later.
[http://ess.stat.wisc.edu/]
Esterel: 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:

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 valid input;

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.

An Emacs mode for Esterel is also available.
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).
[http://www.inria.fr/meije/esterel/esterel-eng.html]
ET: 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 installed.
[http://www.hwaci.com/sw/et/ET.html]
Eterm: A color VT102 terminal emulator for use as an xterm replacement for those using Enlightenment or for those who want a more aesthetically pleasing command-line interface.
[ftp://ftp.eterm.org/pub/Eterm/]
ETERNA: 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.
[http://www.gik.uni-karlsruhe.de/~wenzel/eterna30/]
e-TeX: The result of an international project (the NTS Project) whose aims are to perpetuate and develop the spirit and philosophy of TeX while 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 existing primitives.
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 scantokens commands);

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 commands);

for additional debugging features (e.g. the interactionmode, showgroups, showtokens, tracingassigns, tracinggroups, tracingifs, tracingscantokens commands and additional detail for tracingcommands);

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.
[http://www.rhbnc.ac.uk/e-TeX/]
ETFTP: Enhanced Trival File Transfer Protocol is an adaptive transmission protocol for radio-based data transmission. This implementation is available in both source code and binary distributions.
[http://sunsite.unc.edu/pub/Linux/system/network/file-transfer/]
ETGTAB: 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.

[http://www.gik.uni-karlsruhe.de/~wenzel/etgtab30/]
Ethereal: 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:

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 filter string;

saving all or part of each captured packet to disk; and

support for over a dozen interfaces and packet types.

A source code distribution is available which requires both GTK and libpcap for compilation.
[http://ethereal.zing.org/]
EtherBoot: 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 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 NFS.

A source code distribution is available.
[http://www.slug.org.au/etherboot/]
Ethernet: 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. See Spurgeon (1996), Spurgeon (2000) and Taylor (1995).
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 generator;

NOCOL, a network monitoring package; and

Sniffit, a packet sniffer.

[http://www.ots.utexas.edu:8080/ethernet/]

3c59x

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).
[http://cesdis.gsfc.nasa.gov/linux/drivers/vortex.html]

3c90x

A driver for various 3Com Ethernet cards including 3C900B, 3C905B, 3C905C, 3C980, 3C980B and 3C980C. This driver is available under the GPL.
[http://support.3com.com/infodeli/tools/nic/linux.htm]
EtherTap: 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.
[http://www.linuxhq.com/doc22/networking/]

TapTunnel

A TCP/IP application that allows Ethernet tunnels to be created using the EtherTap device in the newer Linux kernels. 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.
[http://voodooz.extinct.org/~poettering/projects/taptunnel/]

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.
[http://www.worldvisions.ca/tunnelv/]
Ethernet Phone: A package providing real time point-to-point voice communications over the Internet. The features include:

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 a contact;

an X11 GUI; and

virtual duplex voice communication.

Source and Linux binary distributions are available. Documentation is available in a technical report.
[http://www.linuxtel.com/EPHONE/ephone.html]
eThreads: 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 load;

Web-based forum setup;

incremental thread expansion;

full customizability of forums;

support for moderated forums;

language-independent coding; and

support for image sets.

[http://ethreads.com/]
e2fsprogs: A library and set of utilities for working with ext2 filesystems on Linux platforms. 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:

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 a filesystem;

e2fsck, checks an ext2 filesystem;

e2label, displays or changes the filesystem label on an ext2 filesystem;

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 source code distribution is available.
[http://web.mit.edu/tytso/www/linux/e2fsprogs.html]
ETOS: 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.
[http://www.iro.umontreal.ca/~etos/]
etset: 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.
[http://www.fourmilab.ch/etexts/etset/]
Euler: 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.
[http://mathsrv.ku-eichstaett.de/MGF/homes/grothmann/euler/euler.html]
EULEX: 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).
[ftp://elib.zib.de/pub/elib/codelib/eulex/]
EuLisp: A member of the Lisp family of languages which more closely resembles Scheme than Common Lisp. 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 is youtoo.
[http://www.maths.bath.ac.uk/~jap/EuLisp/eulisp-faq.html]
EULSIM: 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).
[ftp://elib.zib.de/pub/elib/codelib/eulsim/]
Euphoric: An emulator for the Oric computer.
[http://members.xoom.com/oric2000/emulator.html]
[http://freespace.virgin.net/james.groom/oric/oricpage.htm]
EusLisp: 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.
[http://ci.etl.go.jp/~matsui/eus/euslisp.html]
evalign: 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 alignments. A source code distribution is available for this Perl 5 program.
[http://www.mrc-lmb.cam.ac.uk/genomes/jong/evalign.html]
EveryAuction: A freeware auction package that makes it easy to set up an online auction site. The features include:

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 auction item;

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 auction;

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 Perl script.

Version 1.5 of EveryAuction has been released under the GPL.
[http://www.everysoft.com/auction/]
EVES: A state-of-the-art formal methods tool that incorporates a unique set of technologies including:

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 specifications;

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.

Binary distributions are available for several platforms including Linux Intel. Documentation includes a user's manual and several technical reports.
[http://www.ora.on.ca/eves.html]
EVMS: 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:

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.

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:

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 system;

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 papers.
[http://oss.software.ibm.com/developerworks/opensource/evms/]
Evolvuton: 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 evolution framework;

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.
[http://www.vrainn.com/evolvuton/]
EvoScript: 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:

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 source code distribution is freely available. The documentation is available in HTML format.
[http://www.evoscript.org/about/]
[http://www.evolution.com/contact]
EvoX: 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.

[http://www.santafe.edu/~vince/EvoXandCpptcl.html]
EVP: 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 and use.
[http://gnarly.lanl.gov/Pop/eclare/evpcode/evp.html]
EWIPE: 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.
[http://www.jnet-jp.to/~sekisita/ewipe/]
executor: 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.
[ftp://ftp.ardi.com/pub/Executor_Linux/]
exim: 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 parameters;

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 addresses;

locking out of SMTP calls from specific idents and SMTP messages from specific senders;

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 program;

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 PostScript format.
[http://www.exim.org/]
exmh: 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 Tcl extensions.
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.
[http://www.beedub.com/exmh/]
eXode: 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 project include:

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.

Check the site often to see what's currently available.
[http://www.simplicity.net/exode/]
Exodus: The EXtensible Object-oriented Database System toolkit has been superceded by the SHORE project.
[http://www.cs.wisc.edu/exodus/]
exopc: 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 called ExOS.
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.
[http://www.pdos.lcs.mit.edu/exo.html]
EXOR: 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:

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 source code distribution is available. This runs on top of Oberon 3.
[http://www.elender.hu/~lfeher/exor/]
Expect: 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).
[http://expect.nist.gov/]

ExpectPy

A Python extension to Expect that incorporates a built-in C type with methods as well as support for Perl-compatible regular expressions. The module is written completely in C for faster performance.
[http://starship.python.net/crew/arcege/ExpectPy/]
Expokit: 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 equations. 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 LAPACK. A user's manual is available in PostScript format.
[http://www.maths.uq.edu.au/expokit/]
expresso: 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.

[http://www.mai.liu.se/~oseno/expresso/]
eXsas: 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:

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.

Single spatial analysis tasks include:

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 plotting;

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 light curves.

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.
[http://wave.xray.mpe.mpg.de/exsas]
exscan: 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:

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.

A source code distribution is available.
[http://exscan.netpedia.net/exscan.html]
Extended-IPL: An operating system (OS) boot selector whose features include:

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.

This works with Linux, FreeBSD and some other OS types.
[http://www.tsden.org/ryutaroh/extipl/extipl.html]
EXTRACTOR: 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 astronomical images.
[http://star-www.rl.ac.uk/store/storeapps.html]
eXtrans: 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.
[http://www.elikya.org]
[http://romualdt.free.fr/pkg/]
ext2fs/Ext2: 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 Ext2 filesystem. This library has been used to create a set of utility programs called e2fsprogs for working with the filesystem.
[http://www.mit.edu/~tytso/linux/ext2.html]
EXT2-OS2: 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. e2fsprogs).

[http://perso.wanadoo.fr/matthieu.willm/ext2-os2/index.html]
ext2resize: A program for resizing ext2 filesystems, hopefully in a nondestructive manner. This is not intended for on-the-fly resizing of mounted filesystems, but instead requires unmounting the filesystem, resizing it, and then remounting it.
[http://www.dsv.nl/~buytenh/ext2resize/]
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.
[http://home.hiwaay.net/ darren/ctags/index.html]
[http://sunsite.unc.edu/pub/Linux/devel/lang/c/]
Eye of Gnome: An image viewer and image cataloging program for the GNOME desktop.
[http://www.gnome.org/gnome-office/eog.shtml]
ezbounce: 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 reattaching later). A source code distribution is available.
[http://druglord.freelsd.org/ezbounce/]
ezd: 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.
[ftp://ftp.digital.com/pub/DEC/ezd/]
eznet: 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.
[http://www.hwaci.com/sw/eznet/eznet.html]
eZpublish: 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.

[http://developer.ez.no/article/static/7/]
EZWGL: The EZ Widget and Graphics Library is written under Xlib and implements both Motif-like widgets and some OpenGL-like graphics commands. 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.
[http://www.ma.utexas.edu/~mzou/EZWGL/]

[ home / linux ]

Next: Fa-Fm Up: Linux Software Encyclopedia Previous: Ea-Em Contents

Manbreaker Crag 2001-03-08