Next: Dn-Dz Up: Linux Software Encyclopedia Previous: Cn-Cz Contents

Da-Dm

Last checked or modified: Dec. 12, 1999

daemons: Software packages that involve UNIX daemons include:

ACAPd, a daemon implementing an Internet protocol for remote accessing client program options;

AgentD, a modular scheduling daemon;

AgentX, a protocol specifying a method by which subagents can advertise and export MIB regions;

AMD, a daemon that maintains a cache of mounted file systems;

BIND, an Internet name server package;

bpowerd, a power daemon for controlling specific UPS units;

BWNFSD, an RPC daemon used with a client NFS for DOS-based PCs;

Card Services, a PCMCIA support package;

chrony, for maintaining the accuracy of the system clock;

CMU-SNMP, an implementation of SNMP;

daemontools, a set of programs to automate some system tasks;

DBOX, a BBS package with a mailing list daemon;

dhcpcd, a DHCP client daemon;

DSC, an environment for distributed processing;

fetchpop, a POP3 mail client;

genpower, a UPS power daemon;

HPVM, a package for high performance computing on distributed machines;

IMSPD, a server daemon implementing the IMSP protocol suite;

inet6-apps, a collection of IPv6-aware applications;

inetutils, a package of common networking utilities and servers;

JNet, a collection of miscellaneous UNIX commands;

LAM, an MPI programming environment;

lbnamed, a load balancing name server;

Linuxconf, a system administration tool;

Linux Phone Project, a project to use phones over the Internet;

masq, management utilities for a Linux firewall;

masqdialer, a daemon for initiating and terminating dialup connections;

MBone, a protocol for multicasting live audio and video via the Internet;

mEDA-2, an extension to PVM;

MON, an extensible service monitoring network daemon;

MRT, a multi-threaded routing toolkit for building multicast daemons;

NetKit, a collection of basic network tools;

NTP, a network time protocol;

Perfs, a tool for distributing processes among several machines;

PIKT, a package for administering heterogeneous networked workstations;

ProFTPD, an FTP server daemon;

PVM, a library and daemon for message passing;

rapd, a daemon for sending text messages to radio pagers and mobile telephones;

rinetd, a redirection server;

rjobs, a remote periodic job agent/daemon;

Rover, a network management package;

RSVP, a protocol with support for quality of service flows;

rtnppd, a TNPP daemon;

SandiaXTP, an implementation of the XTP protocol;

SANE, a package implementing a universal interface to scanners;

Spread, a toolkit and daemon for providing multicast communications over a network;

sysdaemon, a UNIX system monitor;

Taylor UUCP, a package implementing the UCCP protocol;

TCP_wrappers, a daemon for controlling access to network services;

ud, an uptime daemon;

uptimed, an uptime daemon;

util-linux, a collection of many Linux utilities;

Watchdog, a daemon that checks if a system is working;

watchlogd, a daemon that rotates system logs;

wu-ftpd, an FTP server daemon;

xinetd, a replacement for inetd;

ypserv, an NIS server daemon;

ZedKit, a Z39.50 toolkit;

Zephyr, a notice transport and delivery system;

ZMailer, a mail transport agent; and

Ztalk, a voice communication tool.
daemontools: Several programs to perform and automate some system tasks. The programs include:

supervise, which starts a service and restarts it if it dies;

svc, which stops, pauses, or restarts a service on request;

svstat, which prints a one-line status report;

cyclog, which writes a log to a disk, automatically synchronizes it every 100 KB, and automatically rotates it to keep it below 1 MB;

accustamp, which puts a precise timestamp on each line of input in TAI format;

tailocal, which converts TAI timestamps to local time;

usually, which watches a log for lines that don't match specified patterns and copies the lines to stderr;

errorsto, which redirects stderr to a file;

setuser, which runs a program under a user's uid and gid and, unlike su, doesn't gain privileges or check passwords and cannot be run except by root.

A source code distribution is available.
[ftp://koobera.math.uic.edu/www/daemontools.html]
DAEPAK: See MANPAK.
DAFLOW: A program for streamflow routing in upland channels or channel networks. DAFLOW is a digital model for routing streamflow using the diffusion analogy form of the flow equations in conjunction with a Lagrangian solution scheme. It is not applicable and therefore should not be used where backwater effects are significant or where flow reversals occur. It uses only two adjustable coefficients per branch, i.e. the wave celerity and wave attenuation coefficient, and these must remain constant. The model is designed to provide reasonable predictions of discharge and transport velocity using a minimum of field data and calibration. It is designed to support the BLTM transport model, but should also be useful for general flow routing applications.
A source code distribution of DAFLOW for UNIX platforms is available. The primary documentation is contained within Jobson (1989). This is part of the USGS Water Resources Applications Software collection.
[http://water.usgs.gov/software/daflow.html]
[http://www.geogr.uni-jena.de/software/daflow.html]
D'Agents: A transportable agent system written in an extended version of Tcl. This is implemented as two components: an extended Tcl interpreter and a server that runs on each machine. A source code distribution is available.
[http://www.cs.dartmouth.edu/~agent/]
DAGH: The Distributed Adaptive Grid Hierarchy is a data management infrastructure for parallel adaptive mesh refinement (AMR) techniques. It consists of two components: a set of programming abstractions in which computations on dynamic hierarchical grid structures are directly implementable and a set of distributed dynamic data structures that support the implementation of the abstractions in parallel execution environments and preserive efficient execution while providing transparent distribution of the grid hierarchy across the processing element execution environment.
DAGH features include:

transparent access to scalable distributed dynamic arrays/grids/grid-hierarchies,

multigrid/line-multigrid support within AMR,

a shadow grid hierarchy for on-the-fly error estimation,

automatic dynamic partitioning and load distribution, and

locality, scalability, portability and peformance.

High level programming abstractions include application objects, coarse-grained data parallelism, Fortran compliant data storage, and more. DAGH also includes HDF-based I/O support, interactive visualization support (via xgraph), and checkpoint/restart support.
The DAGH package includes the source code which will run on IBM SP2, SGI PowerChallenge, Cray T3D, and networked UNIX workstations. The latter port requires the MPI package and, as mentioned, visualization support requires the xgraph package. A preliminary (3/97) user's guide is available in PostScript format. DAGH is part of the Computational Toolkit for Numerical Relativity.
[http://www.caip.rutgers.edu/~parashar/DAGH/]
Dancer: An IRC robot that supports Danish, Dutch, English, Norwegian and Swedish. The features of Dancer include:

single-channel and highly configurable;

password protection of critical commands;

protection against flooding and channel takeover;

awareness of netsplits;

database of answers to FAQs;

relaying messages between users;

support for Client To Client Protocol (CTCP); and

support for Direct Client to Client Chat (DCC).

A source code distribution of this C program is available and has been successfully compiled on several UNIX flavors including Linux.
[http://www.fts.frontec.se/~dast/dancer/]
dante: A free implementation of a SOCKS v4/v5 client and server. The current (9/99) version implements:

SOCKS protocol version 4;

SOCKS protocol version 5 without GSSAPI as described in RFC 1928;

username and password authentication for SOCKS v5 as described in RFC 1919; and

encryption support using SSL.

The features of Dante include:

a design for both security and scalability;

multi-layer access controls;

enables server applications to be SOCKSified;

capable of SOCKSifying most programs at runtime without recompilation;

allows clients to resolve hostnames through SOCKS V4 servers;

works with TCP wrappers (libwrap); and

experimental msproxy support.

A source code distribution is available under a BSD/CMU-type license.
[http://www.inet.no/dante/]
DAOPHOT: A Starlink Project package is a stellar photometry package designed to deal with crowded fields. DAOPHOT performs various tasks including finding objects, aperture photometry, obtaining the point-spread function, and profile-fitting photometry. Profile fitting in crowded regions is performed iteratively to improve the accuracy of the photometry. The package consists of the DAOPHOT program and three additional routines which produce output files from results obtained with DAOPHOT (which cannot by itself display results). These routines are: DAOGREY, which produces a grey scale image of the data; DAOPLOT, which will indicate the positions of objects found with DAOPHOT on top of the grey image produced by DAOGREY; and DAOCURS, which will put up a cursor on the display to allow positions to be measured from the screen.
A binary version of the DAOPHOT package is available for Linux Intel, DEC OSF/1, and Sun Solaris platforms. It is documented in a user's manual available in PostScript format.
[http://star-www.rl.ac.uk/store/storeapps.html]
DAP: The Digital Audio Processor is a comprehensive audio sample editing and processing suite. DAP features include:

support for AIFF, AIFF-C, RAW and WAV audio files;

support for 8 or 16 bit resolution;

support for 1, 2 or 4 channels of audio data;

full time stretch resampling;

manual data editing; and

a reasonably complete DSP suite.

This is available as either source code or a Linux ELF binary.
[http://www.cee.hw.ac.uk/~richardk/]
DaRT: The Data Retrieval Tool is a Java application used for the simultaneous retrieval of documents and archived scientific instrument data that can be accessed via the Web. The features include:

scheduling downloads for later times;

downloading retries for failed downloads;

downloading the most recent version of documentation;

support for internal host name resolution;

configurable target and destination directories; and

starting the program from the command line or a browser.

[http://monet.astro.uiuc.edu/ADC/DaRT/]
Darwin: An operating system ased on the foundation technologies of the Mac OS X Server. This is an advanced BSD UNIX system with advanced networking, the Apache web server, and support for both Mac and UNIX filesystems. It will run on both Power Mac and Intel x86 architectures. Darwin may develop independently of the Mac OS X, although the two code bases will periodically be synchronized. The entire project consists of both Apple and third party subprojects, with the latter including ports of the GNU utilities. An online form must currently (5/99) be completed to gain free access to the source code.
[http://www.publicsource.apple.com/projects/darwin/]
Darxite: An FTP system consisting of a daemon whose job is to retrieve files and execute other FTP commands, and a number of clients programs whose jobs are to control the daemon and to provide a spiffy user interface. The features of Darxite include:

control and monitoring via client programs that are easy to write for any underlying GUI development environment;

auto-resuming of transfers when possible;

automatic switching to mirror sites if a transfer becomes too slow; and

spooling of transfers.

The clients currently (1/99) included in the package are:

DarxGet, obtains a URL from the command line;

NoctFTP, an FTP client written using GTK;

DarxStat, displays the current transfer status;

DarxStat-GTK, DarxStat in a GTK window;

dxFTP, a command-line FTP client; and

DarxCmd, a low-level utility for sending commands to the daemon.

A source code distribution is available.
[http://www.hell.ukgateway.net/darxite/]
Dash: Note: This project has had its name changed to Dash, so check their for further information. A servlet framework for building secure, dynamic websites. Dash is designed such that development can proceed in Java without having to learn or switch to XML/XSL/XSP or some other template language to obtain the HTML and logic abstractions required by template-based Web applications. It can even be easily integrated with existing WebMacro and FreeMaker websites by creating special screens to parse templates. These screens can also be created to read files from other websites as well as from off disk.
Dash is composed of five different modules that each serve a specific service within the framework and which are each defined in an object-oriented fashion. These are:

an Action module that represents a piece of code that performs a task, e.g. a piece of code to read the contents of a submitted HTML form;

a Page module that is first in the chain of execution for page generation and which contains the remainder of the modules;

a Screen module that is essentially the body of the web page and where the HTML of the page is generated;

a Navigation module with a top and bottom scheme generally defined as the header and footer of the site; and

a Layout module that defines the physical layout of a web page, generally defining the location of the Navigation portion as well as the location of where the body or Screen of the page will be.

Daily snapshots of the Dash development package are available under the LGPL.
[http://www.working-dogs.com/dash/]
DASSL: A Fortran 77 package which solves a system of differential-algebraic equations (DAEs) of the form g(t,y,y') = 0. It uses the backward differentiation formulas of orders one through five to solve a system of the above form for y and y' with initial values for both as input. The system is solved for some specified time period t to t. Single and double precison versions called, respectively, SDASSL and DDASSL are available.
A source code distribution of DASSL is available. The routines are written in Fortran 77 and documented via comment statements contained within each source code file. This is part of CMLIB.
[http://sunsite.doc.ic.ac.uk/public/computing/general/statlib/cmlib/]
data formats: Software dealing with data formats includes:

Boulder, a semantic free data interchange format used in the biosciences;

CDF, a self-describing data abstraction for the storage and manipulation of multidimensional data in a discipline-independent format;

CGNS, a format for storing, retrieving and modifying CFD data;

CIF, a standard means of information exchange in crystallography;

DRS, a data retrieval and storage library used mainly for climate model output;

FITS, the format adopted by the astronomical community for data interchange and archival storage;

FlexIO, an API for storing multidimensional data that hides the differences between underlying formats;

GeoTIFF, a TIFF-based interchange format for georeferenced raster imagery;

GRIB, the World Meteorological Organization standard for gridded meteorological data;

HDF, for the storage and exchange of scientific data;

IEEEIO, a library for storing multidimensional data in a portable binary format based on IEEE 754;

NetCDF, an interface for scientific data access which implements a machine-independent, self-describing, extendible file format;

OpenMath, a standard for communicating mathematical objects between computer programs;

SAIF, a Canadian national standard used for the exchange and archiving of geospatial data;

SDDF, a data description language and an API implementing its specifications;

SDTS, a standard for transferring earth-referenced spatial data between dissimilar computer systems;

SEDRIS, a standard for describing and exchanging environmental data; and

VPF, a standard format and structure for large geographic databases.

[http://www2.echo.lu/oii/en/oiistand.html]
database: Informative sites related to Linux and/or databases include:

Linux SQL Databases and Tools
[http://linas.org/linux/db.html]

Free Database List
[http://www.iam.unibe.ch/~scg/Archive/Software/FreeDB/FreeDB.list.html]

RDBMS List
[http://www.hex.net/~cbbrowne/rdbms.html]

Object-Oriented Databases
[http://www.rhein-neckar.de/~cetus/oo_data_bases.html]

Database software available for Linux platforms includes:

ACEDB, an object-oriented DB originally developed to organize molecular biology data but with wider application;

BeagleSQL, a client/server DB which uses SQL;

CACTVS, a chemical information database system;

cdb, a fast, reliable and lightweight package for creating and reading constant databases;

Coral, a project to develop a deductive database system and investigate its use in several application domains;

CQL++, an SQL and ISAM database management system;

DataSplash, a database visualization environment;

DB, the latest version of the classic Berkeley db utilities;

dbedit, a system for integrating and developing web DB applications that is part of the GNU project;

dbMetrix, an SQL database frontend tool that supports most of the freely available SQL implementations;

ESCHER, a visual database editor which extends the SQL model via nested tables, lists, sets, etc.;

FLORID, an object-oriented database prototype whichuses F-logic as a definition and query language;

FramerD, a portable, distributed, object-oriented database designed to support the maintenance and sharing of knowledge bases;

FreeTDS, a free implementation of the Sybase call level interface library DB-Lib;

Gadfly, a Python package providing relational database functionality;

gdbm, the GNU library of database functions;

GiST, a C++ library for implementing a database indexing scheme called Generalized Search Tree;

Glimpse, a powerful indexing and query system;

GSS, a relational database system which supports the full SQL89 dialect with some extensions from SQL92;

id-utils, a set of GNU utilities for implementing an ID database;

IronDoc, a structured storage system for creating object networks of multimedia content;

Kappa, a parallel database management system;

LEAP, a relational DB management system written as an educational tool;

libsql++, a C++ library that wraps ODBC calls into an object-oriented interface;

LINCKS, a DB system developed for complex information system applications;

Mariposa, a distributed DB management system that addresses fundamental problems in the standard approach to distributed data management;

MDBMS, a relational DBMS for complex database work;

MG, a collection of programs which comprise a full-text retrieval system for huge databases;

mSQL, a DB designed to provide fast access to stored data with low memory requirements;

MUMPS, a programming language oriented towards database applications;

mxODBC, a Python DB compliant interface to ODBC databases;

mysql, a small and fast relational DB;

OPT++, a tool for database query optimization;

PostgreSQL, a DBMS research prototype that used to be called POSTGRES and Postgres95;

PTool, a DB tool providing data persistence and which supports the creation, storage, access and querying of complex objects;

Qddb, a database suite with many functions and which supports many search techniques;

Quixote, a deductive, object-oriented database language that's part of the ICOT project;

rdb, a reliable database library based on cdb;

Remembrance Agent, a program that displays a list of documents relevant to a user's present context that it locates in a database back-end;

ROL, a deductive object-oriented database system;

SHORE, a project to design a persistent object system to serve the needs of a wide variety of databases;

SQL Server, a portable multiuser DBMS;

SQRL, a project to build an ANSI SQL-92 compliant DB;

Swish, a tool for creating indexes of files and searching them;

TSIMMIS, a project to develop tools for the rapid integration of heterogeneous information sources including structured and semistructured data;

WDB, a toolkit for integrating SQL databases into the Web;

WIDD, a database GUI front-end written in Java;

WODA, a database written in Perl for creating flat multimedia databases;

Xbase, a library for manipulating Xbase-type data files;

xmbase-grok, a simple database manager and user interface builder; and

XSB, a research-oriented logic programming and deductive database system.

See Bancilhon and Buneman (1990), Castano et al. (1994), Kim (1995) and Whitehorn and Marklyn (1998).
DATAPLOT: This is a powerful, flexible scientific, engineering, statistics, mathematics and graphics system. It is an interactive, command-driven language/system with English-like syntax developed at the National Institute of Standards and Technology in response to data analysis problems. An early version of a graphical user interface is available as of July 1995 that requires both the TclTk and Expect packages.
The capabilities include raw graphics (e.g. 2-D, 3-D, contour and color plots), analysis graphics (e.g. plotting data and functions, mixing data and functions, etc.), presentation graphics (e.g. Hershey fonts, Greek symbols, PostScript output, etc.), summary graphics (e.g. pie charts, histograms, error bar plots, X-Y plots, etc.), diagrammatic graphics, graphical data analysis (e.g. scatter plots, probability plots, etc.), exploratory data analysis (e.g. box plots, robust smoothing, linear/polynomial/nonlinear fitting, general transformations, bootstrap plots, etc.), time series analysis (e.g. lag plots, autocorrelation plots, spectral plots, Fourier plots, etc.), smoothing, fitting, statistics and probability calculations, multivariate analysis, experiment design, a large number of math functions, and much more. Further details about the DATAPLOT capabilities are available.
The source code is available as well as binaries for Convex, DEC Alpha, HP-9000, IBM RS6000, SGI and Sun platforms. It can be compiled on most generic UNIX platforms with Fortran and C compilers, the latter being necessary for X11 support. There is also a source code only C version of the program created by running the Fortran source code through the f2c program. The documentation is contained in several flat ASCII text files, including files describing new features, the command set, and several help files. The README file says that hardcopy documentation is also available.
I compiled the C source code version on my Linux box with GCC using a DATAPLOT Makefile rather than with the supplied shell scripts. The stripped ELF binary is 11+ Mb and running it also causes about 9 Mb of uninitialized data arrays to reside in RAM, so I'd recommend at least 24 Mb of RAM to run this thing. I've also created hypertext wrappers for the overview, new features, command dictionary, and command overview documents that will allow you to get a better feel for this package without having to download an 8 Mb documentation file. If the web page is down, try the DATAPLOT FTP site.
[http://www.itl.nist.gov/div898/software/dataplot.html/]
Datapult/PF: A tool for generating dynamic HTML documents. PF can be used to create and process user input forms without writing a CGI program. The pages created can automatically react to the capabilities of the browser as well as information sources such as SQL databases or user-written modules. It can be used in a server mode where a pool of processes in continually running in its own native server pool with a CGI stub client. There is a module for the Netscape Enterprise server and one under development for Apache. It can run as a FastCGI server under the Openmarket or Apache servers. PF can also be used as a scripting language for the shell to perform, e.g., complex database manipulation tasks via utility scripts.
A source code distribution is available as are binary versions for Linux Intel and Alpha. The documentation is online and still a bit sketchy as of this writing (2/98).
[http://datapult.com/products/pf/]
DataSplash: A database visualization environment which combines a sophisticated navigation model with a paint program interface with which users can create custom visualizations. In addition to the standard features of a paint program DataSplash contains a window which shows rows from a database table to be visualized. Each row is assigned a location on the drawing canvas, i.e. the rows are scattered across the canvas giving an effect similar to a scatter plot. At any point the user can select an object on the canvas and duplicate it for every row in the database table, which gives the effect of splashing paint across the canvas.
DataSplash also incorporates a sophisticated navigation model with which users can zoom, pan, teleport, and link to other canvases. Object changes representation as users zoom closer to them, and a layer manager is provided which allows users to program the way objects behave during zooming. Portals (windows which go to other canvases) can be specified for some or all objects on the canvas.
A beta (4/97) version of DataSplash is available as source code or in binary format for DEC Alpha, HP/UX, Linux Intel, and Sun Solaris platforms. Documentation is available in the form of an online user's manual in HTML format.
[http://s2k-ftp.CS.Berkeley.EDU:8000/tioga/]
Data Visualization Toolbox: A Matlab toolbox for data visualization. The programs in this toolbox are for working with and visualzing various types of data:

univariate data including characterizing a distribution, comparing distributions and transforming data;

bivariate data including curve fitting, visualizing residuals, robust fitting, discrete values, time series and seasonal components;

trivariate data including scatterplots, coplots, image plots, surface fitting, contour plots, mesh plots and surface plots;

hypervariate data including scatterplots and color scatterplots; and

multiway data including multiway dot plots, additive fits, and color scatterplots.

[http://www.datatool.com/Dataviz_home.htm]
Datbkr: A multicall, tar-based shell script along with a small program called tarblocks designed to work with partitionable DAT drives for performing backups. The source code is available.
[http://www.psychosis.com/datbkr/]
DAV: Distributed Authoring and Versioning is a protocol specifying how to use HTTP to provide enhanced capabilities to a web server. It is envisioned as a method for authoring pages without proprietary packages. Other planned capabilities include document management, complex configuration management, and many other types of web-based data repositories. It is sometimes called a web-based filesystem augmented with properties for the directories and files. This is also sometimes called WEBDAV.
[http://www.lyra.org/greg/dav.html]
[http://www.ics.uci.edu/pub/ietf/webdav/]
DAVID: The DAta VIsualization and Diagnostics package an interactive visualization environment that allows the user to interact with numerical or simulation data. In this environment the user can interactively allocate memory for the data, manipulate and display it. These tasks can also be specified in an executable command file. The results can be displayed in an X Windows screen or used to create a PostScript file.
The features of DAVID include:

support for multiple windows and displays;

black and white and color screen support;

a C language-like programming syntax;

multi-dimensional variables in memory and disk in multiple formats and of different types;

automatic conversion from one variable type to another;

a large set of built-in mathematical functions;

a large library of display routines (e.g. X-Y plots, 2-D contour plots and images, 3-D display of 2-D data arrays with hidden line removal, etc.);

interactive graphics animations with movie-like capabilities;

an interactive graphics editor;

an interactive diagnostics system and feature tracking; and

an interactive color map editor and threshold changer.

It is written in C to run on UNIX systems under X Windows using the Athena widget set and other standard X11 libraries. There are binaries for SGI, SUN, DEC Alpha, IBM and HP platforms, and the source code is also available. The package is documented in a 113-page PostScript user's manual.
[http://vizlab.rutgers.edu/vizlab_group_files/RESEARCH/VISIOMETRICS/DAVID/index.html]
daVinci: A visualization tool for automatically drawing high quality direct graphs written using the ASpecT functional language. It can be used to visualize hierarchies, dependency structures, networks, configuration diagrams, dataflows, etc. It combines hierarchical graph layout with powerful interactive capabilities and an API for access from a remote application.
The features of daVinci include:

automatic graph layout with edge-crossing and bend minimization;

interactive fine tuning for a given layout;

control of node and edge attributes including color, font, shapes, icons, etc.;

interactive abstraction operations such as collapsing subgraphs and hiding edges;

scaling functions for getting an overview;

navigation and search features for browsing a graph;

multi-graph, multi-view, and survey-view visualizations;

a choice of layout orientations;

encapsulated PostScript output;

a Motif-like interface with a file browser, icon bar, keyboard support, etc.; and

an integrated help system with online documentation.

The daVinci package is available in binary format for several UNIX platforms including Sun SunOS and Solaris, HP-UX, IBM-AIX, SGI IRIX, Digital UNIX, DEC Ultrix, and Linux Intel (ELF and a.out). The documentation is available online in HTML format in the built-in help system.
[http://www.Informatik.Uni-Bremen.DE/~davinci]
DB: The Berkeley DataBase is a toolkit providing embedded database support for both traditional and client/server applications. This is the newest version of the classic Berkeley db utilities. DB includes APIs for C, C++, Java and Perl. The features include:

various database access methods including B+ tree, extended linear hashing, fixed/variable length records, keyed and sequential retrieval, partial-record data storage and retrieval, architecture independent databases, and more;

transaction support including multiple readers/single writer locking, two-phase page-level locking, degree 3 isolation, and before and after image logging;

database recovery after application or system failure and online database backups;

a modular architecture in which object handles are free-threaded and therefore support concurrent access via threaded programs; and

extensive administrative functionality via both standalone utilities as well as through the API.

A source code distribution of DB is freely available for non-commercial applications. It is written in C and can be compiled on most UNIX systems. Documentation is via an extensive set of man pages available in various formats.
[http://www.sleepycat.com/]

py-bsddb

A Python 1.5.2 interface to Berkeley DB developed using SWIG 1.1.
[http://electricrain.com/greg/python/bsddb3/]
dbedit: A system for integrating and developing web database applications that has been adopted as part of the GNU software project. Dbedit separates the display of information from its storage. A database is displayed by creating an HTML form and then running a Perl script on it which generates a CGI wrapper for the script. This method allows arbitrary Perl code to be added to database applications. An application can be integrated with any database by writing a driver routine since display and storage are separated. Thus the database implementation can be changed without rewriting forms, and forms can be changed without rewriting the databse.
A source code distribution of dbedit is available. It is written in Perl and requires version 5. A manual is included in the distribution.
[http://www.gnacademy.org/uu-gna/tech/dbedit/dbedit.html]
DBI: The DataBase Interface for Perl 5 is an ongoing effort to design and implement a database-independent interface for database connectivity which abstracts the complexity of database technologies from the programmer. The DBI API specification defines a set of functions, variables and conventions that provide a consistent database interface independent of the actual database being used. The database-dependent code for a wide range of available databases is extracted and placed into database drivers (DBDs). These implement all of the methods defined by DBI API for each specific database and are transparent to the user. A source code distribution is available along with modules for over fifteen different database systems.
[http://www.symbolstone.org/technology/perl/DBI/]

WDBI

The Web DataBase Interface is a Perl program that allows a Web browsers to be used to interact with a database. A browser can be used to search, enter, update and delete data. This uses the DBI package to access the SQL database being used.
[http://www.wdbi.net/]
dbMetrix: An SQL database tool that provides a graphical, modularized front end to various freely available SQL servers. This is being developed with MySQL although it supports several other SQL-based databases. A source code distribution is available which requires GTK for compilation.
[http://www.tamos.net/sw/dbMetrix/]
DBOX: A full-featured BBS package designed for heavily-used, professional systems running Linux. The features of DBOX include:

a user database designed for a large number of users;

Janus/ZConnect/UUCP mail transfers;

command-line and menu system interfaces;

keeping track of online time, net traffic, and email for charging purposes;

SLIP for Internet access with automatic IP address assignment;

support for CD-ROM downloads;

chat rooms and file boards;

a mailing list daemon and mail file server;

Internet interfaces via POP3 and HTTP/HTML;

a homepage manager for user-designed homepages; and

online shopping with user accounts and customizable logos/images.

This is currently (1/98) available only in binary format for Linux Intel systems. It is also currently available only in a German version (both software and documentation), although a English version is in the works. It is currently free for non-commercial uses.
[http://sunsite.unc.edu/pub/Linux/commercial/]
DBS Server: A package that supports the integration of the Panasonic DBS telephone system with UNIX servers via the use of the Panasonic API/TSAPI card and the call control protocol (PAPI) supported by the card. The server consists of an interface daemon supporting the PAPI protocol on a serial port, and it provides shared access to the DBS API resources through a UNIX domain socket. Additional functionality is obtained with other daemons which talk to the interface daemon. The package requires an existing Panasonic DBS telephone sysem equipped with the API card. A source code distribution is available.
[http://www.tycho.com/dbs/]
DBT: A Matlab toolbox for radar array processing. DBT is especially suited for processing in the spatial dimension using signals from an antenna array. The features include:

modeling array antennas with and without beamforming to subarrays;

arbitrary antenna element placements and patterns;

simulation of model errors;

single-range simulation of Gaussian distributed narrowband signals and wideband signals with a Gaussian distribution or a specified time signal;

simulation of narrowband radar signals with specified doppler shifts and waveforms;

a choice of waveforms including rectangular pulses and Barker, Frank and Chirp code;

simulation of exponentially distributed clutter including platform motion;

a wide range of conventional signal processing capabilities;

model based signal processing including estimation and modification of the spatial correlation matrix by four methods, spectral high-resolution DOA estimation by six methods, parametric high-resolution DOA estimatino by eleven methods, etc.;

incoherent integration of radar signals;

special functions for the analysis of radar signals; and

plots of received signals, spatial correlation matrices, etc.

[http://www.s2.chalmers.se/~athley/dbt/]
DB2XML: A Java tool for transforming relational databases into XML. The functions provided are:

transforming the results of database queries into XML documents; and

providing attributes describing characteristics of the data.

This requires JDK 1.1 or above and a database with a JDBC driver.
[http://www.informatik.fh-wiesbaden.de/~turau/DB2XML/]
dcc: A decompiler that decompiles x86 binaries into C programs, with the final program containing assembler code for any subroutines that can't be decompiled at a higher level than that. The dcc program uses traditional compiler optimization techniques to eliminate registers and intermediate instructions to reconstruct high-level statements as well as graph theory to determine the control structures in each subroutine. A source code distribution is available.
[http://www.cs.uq.edu.au/groups/csm/dcc.html]
dcc: The Disciplined C Checker is a code checker for C programs that performs full syntactic and some static semantic analysis. It enforces a set of rules and guidelines for writing C code in a higher-level dialect called Disciplined C. This checker allows/enforces strong naming and typing, well-defined types, name equivalence for all types, reasonable automatic conversion rules, easy to use arrays, limited use of casts, and enhanced structuration, encapsulation and portability. It also removes most of the common pitfalls of C programming.
The features of Disciplined C enforced by the checker include:

checking line indentation against the current block level for detection of missing left/right braces or bad if/loop bodies;

separation of declarations from statements by white lines;

allowing only void type expressions to be used as statements except for expressions whose top operator is an assignment or increment operator and functions whose main effect is a side effect;

requiring that if parameter names are given in function prototypes, the same name must be used for the corresponding parameter in the function definition to ensure that the meaning of the prototype stays the same as the implementation;

not allowing a function name to be a pointer on that function;

requiring pointers on functions to be dereferenced before use;

checking that a switch statement controls a block;

requiring that type attributes must precede qualifiers to clarify the distinction between them;

not allowing pointers on local objects to be returned or assigned to global/external variables;

requiring the naming of of numeric constants except in a few situations;

detection of over- and under-flows in constant expressions;

checking argument types against format string specifications in scanf/printf statements;

external identifiers are checked for non-ambiguity for the local linker;

parenthesis problems with macro bodies are detected;

uninitialized local objects are flagged; and

unused variable values are signalled.

A source code distribution of dcc is available. It is written in ANSI and is configured for several compiler/platform combinations including GCC/Linux. It is documented in a technical report available in PostScript format.
[ftp://ftp.supelec.fr/pub/lang/dcc/]
DCDFLIB: A library of C or Fortran routines for computing cumulative distribution functions, inverses, and other distribution parameters. The statistical distributions for which DCDFLIB can calculate these include beta, binomial, chi-square, noncentral chi-square, F, noncentral F, negative binomial, normal, Poisson, and Student's t. Given values of all but one parameter of a distribution, the other is computed.
DCDFLIB is available in either a Fortran or C source code distribution. Each routine is documented in comment statements contained within the source code.
[http://www.netlib.org/random/]
[http://lib.stat.cmu.edu/general/Utexas/]
DCE: The OSF Distributed Computing Environment is an industry-standard, vendor-neutral set of distributed computing technologies. It consists of multiple components which have been integrated to work closely together: the Remote Procedure Call (RPC), the Cell and Global Directory Services (CDS and GDS), the Security Server, DCE Threads, Distributed Time Service (DTS), and Distributed File Service (DFS). The Threads, RPC, CDS, Security, and DTS components are referred to as the ``secure core'' and are the required components of any DCE installation, with DFS being an optional component. DCE also includes administration tools to manage the components.
DCE provides security services to protect and control access to data, name services that make it easy to find distributed resources, and a highly scalable model for organizing widely scattered users, services, and data. It runs on all major platforms and is designed to support distributed applications in heterogeneous hardware and software environments. DCE is not intended to exist alone but should be bundled into an operating system. It is not an application in itself but can be used to build custom applications. A port to Linux platforms is being performed by the DCE-RPC Project. See Shirley et al. (1994), Hu (1995), Peterson (1995), and Rosenberry et al. (1992).
[http://www.opengroup.org/tech/dce/]
DCE-RPC: This is an ongoing project to port OSF's DCE-RPC, a system for developing portable applications, to Linux. See Bloomer (1992).
[http://www.aa.net/~mtp/]
[http://www.bu.edu/~jrd/FreeDCE/dce11rpc.html]
DCSE: The Dedicated Comparative Sequence Editor is a multiple alignment editor that can be used to edit protein, DNA or RNA alignments and that an incorporate the structures of the molecules in the alignment. Additional features include color display of characters and structure, automatic alignment relative to sequences already aligned with others, sequence grouping, sequence or pattern searching, a marker system and checking of the incorporated RNA structure. Binary distributions for X11 built using Tcl/Tk are available for Linux and other platforms.
[http://www-rrna.uia.ac.be/dcse/]
[ftp://ftp.bmc.uu.se/pub/linnaeus/software/dcse/]
DCUHRE: A Fortran 77 package implementing an adaptive multidimensional integration routine for a vector of integrals. This is TOMS algorithm 698 and is documented in Berntsen et al. (1991a) and Berntsen et al. (1991b).
[http://www.acm.org/calgo/contents/]
[http://www.acm.org/toms/V17.html]
[http://www.netlib.org/toms/index.html]
DCUTRI: An adaptive algorithm for computing an approximation to the integral of each element in a vector function o.ver a 2-D region made up of triangles. The basic cubature rule used over each triangle is a 37-point symmetric rule of degree 13. The local error for each element in the approximation vector and for each triangle is computed (on the same evaluation points) using a sequence of null rule evaluations. A sophisticated error-estimation procedure attempts to decide whether there is asymptotic behavior locally for each function, with different actions taken based on that decision. This is TOMS algorithm 706 and is documented in Berntsen and Espelid (1992).
[http://www.acm.org/calgo/contents/]
[http://www.acm.org/toms/V18.html]
[http://www.netlib.org/toms/index.html]
ddcon2d: A Fortran code the solves the 2-D Navier-Stokes equations for Boussinesq convection by Fourier Galerkin/collocation method. The system models double-diffusive convection where two agents (e.g. heat and salt) have opposing contributions to the buoyancy and diffuse at different rates. The code was developed to illustrate the use of spectral methods to solve a nontrivial hydrodynamics problem.
[http://sdcd.gsfc.nasa.gov/ESS/exchange/contrib/deane/ddcon2d.html]
DDD: The Data Display Debugger, a GUI for the popular UNIX debuggers GDB, DBX and XDB. Besides the usual front-end features such as viewing source text, DDD has several other features including:

an interactive graphical data display in which data structures are displayed as graphs;

debugging programs written in Ada, C, C++, Chill, Fortran, Java, Modula, and Pascal;

machine-level debugging;

hypertext source navigation and lookup;

breakpoint, backtrace, and history editors;

preference and settings editors;

program execution in a terminal emulator window;

debugging on a remote host; and

a command-line interface with full editing, history and completion capabilities.

A source code distribution for DDD is available as are binaries for several platforms. Compilation requires Motif 1.1 or later or LessTif 0.83 or later. A manual is available in PostScript format.
[http://www.cs.tu-bs.de/softech/ddd/]
[ftp://ftp.x.org/contrib/utilities/]
DDG: The Digital Dawn Graphics toolkit is a library of C++ classes for building real-time 3-D graphics applications. This uses OpenGL and GLUT (and works with sf Mesa), i.e. use of these classes totally shields you from dealing with OpenGL specifics.
Some of the nearly 100 classes include:

2-, 3-, and 4-D vector and matrix classes;

a class for min/max interpolation;

a string class for pure C++ string operations;

an error handling infrastructure;

a clock to measure time;

a multiple viewport class that supports keyboard and mouse;

a parameter class to control object parameters bound to keys;

camera classes to view the same scene from different perspectives;

classes for scaling, translating and rotating;

color and color group classes;

material, light, light model and fog classes;

a text class for rendering text;

texture classes which can read/write RGB, TGA and z-buffers;

generic objects, e.g. box, cylinder, axis, grd, lattice, etc.; and

a geodesic object to create faceted spheres.

[http://www.oz.net/~ddg/]
DDLab: The Discrete Dynamics Lab is an interactive graphical program for studying the dynamics of finite binary networks, a field relevant to studies of complexity, emergent phenomena, neural networks, and aspects of theoretical biology. In DDLab networks can be constructed with any architecture between regular 1- or 2-D automata and random Boolean networks (i.e. those with arbitrary connections and heterogeneous rules), with networks also capable of having heterogeneous neighborhood sizes (from 1 to 9). Networks can be moved forward in time to display space-time patterns as well as backwards to generate the predecessors of a pattern and reconstruct its branching sub-tree of all ancestor patterns. Sub-trees, basins of attraction, or even the whole basin of attraction field can be reconstructed and displayed as a directed graph or set of graphs in real time for smaller networks. (An attractor basin of a discrete dynamical network is an object in space-time that links network states according to their transitions, and it can offer insight into complexity, chaos, and emergent phenomena in cellular automata.) Learning and forgetting algorithms allow attaching and detaching sets of states as predecessors of a given state by automatically mutating rules or changing connection, a feature which allows sculpting the basin of attraction field to approach a desired scheme of hierarchical categorization. Most network and graphics parameters can be flexibly set, reviewed and altered (even on the fly).
DDLab allows various quantitative, statistical, and analytical measures and data to be collected in both forward dynamics and backwards attractor basin topology modes of operation. These measures and data include:

the P and Z parameters;

the frequency of canalyzing ``genes'' and inputs;

various measures on forward dynamics such as pattern density, frozen islands, pattern differences between two networks, the Derrida plot, rule-table lookup frequency and entropy, and the variance of the entropy;

various global measures on the topology of attractor basins including garden of Eden density and a histogram of in-degree frequency; and

a scatterplot of state space.

Binary versions of DDLab are available for MS-DOS, Sun SunOS, and Linux Intel platforms. A user's manual is available in HTML format. See Wuensche and Lesser (1992).
[http://www.santafe.edu/~wuensch/ddlab.html]
DDRIV: A routine for solving ODE IVPs. See CDRIV.
DDSCAT: A package to calculate scattering and absorption of electromagnetic waves by targets with arbitrary geometries using the discrete dipole approximation (DDA) wherein the target is replaced by an array of point dipoles. The source code, written in Fortran, is available. The documentation is contained within a 38 page user's manual in PostScript format.
[ftp://astro.princeton.edu/draine/scat/ddscat/]
deal.II: A C++ program library for adaptive finite elements and error estimation. The primary development goal is to implement modern finite element algorithms in 1-, 2- and 3-D using sophisticated error estimators and adaptive meshes. The features include:

a unified interface that enables writing programs in an almost dimension-free manner;

locally refined grids including different adaptive refinement strategies based on local error indicators and estimators;

a wide variety of finite elements including Lagrange elements of order one through four and discontinuous elements;

extensive documentation including 200 pages of tutorials and over 1000 pages of programming interface information;

use of modern object-oriented software engineering techniques to make access to complex data structures and algorithms as transparent and simple as possible;

fast algorithms for solving problems with even millions of degrees of freedom quickly; and

several available output formats including some commonly used for scientific data visualization.

The source code is available under an open source license.
[http://gaia.iwr.uni-heidelberg.de/~deal/]
debuggers: Available debuggers and related software include:

DDD, a GUI for several command-line debuggers including GDB;

deet, an extensible graphical debugger;

dmalloc, a debugging malloc library;

Duel, a high-level C debugging language extension to GDB;

GDB, the GNU debugger;

gdbtk, a GUI for GDB;

KDbg, a GUI for GDB;

LCLint, a tool for statically checking C programs;

ldb, a retargetable debugger for ANSI C;

Nana, a library providing support for assertion checking and loggin in C and C++;

Pydb, a version of the standard Python debugger for making it usable with DDD;

SmartGDB, a scriptable and thread-aware extension to GDB;

ups, a debugger with an integrated C interpreter; and

xxgdb, an X11 front-end to GDB.

[http://www.ptools.org/hpdf/]
[http://www.cs.nmsu.edu/~mikau/aadebug.html]
DECnet: The Linux DECnet Project aims to write a network protocol for Linux that will allow it to communicate with DECnet-based systems. Specifically, the goals are to create a networking layer for Linux that can communicate using the DECnet protocol and to write user mode programs providing services compatible with those on DECnet-based machines, e.g. PHONE, email exchange, and remote filesystem sharing (DAP). This project is (7/98) still in the early beta stages. <P> A related project involves LinuX DECnet CTERM utilities including a DECnet socket layer and a set of high-level applications including a terminal emulator over DECnet using CTERM. Versions of the dncopy and dntype applications are also available.
[http://linux.dreamtime.org/decnet/]
[http://members.tripod.com/~emserrat/]
decision trees: One of the central techniques used in automated machine learning for analyzing, filtering and classifying huge amounts of data. Such methods are commonly used in, e.g. astronomy and DNA sequence analysis. Decision trees are particularly useful in that they perform classification via a sequence of simple tests whose semantics are intuitively clear to domain experts. See Brieman et al. (1984) and Safavin and Landgrebe (1991).
Related software includes:

CDT, an algorithm for the asymmetric traveling salesman problem;

C4.5, a program for inducing classification rules in the form of decision trees from a set of examples

OC1, a system for the induction of oblique decision trees;

ITI, a program for constructing decision trees using either incremental or direct metric tree induction;

IVODES, a decision tree for selecting suitable codes for solving initial value ODEs;

MLC++, a library of classes for supervised machine learning;

QUEST, a decision tree algorithm for classification and data mining with unbiased variable selection;

TiMBL, a machine learning program implementing a family of memory-based learning techniques; and

WEKA, a collection of machine learning methods linked together with a common file format and interface.
deet: A graphical debugger which can be easily retargeted for different languages, compilers, and operating systems. This is done by separating the core debugger functionality from the user interface, with the former implemented with a small set of commands called a nub (with nubs for Java and C available). This works on top of GDB and also requires Tcl/Tk 4.0 and higher. A source code distribution is available.
[http://www.cs.princeton.edu/~jlk/deet/]
DejaGnu: This is a framework for testing other programs whose purpose is to provide a single front-end for all tests. Its features include: a flexible and consistent framework which make it easy to write tests for any program, a layer of abstraction which allows tests to be written that are portable to any host or target where a program must be tested, and the same output format for all tests which makes it easy to integrate testing into other software development processes.
DejaGnu is a GNU project program written in Expect, which is in turn written in Tcl/Tk. The distribution includes the source code written in Expect and a user's guide in Texinfo format.
[http://www.welcomehome.org/dejagnu.html]
delaundo: A package for creating triangular grids based on the frontal delaunay method. In this method the set of discretized curves that describe the boundary are first triangulated. New vertices are then created on frontal edges between well- and ill-shaped triangles such that a new triangle with the desired size and shape will result. New vertices are introduced in layers on the boundaries in a regular manner, with the regularity of the point distribution and element quality enhanced by an averaging process that tends to choose an equilibrium position between competing edges when a front is refined or coarsened. Delaundo can also produce stretched grids and has a multi-grid capability that can produce a series of coarsened grids with nested nodes. A source code distribution of this Fortran package is available. It is documented in a thesis available in PostScript format as well as in Müller (1994).
[http://www.cerfacs.fr/~muller/delaundo.html]
DeleGate: A multi-purpose application level gateway or proxy server. This mediates communications among various protocols (e.g. HTTP, FTP, etc.) by caching and converting data. It controls access from clieints and routing toward servers, and translates protocols between clients and servers, merging several servers into a single general purpose proxy server with aliasing and filtering.
The features of DeleGate include:

unbound proxying wherein a user can arbitrarily select target servers by specifying a destination in user level data specific to the protocol of the client;

bound proxying wherein the administrator can specify which destination server is used depending on the client;

caching of messages in their original format and sharing them among gateway servers with different protocols;

connection sharing wherein an established connection to a server can be reused and shared among multiple clients;

several built-in data conversion filters;

several protocol conversion filters;

relaying messages between clients and servers with and without SSL capabilities;

access control via destination protocol, destination server and source client;

detailed logging of all actions as well as protocol depending logging;

automatic invocation on demand or at boot time;

resolver control wherein the combination and sequence of multiple resolution mechanisms can be controlled independent of platform;

selecting routes to the server based on protocol, server and client;

merging multiple servers with multiple protocols into a single server with resource name filtering and aliasing; and

invocation of proxy on demand, e.g. for a current session.

A source code distribution of DeleGate is available. It can be compiled and used on most UNIX platforms with minor modifications. It is documented on the site and in an ASCII text file serving as a manual.
[http://wall.etl.go.jp/delegate/]
Delila: A package for the information analysis of protein and nucleic acid sequences. The programs include:

alist, creates an aligned listing of sets of sequences;

alword, prepares an aligned set of protein sequences for input into concensus;

aran, generates random sequences from a given sequence;

asciidna, draws a spiral DNA in ASCII characters;

binfra, a genetic algorithm to maximize the fractal dimensionality of a binary string;

calc, an error-propagating calculator;

calhnb, calculates the sampling error and variance given a genomic composition and a series of integers representing the number of sample sites;

cerf, calculates the complement of the error function;

chaos, searches for a chaotic relationship using the potential locations of binding sites;

compan, computes chi squared from a composition;

da3d, shows the position to position correlation data in three dimensions;

dangles, calculates the DNA angles of a list of positions;

dbmutate, mutates GenBank database sequences;

delila, a database manager for nucleic acid sequences;

diana, performs dinucleotide analysis of an aligned book;

dirgra, performs a Monte Carlo analysis of a directed graph;

dnag, generates a graph of DNA;

dnamwt, calculates the weight of a DNA molecule;

encfrq, performs encoded sequence frequency analysis;

fradna, computes the fractal structure of DNA;

helix, find helices between sequences in two books;

hist, make a histogram of aligned sequences;

lig, computes the results of a ligation reaction for insertion of a linker onto both ends of a linearized plasmid;

malopt, creates a 2-D plot of optimal alignments;

migrate, shows evolutionary selection in the context of a drunkard's walk;

patana, does simple analyses of a pattern matrix;

patval, performs pattern evaluations of aligned sequences;

sites, gathers, collates, and analyzes data from a randomization experiment;

and over a hundred more programs. A source code distribution is available. Each program is written in C and documented in a separate man page.
[http://www-lmmb.ncifcrf.gov/~toms/delila.html]
Delta Toolbox: A Matlab toolbox which provides an extensive collection of routines for use by a control or systems engineer. The routines allow control systems to be modeled as transfer functions or in state space form as well as methods to convert between the various model representations. The toolbox provides time response, frequency response, pole-placement, optimal control, and estimation. The Delta Toolbox differs from the Control System Toolbox supplied in the standard Matlab distribution in that while the latter uses the shift operator for discrete time systems the former uses the delta operator which has been shown to be superior for such applications. The delta operator unifies continuous and discrete time theory such that discrete time results converge to the corresponding continuous time results as the sampling period is decreased. It also provides superior numerical properties. The Delta Toolbox should be seen as an upgrade to the Control System Toolbox using the delta operator such that each pair of (continuous and discrete) existing routines is replaced by one using the delta operator.
The Delta Toolbox can be used with Matlab or with the freely available Octave package which can run most Matlab m-files. It is documented in a 34 page user's manual in PostScript format.
[ftp://ftp.mathworks.com/pub/contrib/v4/control/]
Delve: The Data for Evaluating Learning in Valid Experiments is a standardized environment designed to evaluate the performance of methods which learn relationships based primarily on empirical data, e.g. neural nets. Delve makes it possible for users to compare their learning methods with other methods on many datasets, with the learning methods and evaluation procedures well-documented so meaningful comparisons can be made. Delve consists of a software environment, a number of datasets, and a repository of learning methods.
The software environment consists of a suite of utilities for manipulating datasets and evaluating method performance. These utilities allow users to get information about the Delve datasets installed on their system, get information about which methods have been run on those datasets, extract training and testing cases from the dataset file so another method can be run on it, calculate losses given the predictions a method makes for the testing data, and calculate summary statistics about the method's performance and comparie it to other methods. The learning methods available include linear least squares regression, multilayer perceptron ensembles, multivariate adaptive regression splines (MARS), K-nearest neighbors, and more.
The source code for the Delve software environment is available and can be installed on most generic UNIX platforms which already have Tcl version 7.3 installed. The package is documented in a user's manual available in PostScript format.
[http://www.cs.utoronto.ca/~delve/]
DEM Tools: A set of tools for working with Digital Elevation Model (DEM) data. DEM Tools can be used for previewing DEM data sets and for wandering around in virtual representations of landscapes. The tools in the package are:

dem2ppm, which converts DEM files into PPM format images;

dem3dmap, a 3-D map viewer which allows images to be rotated, zoomed and manipulated in various other ways; and

dem2vrml, which converts DEM files into VRML files.

A source code distribution is available as are static binaries for Linux Intel platforms. Building from source requires the Mesa and GLUT libraries.
[http://www.arq.net/~kasten/demtools/]
Demeter: An object oriented software development method featuring a graphical description of class structures and a high level language for the definition of object behavior. Demeter is a software design and development method for deriving object-oriented software from informal specifications such as use cases or scenarios. The software is described at the adaptive object-oriented level rather than at the object oriented level, with adaptive meaning that it adjusts automatically to a large number of context changes. The Demeter software provides a high-level interface to both C++ and Java. It defines a high-level interface for defining the structure of classes and objects through class dictionaries, and also defines an interface for defining the behavior of objects through adaptive programs. The method is supported by a suite of tools including a graphical user interface (GUI), a consistency checker, C++ code generators, and a rum-time library of generic software.
Implementations of Demeter are available for Sun SunOS, IBM AIX, and Linux Intel platforms. The documentation is in a separate file which contains a tutorial, several code examples, and a user's guide in PostScript format. See Lieberherr (1996).
[http://www.ccs.neu.edu/home/lieber/demeter.html]
DEMOCRITOS: Note: As of 12/99 there is no sign of this at its orginal site or anywhere else. A C++ class library specially written to provide support for tasks in bioinformatics and computational chemistry. This is currently (6/97) still under development and has its classes divided into four groups: main, PDB, CIF, and container classes. The main group contains over 60 classes including: DMAtomType, for atom types and associated properties; DMChemicalElement, for elements and associated properties; DMAminoAcid, for amino acids and associated information; DMBivariate, which performs various statistical calculation; and many more. A beta version of this is available, although the documentation is still a bit scarce.
[http://www.seqnet.dl.ac.uk/CBMT/democ/HOME.html]
DEMODWT: Wavelet transform algorithms for finite-duration, discrete-time signals. This is TOMS algorithm 735 and is documented in Taswell and McGill (1994).
[http://www.acm.org/calgo/contents/]
Dents: A server for the DNS protocol as specified in RFC 1035. The features of Dents include:

compatibility with named such that it can be used as a drop-in replacement;

a modular driver system allowing for the dynamic binding of zones and corresponding code to answer DNS queries; and

an extensible control facility allowing an administrator to control the running server.

A source code distribution is available under the GPL.
[http://www.dents.org/]
DEPAK: A suite of Fortran 77 programs for the solution of initial value problems for ODEs. The package consists of three routines:

DERKF, which uses a Runge-Kutta method;

DEABM, which uses an Adams predictor-corrector method; and

DEBDF, which uses a Gear stiff method.

DERKF is a fifth-order Runge-Kutta code and the simplest of the codes both algorithmically and in its use. It is designed to solve non-stiff and mildly stiff DEs when derivative evaluations are not expensive and should not be used to obtain high accuracy results or answers at many specific points. It also attempts to discover when it is not suitable for the assigned task. DEABM is a variable order (one through twelve) Adams code of intermediate complexity which is designed to solve non-stiff and mildly stiff DEs when derivative evaluations are expensive, high accuracy results are needed, or answers at many specific points are required. It also attempts to discover when it is unsuitable for its assigned task. DEBDF is a variable order (one through five) backward differentiation formula code. It is the most complex code and primarily designed to solve stiff DEs at crude to moderate tolerances. It is much more efficient than the other codes if the problem is very stiff.
DEPAK is available as Fortran source code. Each of the three components are documented in comment statements contained with the source code. This is part of CMLIB.
[http://sunsite.doc.ic.ac.uk/public/computing/general/statlib/cmlib/]
Depot: A software management tool that provides a simple yet flexible mechanism for maintaining third party and locally developed software in large, heterogeneous computing environments. It uses an object-oreinted approach to managing software with each package managed as one or more logical objects. Depot integrates separately maintained software packages (known as collections) into a common directory hierarchy consisting of a union of all of the collections, with this directory defined as the software environment. A set of configuration options manages interactions and intersections between collections in the environment.
A source code distribution of Depot is available. It is written in C and can be compiled on most UNIX platforms. Several technical papers are available as documentation.
[http://andrew2.andrew.cmu.edu/depot/depot.html]
Depot4: A system for implementing language processors in which translators and interpreters can be written in the Ml4 language, an extension of the EBNF form, and then produce an executable program. Depot4 was created to provide a tool for domain-specific language implementors. Depot4 is similar to a compiler generator in that it accepts a grammar-based input language and produces a parser or translator from it. It differs in that it is designed for rapidly implementing translators rather than creating maximally efficient translators. The Depot4 metasystem consists of a meta-language compiler (i.e. a preprocessor), a library of modules for standard tasks and runtime support, and a user interface. Versions of Depot4 written in both Oberon and Java are available.
[http://www.math.tu-dresden.de/wir/depot4/]
detect: A hardware detection library which, while documented very sparsely, forms the underpinnings of the Lothar project.
[ftp://ftp.linuxmandrake.com/pub/lothar/SOURCES/]
DeTeX: A filter program that removes TeX and LaTeX control sequences from input files.
[http://www.cs.purdue.edu/homes/trinkle/detex/]
devfs: The Linux device file system is an alternative to the ``real'' character and block special devices on the root filesystem, i.e. the /dev directory. It allows kernel device drivers to register devices by name rather than by major and minor numbers. These devices will automatically appear in devfs, and with whatever default ownership and protection the driver specified. It consists of an underlying device namespace (i.e. a namespace like any mounted filesystem) and the filesystem code that provides a view of the device namespace.
The problems devfs was created to solve include:

the requirement that major and minor device numbers be allocated for each and every device, with the consequent requirement of a central coordinating authority to issue the numbers to preserve uniqueness (with devfs shifting the burden to a namespace);

two separate databases of major and minor numbers: one in the kernel and one in /dev;

well over 1200 nodes in typical /dev directories - most for devices that don't exist - with devfs offering a list of available rather than conceivable devices;

having the device nodes on the root filesystem means you can't operate with a read-only root filesystem;

non-UNIX filesystems can't be used for root filesystems;

PTY device would be increased by allowing a secure user-space daemon to run as root and create pty-pairs; and

device management would be more intelligent.

[http://www.atnf.csiro.au/~rgooch/linux/docs/devfs.html]
DeviceNet: A networking standard for industrial automation applications. It provides both peer-to-peer and master/slave communication and is designed to reduce hardwiring and provide access to device-level diagnostics. The DeviceNet communication link is based on the CAN (Controller Area Network) protocol.
[http://www.odva.org/]

ss5136dn

A device driver, a set of utility programs, and a function library for the SST model 5136 family of CAN Bus / DeviceNet interface cards. It rovides a programming library, driver module, and set of configuration and testing utilities for using the SST 5136-DN, and 5136-DNP, cards as a DeviceNet scanner under Linux. The package contains drivers for the ISA and PC104 versions of these cards as well as the PCMCIA version. These products are rebranded and sold under several vendor's names. Such rebranded products also work.
[http://sunsite.unc.edu/pub/Linux/hardware/drivers/]
DEVise: An environment for Data Exploration and Visualization is a data exploration system allowing the easy development, browsing and sharing of visual presentations of large tabular datasets from several sources. The features include:

a visual query interface;

efficient handling of datasets larger than RAM;

mapping from data to graphics at record level;

querying of data records used to represent graphics;

a flexible layout mechanism within windows;

linked axes;

use of cursor to compare relationships between different data views;

record-based input data;

direct input of ASCII files; and

handling of several data types including integer, float, data and string.

[http://www.cs.wisc.edu/~devise/devise.html]
DFM: Desktop File Manager is a file manager for UNIX systems designed to emulate the OS/2 WPS program. File are shown as icons and every folder has its own window, with the desktop background being a special folder in the home directory. The features of DFM include:

icons can have any size or position;

XVPICS can be shown as icons;

constant position icons that cannot be moved;

easy addition of new programs to the desktop;

drag and drop support; and

detail and structure views.

This was built using the GTK library.
[http://dfm.linuxbox.com/]
DFN-RPC: A remote procedure call (RPC) tool developed for distributing and parallelizing scientific application programs on clusters of workstations. It is optimized for applications written in Fortran but can also be used in a C environment. The features of DFN-RPC include:

synchronous, asynchronous and parallel RPCs;

datapipes for message passing;

a central location for handling the completion of a parallel RPC, the receipt of a datapipe message, an X event, an input, or another event on a UNIX file descriptor;

quick start routines for building a network of parallel application processes;

a graphical monitor with a step mode;

a remote file access library;

routines for establishing a freely configurable interconnection network between all server processes; and

several example applications.

A source code distribution of DFN-RPC is available. Versions after 1.0.49alpha will work on Linux platforms, although version 1.0.60beta is recommended. A user's guide is available as are several technical reports concerning its development and applications.
[ftp://ftp.uni-stuttgart.de/pub/rus/dfn_rpc/README_dfnrpc.html]
DGENESIS: A distributed implementation of parallel genetic algorithms (GA). Distributed GENESIS is based on the GENESIS GA package. This package parallelizes a GA by dividing the population into subpopulations, runs a conventional GA in each subpopulation, and allows the periodic communication of information between subpopulations that helps in the search for the solution. The information usually exchanged is a subset of the fittest individuals of each subpopulation in a process known as migration. Each subpopulation is handled by UNIX process and interprocess communication is handled via Berkeley sockets. It uses rsh and rcp to execute remote processes and to copy files across the network.
The source code for DGENESIS is available. It is written in C and can be compiled and used on UNIX systems with the above capabilities and programs. It is documented is a user's manual available in PostScript format.
[http://www.aic.nrl.navy.mil/galist/src/]
DGL: The Data Generation Language is a language that can be used to generate various kinds of test data. It was originally designed to generate functional level test for VLSI designs but has been used to generate tests for both software and hardware with tests generated either systematically or randomly. It is particularly adapted to situations requiring the random selection and printing of data. DGL is based on the concept of context-free grammars with significant additions to expand the generating power of the language. A C language source code distribution is available and is a collection of examples and an extensive test suite. Documentation includes a user's manual and a couple of technical reports.
[http://www.csee.usf.edu/~maurer/dgl.html]
DHCP: The Dynamic Host Configuration Protocol provides a framework for passing configuration information to hosts on a TCP/IP network. It is based on the Bootstrap Protocol (BOOTP) but also adds the capability of automatic allocation of reusable network addresses and additional configuration options. It consists of two components: a protocol for delivering host-specific configuration parameters form a DHCP server to a host, and a mechanism for the allocation of netowrk addresses to hosts. DHCP is built on a client-server model where designated DHCP server hosts allocated network addresses and deliver configuration parameters to dynamically configured hosts.
The general design goals for DHCP include that:

it should be a mechanism rather than a policy;

clients should require no manual configuration;

networks should require no manual configuration for individual clients;

it should not require a server on each subnet;

a client should be prepared to receive multiple responses to a request for configuration parameters;

it must coexist with statically configured, non-participating hosts and with existing network protocol implementations;

it must interoperate with the BOOTP relay agent behavior; and

it must provide serve to existing BOOTP clients.

The given address is for a reference implemtation of DHCP which contains a server, a client, and a relay agent. The tools all use a modular API designed to be sufficiently general to work on POSIX-compliant operating systems as well as on non-POSIX systems. The implementation aims to provide full support for all the intricacies of the protocol as well as to provide a modular and highly adaptable interface to related tools such as DNS and NIS. The dhcpcd package implements the DHCP protocol.
[http://www.isc.org/products/DHCP/]
[http://www.ietf.org/html.charters/dhc-charter.html]

dhcpcd

An RFC-2131 compliant DHCP client daemon which recieves an IP address and other information from a corresponding DHPC server, automatically configures the network interface, and tries to renew the lease time according to the protocol. It has been found to work with several servers. A source code distribution is available.
[http://www.phystech.com/download/dhcpcd.html]
[http://sunsite.unc.edu/pub/Linux/system/Network/daemons/]

JDHCP

A project to add DHCP support to Java.
[http://www.eg.bucknell.edu/~jgoldsch/dhcp/]
DHTML: Dynamic HTML is a sort of buzzword for Web pages that combine HTML, CSS and JavaScript to enhance their interactive functionality. It can be used to create animations, games, applications, novel site navigation methods, and page layouts that aren't possible with just HTML.
Related packages include:

DynAPI, an Open Source project for developing a code library for programming DHTML

[http://www.dhtmlzone.com/index.html]
[http://www.dansteinman.com/dynduo/links.html]
Dia: A program for drawing various kinds of diagrams that is sort of based on the Windoze program Visio. The current (8/98) beta version has support for UML static structure diagrams (i.e. class diagrams) and network diagrams. It can also load and save diagrams to either a custom file format or export them in PostScript format. A source code distribution is available.
[http://www.lysator.liu.se/~alla/dia/dia.html]
diald: The dial daemon software makes it appear that you have a 24 hour a day connection to the Internet over a SLIP or PPP link. It can handle tasks ranging from actually keeping a link up for 24 hours a day during phone line problems to dialing out with a modem whenever a connection is needed and hanging up when it is no longer needed. The main function of diald is to provide a proxy network device that stands in for the physical connection to a remote site. It monitors the packets sent to the proxy device and tries to bring up a real link whenever one is needed. One the real link is in place packets are routed through this rather than the proxy and the network connection behaves exactly as if it had been manually established.
The functionality of diald includes:

forcing connections up or down at specified times (including forcing a continuous connection);

bringing connections up or down based on the flow of traffic across a network with the possibility of treating traffic differently depending on the contents of the packet header;

the capability of running multiple copies of diald simultaneously for connectivity with multiple remote sites;

manual intervention to bring a link up or down, temporarily block it, or force it to stay up;

allowing incoming connections to, for example, construct a two-way demand dialed link with a remote site where either can call the other when a link is needed; and

keepin track of phone usage statistics such as total connect time for each session and the amount of traffic passed.

A source code distribution of diald is available. It needs SLIP devices in the kernel to work under all circumstances and PPP devices for using PPP. A makefile is supplied which will compile it on most platforms. A series of man pages are supplied in multiple formats.
[http://www.dna.lth.se/~erics/diald.html]
DIALIGN: An alignment program for nucleic acid and protein sequences that relies on comparison of whole segments of the sequences rather than comparison of single residues. Pairwise as well as multiple alignments are constructed from gapfree pairs of equal length segments, with these segment pairs called diagonals. DIALIGN doesn't use a gap penalty and therefore is especially suited for the detection of local similarities in other completely unrelated sequences. Binary distributions are available for several platforms including Linux Intel.
[http://www.gsf.de/biodv/dialign.html]
DialoX: A distributed human/computer interaction (HCI) server tailored for use with symbolic programming languages such as April. DialoX contains a combination of window primitives, graphics capabilities, and a high-level approach to constructing GUIs for agent applications. In this approach the task of building the code need for the GUI is delegated to the server, i.e. applications interact with the server via a special purpose protocol that allows the appplication to request that particular windows be constructed as well as notify the application via a message when the user invokes an action in the window. The descriptions of user interface elements are written as external resources to the application using an XML-based notation. The application only has to manage the top-level invocation of the windows and the responses from the user. This is part of the larger Network Agents project.
[http://www.nar.fujitsulabs.com/dialox/]
Diary: A program for storing and keeping track of notes. Diary allows notebooks to be created and entries added, deleted and modified. The notes can be browsed and searched. The features include:

universal access via web browsers;

collaboration by specifying permission for one or more other users to use a notebook; and

a choice of making any notebook as private or public as you want.

This is a PHP package that also requires MySQL.
[http://keilor.cs.umass.edu/diary/]
DICT: The DICTionary Server Protocol is a TCP transaction based query/response protocol allowing a client to access dictionary definitions from a set of natural language dictionary databases. It is fully described in RFC 2229.
[http://www.dict.org/]

dictd

A client/server software package implementing the DICT protocol. The programs comprising the package include:

dict, a client that can access DICT servers from the command line;

dictd, a server supporting the DICT protocol; and

dictzip, a program that creates compressed files in a modified gzip format that compresses the file in pieces and stores and index in the header.

A source code distribution of dictd is available which can be compiled on most UNIX flavors including Linux.
[http://www.dict.org/announce.html]