Next: Ca-Cm Up: Linux Software Encyclopedia Previous: Ba-Bm Contents

Bn-Bz

Last checked or modified: Aug. 10, 1999

BNG: The Bayesian Network Generator is a tool for constructing structurally minimal Bayesian networks from universally quantified probability logic statements with optional context constraints. A class of Bayesian networks is specified with a knowledge base of rules which may contain universally quantified temporal and non-temporal variables as well as context constraints (i.e. deterministic information used to index probabilistic relations). BNG constructs a Bayesian network to compute the posterior probability of a query given that query, a knowledge base, a set of context information, and some evidence. This is done by constructing the network (as indexed by the context) and then performing fast d-separation based pruning. A source code distribution of this Common Lisp package is available.
[http://www.mcw.edu/midas/bng.html]
Boa: A high performance Web server for UNIX platforms. Boa is a single-tasking HTTP server which means that, unlike other servers, it does not fork for each incoming connection or fork many copies of itself to handle multiple connections. Rather, it internally multiplexes all of the ongoing HTTP connections and only forks for CGI programs. Some tests show Boa being about twice as fast as Apache and capable of handling 50 hits per second on a 66 MHz 486. Boa was designed for speed and security, with the latter being of the type that prevents subversion by a malicious user rather than the type that allows infinite access control and encrypted communications.
The source code for Boa is available. It is written in C and should compile and run on most UNIX platforms. The documentation is a bit sketchy, although most of the basics can be found in the documentation for other HTTP servers.
[http://www.boa.org/]
Bobby: A program to help make web pages more accessible to those with disabilities. Bobby finds HTML compatibility problems that prevent pages from displaying correctly on different web browsers. It works by displaying warning symbols on Web pages that have been selected and processes. Different symbols are displayed for disability access violations and browser compatibility violations. A source code distribution of Bobby is available. It is written in Perl.
[http://www.cast.org/bobby/]
Bobo: This has become part of Zope.
bobstuff: A collection of Matlab programs (m-files) for performing vector correlation, complex correlation, and various other statistical tasks. The routines include:

veccor, which computes the vector correlation coefficient;

linreg, which computes the linear regression of y on x;

boxfilt, a running boxcar filter;

rot, which rotates a vector counterclockwise;

cv, which computes the cross product between two vectors;

veccor1, which computes the complex vector correlation; and

tide-ell, which calculates tidal ellipse parameters.

These files can be used with Matlab or with the freely available Octave program which can run most Matlab m-files.
[http://crusty.er.usgs.gov/sea-mat/bobstuff-html/index.html]
Bochs: A portable X86 PC emulation software package that emulates enough of the X86 CPU, related AT hardware, and BIOS to run DOS, Windows 95, Minix 2.0 and other operating systems on a workstation. The source code is available for free evaluation for up to 30 days, after which a fee of $25 per workstation must be paid for its use. It can be used on almost any UNIX workstation, and has been tested on Sun Solaris, Linux Intel, FreeBSD Intel, and the BeBox BeOS.
[http://www.bochs.com/]
BOCLS: A package of Fortran 77 routines for solving bounded and constrained linear least squares problems, i.e. it will find a least squares solution to a system of linear equations subject to general linear constraints and to simple bounds on the variables. The package contains two subroutines: BOCLS for the general problem and BOLS for problems with only bounds. The source code for these Fortran routines is available. All documentation is contained in comment statements within the source code. This is part of CMLIB.
[http://sunsite.doc.ic.ac.uk/public/computing/general/statlib/cmlib]
[http://www.hensa.ac.uk/ftp/mirrors/statlib/cmlib]
Bode Step Toolbox: A Matlab toolbox for the design of control systems with maximized feedback that required shaping the loop with a Bode step. The functions in the toolbox include:

nyqlog, a Nyquist plot on a logarithmic scale with frequency in octave marks;

bolagnyq, a Bode diagram for the gain and the lag margin, and the logarithmic Nyquist plot;

tfshift, a frequency transform and denormalization;

bonyqas, an asymptotic Bode diagram, phase plot, and logarithmic Nyquist plot;

bostep, rational function approximation to optimal Bode step response;

boclos, prefilter design for closed-loop low overshoot and fast settling;

bointegr, breaks the compensator into two parallel paths, one of which is dominant at low frequencies;

bocomp, calculates the compensator function for a DC motor control;

ndcp, Nyquist plot for describing functions of NDC with parallel paths;

bndcp, Bode plot for describing functions of NDC with parallel paths;

ndcb, Nyquist plot for describing functions of NDC with feedback path; and

BNDCB, Bode plot for describing functions of NDC with feedback path.

For documentation see Lurie and Enright (2000).
[http://www.luriecontrol.com/BodestepToolbox.htm]
BOIL: Brunnis Own Interpreter Language is a C-like scripting language developed under Linux for special purposes which is being released under the GPL. BOIL has some features not found in similar languages including:

distributed programming via RPC wherein a BOIL function can be declared external and be transparently executed on another machine;

accounting and resource limiting for an entire program or single functions;

database functions that support PostgreSQL;

isolation of single functions from the rest of the program as well as disabling the use of every library function; and

parsing, definition and deletion of functions at runtime.

BOIL code can be embedded in ASCII/HTML and can read POST/GET data into variables, making it a useful interpreter for CGI scripts.
A source code distribution of BOIL is available as is a binary (normal or statically linked) for Linux Intel platforms. It is documented in an ASCII file available in either English or German.
[http://www.netestate.de/boil/]
Bond: A package of Java middleware that provides network-centric computing, BVond is an agent-based, message-oriented system using KQML as a communication language. It consists of a communication infrastructure and frameworks for building metaobjects and agents. Frameworks are also provided for various aspects of complex object design, e.g. security and monitoring. Bond can be used in stand-alone mode or to connect to a Bond domain, i.e. a society of users with common interests and a number of services. These services are provided by core servers, i.e.

BSM (Bond System Monitor), provides the failure detection service for the implementation of the fault tolerance;

DS (Directory Server), cooperates with the local Bond directory in each Bond program to provide a distributed directory service that can be used by a Bond objects to find other objects;

PSS (Persistent Storage Server), a server providing persistent storage service which can be used by any Bond program to save an object; and

AS (Authentication Server), provides authentication service which can be used by a Bond domain to manage a group of user accounts shared in the domain.

A source code distribution is available which requires II and the Java Swing package. Documentation includes a user's guide and several technical reports.
[http://bond.cs.purdue.edu/]
Bongo: This programming language has been renamed YoYo.
Bonnie: A benchmark that measures the performance of UNIX file system operations in an attempt to identify bottlenecks. Bonnie performs a series of tests of a file of known size. For each test, it reports the bytes processed per elapsed second, per CPU second, and the percentage CPU usage. A source code distribution is available.
[http://www.textuality.com/bonnie/]
Boost Libraries: A set of free, peer-reviewed C++ libraries, with the emphasis on portable libraries that work well with the C++ Standard Library. The Boost Libraries include:

array, an STL-compliant container wrapper for arrays of constant size;

call_traits, a collection of typedefs encapsulating the best methods for passing a parameter of some type to or from a function;

compose, provides compose function object adapter extensions for use with STL;

compressed_pair, provides empty member optimization;

config, a header used to pass configuration information to other Boost files to allow them to cope with platform dependencies;

dir_it, an input iterator to iterate over the contents of a directory;

functional, provides enhancements to the function object adapaters specified in the standard library;

graph, generic graph components and algorithms;

integer, for dealing with integer types;

operators, sets of templates for arithmetic operators as well as dereference operators and iterator helpers;

random, a random number library;

rational, an implementation of rational numbers;

regex, a regular expression library;

smart_ptr, a smart pointer library;

timer, provides classes for measuring and reporting elapsed time as well as for indicating progress toward a goal;

type_traits, template classes that describe the fundamental properties of a type; and

utility, various utility functions.

[http://www.boost.org]
Boot Control: A set of alternative Master Boot Records (MBR) and an installation program that makes it easier to choose an OS at boot time than the standard MS-DOS MBR software. Nine different MBRs are available, each with a different combination of options, e.g. default boot partition, harddisk choice, other operating systems, and description sizes. The available MBRs are:

MBR 0 - boots the currently active partition;

MBR 1 - doesn't rewrite itself to disk to save the active flag, and offers a menu of bootable OS options;

MBR 2 - similar to previous but rewrites itself to disk;

MBR 3 - can boot other hard disks by loading and executing the MBR of those disks;

MBR 4 - similar to previous but defaults to first partition;

MBR 5 - drops PC-DOS support in favor of OS/2 and also changes the way other drives are supported;

MBR 6 - similar to previous but defaults to a fixed partition or drive;

MBR 7 and 8 - hide all primary DOS partitions other than the one booted (for installations where DOS/Windoze 3.11 and Windoze 95 are installed on separate partiations and shouldn't see each other).

[http://www.xs4all.nl/~gklein/bcpage.html]
booting: Software related to booting operating systems includes:

Boot Control, a set of alternative Master Boot Records;

Choose-OS, a boot loader for Linux;

the distributions entry contains several small distributions for rescuing, repairing and rebooting systems gone awry;

dmesg, a program in the util-linux collection that prints a list of bootup messages;

EtherBoot, for booting X86-based machines over a network;

Extended-IPL, an operating system boot selector;

FIPS, a program for non-destructively splitting hard disk partitions;

GAG, a graphical boot manager;

GRUB, a unified bootloader for PC-compatible machines;

KLilo, a GUI for configuring LILO;

LILO, a generic boot loader for Linux and other operating systems;

loadlin, a boot loader for Linux that runs under DOS;

Netboot, for booting a computer with an X86 processor via an IP network;

NILO, a network boot image loader;

OSKit, a framework for OS development with tools for booting systems;

Ranish Partition Manager, a disk partitioning and boot management system;

RawWrite, a program for creating Linux boot and root disks from within Windoze NT/95;

reboot, a program in the util-linux collection that reboots the system;

Smart Boot Manager, an OS-independent boot manager;

SOLO, a shell and boot loader for protected mode 32-bit x86 microkernels;

UNILOAD, a boot loader for booting from any partition on up to 4 hard disks;

Watchdog, a daemon that reboots a system if it is not working;

Wolfpack Boot Manager, a boot manager;

XOSL, a boot manager for machines with several operating systems;

Yard, a collection of scripts for creating rescue disks for rebooting a system.
Bootstrap Toolbox: A set of Matlab functions for resampling, hypothesis testing, and confidence interval estimation. These functions use a technique called the bootstrap for assessing the accuracy of statistical parameter estimation in situations where conventional techniques do not apply. Several examples are included in the distribution.
[http://www.atri.curtin.edu.au/csp/downloads/bootstrap_toolbox.html]
Bosy: An online newsreader which is multi-threaded, supports reading MIME and HTML formatted messages, and has a flexible kill filtering system. It can also save important messages so they won't disappear when old news is expired. This requires Motif (although Lesstif 0.85 will do), gdbm, some graphics libraries, XmHTML, and UUDeview. A source code distribution is available.
[http://www.pandh.demon.co.uk/bosy.html]
Boulder: A semantic free data interchange format used mostly in the biosciences. This is an easily parseable tag/value format suitable for applications that need to pipe the output of one program into the input of another. It was originally developed for use in the human genome project but has found use in many other areas.
[http://www.genome.wi.mit.edu/genome_software/other/boulder.html]
[http://stein.cshl.org/software/boulder/]
BowMan: This has been superseded by the AfterStep project.
BoxLib: A library of C++ classes that facilitate the development of block structured finite difference programs such as those that arise in computational fluid dynamics, semiconductor device simulation, and other disciplines in which systems of PDEs are routinely solved. It is primarily intended for use by developers of such programs and was originally developed to reduce the computational burden of expressing computational fluid dynamics algorithms that use adaptive mesh algorithms. It contains a variety of data structures for describing operations which take place on data defined in regions of index space that are unions of non-intersecting rectangles. Support is also provided for efficiently building and destroying data structures in adaptive algorithms.
The classes in BoxLib and their functions include:

Box, a rectangular domain on an integer lattice;

BaseFab, a Fortran array-like object;

BoxArray, an array of boxes;

BoxAssoc, nearest neighbor lists for Boxes and BoxArrays;

BoxDomain, a list of disjoint boxes;

BoxDomainIterator, an iterator for BoxDomain;

BoxLib, error-reporting functions and version number;

FABio, a class facilitating I/O for Fabs;

FArrayBox, a Fortran array of real numbers;

FabArray, a collection of Fortran array-like objects;

IntVect, an integer vector in N-dimensional space;

MultiFab, a collection of FArrayBoxes;

NormedFab, a BaseFab with norms;

Orientation, encapsulation of the orientation of the faces of a box;

PArray, an array of pointers to objects; and

Utility, useful C++ utility functions.

A source code distribution of BoxLib is available. It is written in C++ and has been compiled on Cray, SGI IRIX, Sun Solaris, DEC Alpha, IBM AIX, and Linux Intel boxes. It is documented in a tutorial and a reference manual, both of which are included in the distribution. Other software at this sight that uses BoxLib includes Amrvis, AmrPoisson, HAMR, and VarDen.
[http://seesar.lbl.gov/ccse/software/software.html]
BPKIT: A toolkit of block preconditioners for the iterative solution of linear systems. This contains the most effective general purpose and black-box types of preconditioners, including block SSOR, block tridiagonal ILU, and the block extension of point ILU with level-of-fill. The global preconditioners can be coupled with one of a large collection of local preconditioners for approximately or exactly inverting or solving with the diagonal or pivot blocks. A wide variety of preconditionings are possible by combining local and global preconditioners appropriate to the difficulty and structure of the problem.
The blocks can be stored in dense or sparse formats, and variable block sizes are allowed within a matrix. The BLAS, LAPACK, and sparse BLAS packages are used for efficiency across many platforms. BPKIT is callable from C/C++ and Fortran and is written in standard C++ and Fortran. It is also user extensible since a completely black box approach to high-performance preconditioning is not as yet possible, and as such local and global preconditioners written in any language can be added.
The source code for BPKIT is available as well as a manual and additional documentation in PostScript format.
[http://www.cs.umn.edu/~chow/bpkit.html]
BPMPD: A state-of-the-art implementation of a primal-dual interior point algorithm for solving optimization problems. BPMPD reliably and quickly solves a wide variety of linear programming problems, and can automatically handle special structures such as dense columns as well as explicitly handle free variables. It is written in Fortran 77.
The features of BPMPD include:

standard MPS input;

an advanced presolver which removes empty rows/colums, removes singleton rows, eliminates free single columns, removes redundant constraints and fixes variables based on min/max constraints activity, substitutes duplicated variables, removes redundant bounds on variables, eliminates free variables, and makes the constraint matrix sparser;

a sophisticated heuristic to make decisions between normal equation and augmented system approaches;

problem scaling for better numerical properties;

advanced symbolic ordering for normal equations approach;

a left-looking supernodal factorization algorithm with loop unrolling;

a supernodal backsolve with loop unrolling; and

numerical robustness (e.g. iterative refinement, PCG, QMR).

A source code distribution of BPMPD is available and is freely available for non-commercial uses. A user's manual and several technical papers are available in the way of documentation.
[http://www.sztaki.hu/~meszaros/bpmpd/]
bpowerd: A power daemon for Linux for controlling Best Power Patriot and Patriot Plus UPS units.
[http://www.ccraig.org/bpowerd/]
BRAGI: A program initially developed for the homology modeling of proteins with unknown structure and the design of proteins with new properties. The functionality has since been expanded and now includes:

display of molecules in several data formats;

creation of new or editing of existing molecules;

display of molecules as space-filling or ball and stick models;

calculation and display of the molecular surface and secondary structure;

display of the backbone torsion angles;

exchange of amino acides and variation of torsion angles with interactive energy calculations;

comparison of the 3-D structure and superposition of two molecules by RMS fitting;

automatic creation of optimal protein fits;

calculation of covalent and potential hydrogen bonds;

output to display or printable file;

building or replacing loops; and

identification of specific residues or atoms with a label.

The source code is available as are several binaries including Linux Intel. A user's manual is available in PostScript format.
[ftp://ftp.gbf.de/pub/Bragi/]
Brain: A high-level scripting language with a syntax resembling something between Smalltalk and JavaScript. It is fully object-oriented (i.e. everything is an object) and uses a prototype-based (as opposed to a class-based) object model. The features include:

automatic memory management;

closures, i.e. when a nested code block is defined the variables of the outer scopes and be accessed;

built-in high-level data structures;

exceptions; and

arbitrary precision numbers.

A source code distribution is available as well as a manual.
[http://brain.sourceforge.net/]
BRANCH: The BRANCH-network dynamic flow model is used to simulate steady or unsteady flow in a single open-channel reach (i.e. branch) or throughout a system of branches (i.e. network) connected in a dendritic or looped pattern. BRANCH is applicable to a wide range of hydrologic situations wherein flow and transport are governed by time-dependent forcing functions. It is particulary suitable for the simulation of flow in complex geometric configurations involving regular or irregular cross-sections of channels having multiple interconnections, but can also be used for flow in a single, uniform open channel. It will compute time-varying water levels, flow discharges, velocities, and volumes at any location within the network. BRANCH works much better than simpler routing methods in open channel situations where severe backwater and/or dynamic flow conditions prevail. Surface and groundwater interactions can be simulated using BRANCH coupled with MODFLOW.
BRANCH uses a weighted, four-point, implicit, finite-difference approximation of the unsteady flow equations, with the equations formulated using water level and discharge as dependent variables. This approach allows accounting for nonuniform velocity distributions via the momentum Boussinesq coefficient, accomodating flow storage and conveyance separation, treating pressure differentials due to density variations, and including wind shear as a forcing function. An extended form of the Saint Venant equations is used to provide a high degree of flexibility for simulating diverse flow conditions as are produced by varied forcing functions in channels of variable cross-sectional properties. The effects of hydraulic control structures are treated via a multi-parameter rating method. The model accomodates tributary inflows and diversions as well as lateral overbank flows, and includes a Lagrangian particle-tracking scheme for conservative constituents.
A source code distribution of BRANCH for UNIX platforms is available. The primary documentation is contained within Schaffranek et al. (1981) and Swain and Wexler (1993). This is part of the USGS Water Resources Applications Software collection.
[http://water.usgs.gov/software/branch.html]
bras: An alternative to make created, according to the author, to smooth out the ``rough edges'' of make. The features of bras include:

rule-controlled command execution similar to make;

written as a Tcl script so no compilation is required;

uses of Tcl syntax so commands associated with rules can contain control structures;

dependencies in foreign directories can trigger sourcing rule files in that directory so recursive execution is not needed;

several types of rules including Newer, Exist, and Always;

extensibility for addition of new types of rules;

distinctions made between dependencies and prerequisites;

multiple targets in one rule;

multiple rules for a target; and

enhanced pattern rules.

A source code distribution is available.
[http://wsd.iitb.fhg.de/~kir/brashome/]
BRATIO: An algorithm for evaluating the complete beta function ratio and its complement that uses a new continued fraction and a new asymptotic series along with classical results. This Fortran 77 routine is accurate to 14 significant digits. This is TOMS algorithm 708 and is documented in Didonato and Morris Jr. (1992).
[http://www.acm.org/calgo/contents/]
[http://www.acm.org/toms/V18.html]
[http://www.netlib.org/toms/index.html]
BREP: The Boundary REPresentation library is an implementation of a topological data structure that represents the boundary of a polyhedral solid. It is a core layer on top of which a 3-D model topology fixer can be implemented. BREP represents the boundary or surface of a solid by means of a set of topological entities including solids, shells, faces, contours, wings, edges and vertices. The library maintains adjacency and containment relations between these entities by providing:

constructors and destructors to create/dispose of solids, shells in a solid, etc.;

modifiers to split or join edges or contours, create notches and slits, etc;

selectors and iterators to implement such queries as "what are the contours in this face","what face is sharing this edge on the other side", etc.; and

a sorted octree of vertices in a solid for fast vertex searching, etc.

The current (8/00) implementation is written in C, although a C++ rewrite is planned.
[http://breplibrary.sourceforge.net/]
BriefCase: A toolkit that expands the basic capabilities of RCS to manage software system component revisions throughout their development, release and maintenance life-cyles. BriefCase implements a client/server interface to an RCS-based central repository, with project directory structure integrity preserved automatically via built-in work directory/repository mapping. The functionality and features include:

project organization, revision control and release management;

central repository management of shared project files;

client/server support for multiple developers;

easy isolation of bug-fix work from enhancement work;

branch revisions and merging;

an integrated product build facility based on make;

integrated defect and enhancement tracking;

software release life-cycle management;

cross-replica and cross-client-host lock integrity;

command behavior options that allow certain commands to be enabled, restricted, or disabled by project; and

import and conversion tools with support for CVS, RCS, SCCS and PVCS.

The BriefCase source code is available as Open Source. Compilation and use requires ksh (any generally available version) and awk. The source distribution includes the documentation in several popular formats.
[http://www.applied-cs-inc.com/bcintro.html]
BRL-CAD: A computational solid geometry (CSG) solid modeling system whose four major components are:

a solid geometric editor;

a ray tracing library;

two lighting models; and

a wide range of image handling, data comparison and support utilities.

BRL-CAD supports several methods for the geometric representation of data including:

the CSG BRL database originally used by the project;

extensions including solids composed of collections of uniform B-splines and NURBs;

a faceted data representation; and

n-manifold geometry (NMG), which converts CSG solid models into approximate polygonalized boundary representations suitable for processing by subsequent applications as well as high-speed hardware display.

All geometric objects can be combined using boolean set-theoretic operations such as union, intersection and substraction. Material properties and other attributes can be associated with the geometry objects as a critical part of linking BRL-CAD with application codes. Source code and binary distributions are available. They are available in encrypted form via the Web. A free license agreement must be completed and FAXed to the developers to obtain a decryption key. The hardcover manual set is slowly being converted to electronic form.
[http://ftp.arl.mil/brlcad/]
Broadcast 2000: A nonlinear audio and video editor for Linux. The features include:

unlimited audio and video tracks;

a full-featured audio editor;

rendering audio by first reading large chunks of audio from disk and then rendering small fragments through the console to the sound driver for virtually uninterruptable audio playback;

audio recording using the same process in reverse;

a duplex mode for playing audio while recording;

extensive use of caching to speed up rendering;

reading several formats incuding WAV, raw audio, Quicktime, and still-frame PNG, JPEG and TIFF images;

an asset manager for perusing file, deleting them, viewing their attributes, building and rebuilding indexes, and appending new tracks;

a transport manager that controls all playback functions;

several editing functions including cut, copy, paste and clear; and

a camera and projector for video track automation.

A source code distribution of this beta (5/99) software is available.
[http://heroine.linuxave.net/bcast2000.html]
Broadway: The name given to the X11R6.3 release of the X Window System, the last release of X11 by the X Consortium (in 1997), with all future releases of X to be released by the Open Group which is subsuming the X Consortium. Broadway introduces such features as integration with Web servers, universal access to applications, improved low-bandwidth communications, network print, and networked audio to the X Window System.
The salient features of Broadway include:

the X.Fast Extension, a protocol for using X11 applications over low-speed networks like dial-up modem lines (formerly known as the Low-Bandwidth X or LBX protocol;

Remote X or RX, a remote execution MIME type which allows X clients to be launched by and displayed within Web browsers using plug-in technology;

a Security Extension which expands the security system to include more information to distinguish trusted and untrusted client applications;

a Print Extension which is a new network printing protocol through the X11 protocol which allows a client to print directly to a network printer rather than via the host OS;

an Application Group Extension which allows multiple programs to have control access of applications on the X desktop;

X-Agent, which allows special X client applications to have real-time access to the interface and graphics of other X clients, and thus allows one client application to monitor or receive the output of another in real-time;

a Proxy Management Protocol which creates the ability to use proxy services, e.g. running an application through a firewall; and

Network Audio, in which a separate audio server runs alongside the X server to allow users to play and record audio across the network.
browsers: Browsers are clients for documents obtained from web servers. Those available for Linux platforms include:

Amaya, an experimental, test-bed browser developed by W3;

Arena, the previous test-bed browser of W3 that is now developed by Yggdrasil;

Chimera, a browser written using Xlib;

Cineast, a browser written in a Tcl/Tk extension called OTcl;

Express, a planned Open Source browser as part of the GNOME project;

Grail, a browser written in Python;

Gzilla, a browser written using GTK;

Lynx, a line-mode browser;

MMM, a browser written in Objective Caml.

mMosaic, Mosaic with multicasting enhancements;

Mnemonic, a project to create a multilithic, non-dependent, extensible, modular, objective, network-aware Internet client;

Mosaic, the first graphical browser that spawned Netscape;

Netscape, the biggie whose source is freely available as of 4/98 at mozilla.org;

Plume, a browser written using Tcl/Tk;

Qweb, a browser that can also display SGML documents;

W3, a full-featured browser for the Emacs environment; and

w3m, a text-based broser that can render tables and frames.
brusey20: A tool for converting state diagrams into synthesizable VHDL. State diagrams created with XFig and exported in .PIC format are processed by brusey20 to yield behavioral VHDL descriptions of the state machine. Source and binary distributions are available, the former under the GPL. The documentation is quite sketchy.
[http://www.servtech.com/~tcmayo/things/computers/programming/brusey20.html]
BSCW: Basic Support for Cooperative Work is a package which offers shared workspaces for exchanging documents of any kind. BSCW allows you to download and upload documents via a Web browser, and the workspace keeps you aware of all events, e.g. creating, reading, and changing objects. It also supports event notification, group management and much more. BSCW is written in Python and can be used on any UNIX system with an installation of that language.
[http://bscw.gmd.de/]
BSD: The first Berkeley Software Distribution was created in early 1977 by Bill Joy. It contained a Pascal programming system and the line editor ex in addition to various other improvements to Version 5 of the UNIX operating system distributed by AT&T. (This wasn't the first UNIX to be used at Berkeley, by the way, as a coalition of departments had purchased a PDP-11/45 and installed a UNIX Version 4 tape on it during January 1974.) Development on BSD continued as Joy improved the Pascal system and wrote the first version of vi and the precursor to termcap. This improved distribution was called the Second Berkeley Software Distribution or 2BSD in mid-1978. The distribution continued to be maintained and expand even after Joy left for other projects, with the final 2.11BSD version still running on various PDP-11s.
The 3BSD distribution originated from a need to port 2BSD from the 16-bit PDP-11 to the 32-bit VAX-11/780. This started in mid-1978 and culminated in the first release of 3BSD in December, 1979. The most significant advance of this version - and indeed the need that originated it - was a virtual memory system to take advantage of new hardware capabilities on the VAX. This memory system was mostly developed by Ozalp Babaoglu, with (a returned) Bill Joy, Peter Kessler and Marshall McKusick doing most of the rest of the work to port the various parts from a 16-bit to a 32-bit system.
At around the same time as the 3BSD release, AT&T switched their development emphasis from research releases to stable commercial releases. This left a significant void in regards to UNIX research, especially given DARPA's decision to choose UNIX as the standard on which to unify their growing research network in mid-1979. The void was filled when a Berkeley proposal to develop an enhanced version of 3BSD led to an 18-month contract beginning in April 1980. An organization called the Computer Systems Research Group (CSRG) was established to fulfill the contract. Bill Joy led the research effort that released 4BSD in October 1980. Enhancements over 3BSD included job control, auto reboot, a 1K block file system, support for the just-released VAX-11/750, the Franz Lisp system, and an enhanced mail handling system. The next release was 4.1BSD and featured extensive kernel performance enhancements as well as auto configuration code. This was going to be called 5BSD until AT&T expressed concern that it would be confused with their System V release, after which it was agreed to increment only the minor number in future releases.
An intermediate version called 4.1c was released in April 1983. This contained many of the features in the ambitious plan for 4.2 including a new and faster filesystem, prototype IPC facilities, an implementation of TCP/IP and the beginnings of a kernel reorganization to isolate machine dependencies. 4.2BSD was released in August 1983 and included new signal facilities, increased networking support, a simplified installation process and disc quota facilities. This was an extremely popular release and briefly enjoyed a lead over AT&T's System V in installations until the latter caught up with its networking and file system enhancements.
The planned release of 4.3BSD in June 1985 after two years of work tuning the system and improving the network code was stalled when BBN complained to DARPA that 4.2BSD had never been updated with the final version of their network code. DARPA tested the pre-release 4.3BSD with both networking code bases and decided to go with the Berkeley version, which was released in June 1986. The next release - 4.3BSD-Tahoe in June 1988 - was an interim release notable for the completion of the work to split the kernel into machine-dependent and -independent parts. Up to this point all those who used any BSD release had to first buy an AT&T source license. The increasing cost of this license and the fact that the networking portions of BSD were developed independently of AT&T led to the separate release of the networking code and utilities in the Tahoe version as Networking Release 1 in June 1989. This was also the advent of the BSD license wherein a licensee could release the code modified or unmodified in source or binary form with no accounting or royalties to Berkeley, with the only requirements being the retention of the copyright notices and that proper attribution be made to previous contributors.
Another interim release - 4.3BSD-Reno - was made in early 1990. This was notable for the incorporation of the virtual memory system from the Mach OS and a Sun-compatible version of the Network Filesystem (NFS). In June 1991 Networking Release 2 was announced. It was much more than an enhancement of Release 1 - and was indeed just six kernel files short of being an AT&T-independent, complete UNIX distribution. The CSRG had pioneered the net-based development paradigm in the previous year, with all but those six files having been completely rewritten from scratch by them and volunteers from across the net. Bill Joy rewrote the last six files within six months of Release 2 to create a complete UNIX system for the Intel 386 architecture called 386/BSD, which he made freely available via FTP. This was notable in that the previous releases had been available only on tape for a $1000 distribution fee (in addition to the AT&T license fee).
The CSRG had insufficient resources to keep up with the bug fixes and enhancments for 386/BSD, which led to the formation of the NetBSD group in early 1992 to help maintain and enhance 386/BSD. What became known as the NetBSD distribution emphasized the support of as many platforms as possible as well as the sort of continuing research that had been done by CSRG. A few months later another group called FreeBSD formed with an initial goal to support only the PC architecture for less advanced users (in a manner similar to the early years of Linux). They emphasized elaborate installation scripts and cheap distribution via CD-ROM, leading to what is still the largest installed base of all systems derived from Release 2. Another group called OpenBSD spun off from NetBSD in the mid-1990s with the aims of focusing on the security of the system and making it easier to use and more widely available.
The formation of BSDI to sell a commercial version of Release 2 (with their rewritten versions of the six kernel files) starting in January 1992 led to what is now known as ``The Lawsuit.'' Unix System Laboratories (USL) - a subsidiary of AT&T spun off to develop and sell UNIX - filed a suit against BSDI alleging that their release contained proprietary USL code and trade secrets. Various legal machinations over the next two years including dragging the University into the suit as well as the acquisition of USL from AT&T by Novell led to a settlement in January 1994. The final result was that 3 of over 18,000 files in Release 2 were were removed, a number of minor changes were made to other files, and USL copyrights were added to about 70 files (which were still freely redistributable).
The first post-lawsuit BSD was called 4.4BSD-Lite and was released in June 1994 under the same Berkeley license as the Networking releases. Since USL had agreed not to sue any organization using 4.4BSD-Lite as the base for their system, BSDI, NetBSD and FreeBSD all restarted their code base using its sources. The downside of the temporary delay in overall BSD development was more than balanced by all the groups having to resynchronize with the three years of development since Networking Release 2. Soon after the release of 4.4BSD-Lite, Release 2 in June 1995 the CSRG was disbanded, with further BSD development being ceded to FreeBSD, OpenBSD, NetBSD and any other group that wants to use that final release to create a distribution.
See DiBona et al. (1999) for a much lengthier and more detailed version from which this was extracted. Books covering the various incarnations of BSD include Computer Systems Research Group, UC Berkeley (1994), Leffler et al. (1989) and Wilson (1991).
Related newsgroups include:

comp.unix.bsd.386bsd.announce

comp.unix.bsd.386bsd.misc

comp.unix.bsd.bsdi.announce

comp.unix.bsd.bsdi.misc

comp.unix.bsd.freebsd.announce

comp.unix.bsd.freebsd.misc

comp.unix.bsd.misc

comp.unix.bsd.netbsd.announce

comp.unix.bsd.netbsd.misc
BSDMS: The Bridge Scour Data Management System is a software package that supports the preparation, compilation, and analysis of bridge scour measurement data. It can be used to interactively store, retrieve, update, and display bridge scour and associated data. A data set for a site can consist of more than 200 items, including variables that allow local pier scour, local abutment scour, contraction scour, and long-term scour measurements to be described. The data items also cover all of the other information needed to characterize a given situation including site data, measured data, flood event data, and channel geometry data. There is a program option that permits comparison of observed scour depths with estimates from selected published scour equations.
A source code distribution of BSDMS for UNIX platforms is available. The primary documentation is contained within Landers et al. (1996) and This is part of the USGS Water Resources Applications Software collection.
[http://water.usgs.gov/software/bsdms.html]
bsdutils: A port of some basic UNIX commands from BSD to Linux. The commands include:

ac, displays connect time accounting info;

accton, enables/disables system accounting;

amd, automounting utilities package;

apm, advanced power management control program;

apmd, advanced power management monitor daemon;

arp, address resolution display and control;

bad144, reads/writes DEC standard 144 bad sector information;

bootpd, an Internet Bootstrap Protocol (BOOTP) server daemon;

bootpef, a BOOTP extension compiler;

bootptest, sends BOOTP queries and prints responses;

catman, formats cat pages from man pages;

chown, changes file owners and groups;

chroot, changes the root directory;

chrtbl, creates character classification and upper/lower case conversion tables;

cnwctl, displays stats for and controls Netwave AirSurfer PC cards;

config, builds kernel compilation directories;

cron, daemon for executing schedules commands;

dbsym, copies the kernel symbol table into db_symtab space;

dev_mkdb, creates a /dev database;

diskpart, calculates default disk partition sizes;

dumpfs, dumps file system information, e.g. super block and cylinder group information;

dumplfs, prints the file system layout information for the LFS file system;

edquota, edits user quotas;

eeprom, displays or modifies the contents of the EEPROM or OpenProm;

envstat, display environmental sensor readings;

eshconfig, configure a HIPPI network interface;

faithd, FAITH IPv6/v4 translator daemon;

greconfig, displays or manipulates the characteristics of the GRE 4 tunnel device;

grfconfig, alters the GRF device screen mode definitions;

grfinfo, displays info about GRF graphics devices;

ifmcstat, dumps multicast group management stats;

inetd, internet super-server daemon;

iostat, displays kernel statistics;

iteconfig, modify console attributes at runtime;

kgmon, generate a dump of the operating system's profile buffers;

kvm_mkdb, creates a kernel database;

lastlogin, indicates the last login time of users;

mailwrapper, invokes a mail transfer agent (MTA) based on a configuration file;

map-mbone, a multicast connection mapper;

mdconfig, configures memory disks;

mdsetimage, sets the kernel RAM disk image;

memswitch, gets or sets X68K memory switch;

mld6query, sends a multicast listener query;

mopd, a daemon servicing MOP load requests;

mrinfo, displays configuration info from a multicast router;

mrouted, a multicast routing daemon;

mtrace, traces multicast path from a source to a receiver;

mtree, maps a directory hierarchy;

ndp, controls and diagnoses IPv6 neighbor discovery protocol;

netgroup_mkdb, generates the netgroup database;

nfsd, NFS server daemon;

pcnfsd, (PC)NFS authentication and print request server;

pim6dd, daemon for PIM for IPv6 dense mode;

pim6sd, daemon for PIM for IPv6 sparse mode;

pstat, displays system data structures;

pvcsif, configures ATM PVC sub-interfaces;

pvcxctl, displays or controls ATM PVC transmitter parameters;

quot, display disk space occupied by each user;

quotacheck, filesystem quota consistency checker;

quotaon/quotaoff, turns filesystem quotas on and off;

rarpd, a reverse ARP daemon;

rbootd, HP remote boot server;

rdate, sets the system date from a remote host;

repquota, summarize quotas for a file system;

rip6query, a RIPng debugging tool;

rmt, remote magnetic tape protocol module;

route6d, RIP6 routing daemon;

rpc.bootparamd, boot parameter server;

rpc.lockd, NFS file locking daemon;

rpc.statd, host status monitoring daemon;

rpc.ypasswdd, YP update password file daemon;

rpcbind, maps universal addresses to RPC program number;

rtadvd, router advertisement daemon;

rtsold, router solicitation daemon;

sa, prints system accounting statistics;

screenblank, screen saver daemon;

sesd, monitors SCSI environmental services devices;

sliplogin, attaches a serial line network interface;

slstats, reports SLIP-related statistics;

spray, sends many RPC packets to a host;

tadpolectl, gets or sets tabpole microcontroller state;

tcpdchk, TCP wrapper configuration checker;

tcpdmatch, TCP wrapper oracle to predict how the TCP wrapper will handle a specific service request;

tcpdump, dumps traffic on a network;

trpt, transliterates a TCP protocol trace;

trsp, transliterates a sequenced TCP packet protocol trace;

unlink, calls the unlink function;

usbdevs, shows USB devices connected to the system;

vipw, edits the password file;

vnconfig, configures vnode disks;

wiconfig, configures WaveLAN/IEEE devices;

wsconscfg, configures virtual terminals on a WSCONS display;

wsfontload, loads a font bitmap into a WSCONS display device;

ypbind, creates and maintains a bind to a YP server;

yppoll, asks the version of the YP map from a YP server; and

ypserv, a YP server daemon.

[http://sourceforge.net/projects/bsd-utils-aconf/]
BSML: The Bioinformatic Sequence Markup Language is a public domain protocol for graphic genomic displays. The goals of the BSML project are to describe the features of genetic sequences, the features of graphic objects used to represent sequence features, determine procedures for assigning graphic objects to sequence features, and determine how to store and transmit encoded sequence and graphic information. This is to be based on SGML and XML to conform with the latter standard.
[http://www.visualgenomics.com/bsml/]
[http://www.oasis-open.org/cover/xml.html]
BSPlib: The Bulk Synchronous Parallel library is an implementation of the BSP model of parallel computation. The BSP model consists of a set of processor-memory pairs, a communications network which delivers messages point-to-point, and a mechanism for the efficient synchronization of all, or a subset, of the processors. A BSP computation consists of a sequence of parallel supersteps where each superstep is a sequence of steps (basic operations on locally held data) followed by a barrier synchronization at which point any non-local data accesses take place. The BSPlib package contains efficient implementations of standard BSP primitives. Efficient implementations of it are created using either the most efficient native communications facilities of the host machine to create a native version, or making use of generic packages such as PVM and MPI to create generic versions.
The most recent (4/97) version of BSPlib is available as source code or in binary format for Cray T3D, SGI Challenge, IBM SP2, SGI, Sun SunOS and Solaris, and Linux Intel platforms. Documentation is available in the form of man pages and some technical reports in PostScript format. Some ancillary contributed programs are also available. See Hill et al. (1998).
[http://www.bsp-worldwide.org/implmnts/oxtool.htm]
[http://pegasus.cc.ucf.edu/~dsd75511/bsp.html]

BSPPACK

A library of numerical algorithms written in C according to the BSP model which uses the BSPlib standard. The programs in the package include:

bspbench, a benchmarking program;

bsplu, an LU decomposition program; and

bspmv, a sparse matrix-vector multiplication program.

A source code distribution is available.
[http://www.math.ruu.nl/people/bisselin/software.html]
BSPLINE: A package of Fortran subroutines for manipulating B-splines at a fairly high level. The routines in the package are:

BINT4, for interpolating with splines of order 4;

BINTK, for interpolating with splines of order k;

BSQAD, for integrating the B-representation on subintervals;

PPQAD, for integrating the PP-representation;

BFQAD, for integrating the product of a function F and any spline derivative in the B-representation;

PFQAD, for integrating the product of a function F and any spline derivative in the PP-representation;

BVALU, for evaluating the B-representation or a derivative;

PPVAL, for evaluating the PP-representation or a derivative;

INTRV, for getting the largest index of the knot to the left of x;

BSPPP, for converting from B- to PP-representations;

BSPVD, for computing nonzero basis functions and derivatives;

BSPDR, for setting up a difference array for BSPEV;

BSPEV, for evaluating the B-representation and derivatives;

BSPVN, a general routine called by several other routines for function and derivative evaluations.

The BSPLINE package is available in source code form. It is written in Fortran 77 with both single and double precision versions available. The use of the code is documented in comment statements within each subroutine. See de Boor (1977) and de Boor (1978). This is part of CMLIB.
[http://sunsite.doc.ic.ac.uk/public/computing/general/statlib/cmlib/]
[http://www.hensa.ac.uk/ftp/mirrors/statlib/cmlib]
BSVC: A microprocessor simulation framework written in C++ and Tcl/Tk. BSVC provides an object-oriented framework that simplifies the task of writing a microprocessor simulator. This has been used to build an emulator for the Motorola 68000 processor but can be used for a wider range of applications. This is available in both source code and binary versions for UNIX platforms. RPM packages are also available.
[http://www2.ncsu.edu/eos/service/ece/project/bsvc/www/]
BTL: The Bioinformatics Template Library attempts to do for bioinformatics programming what the STL does for generic C++ programming. The BTL uses templates to provide containers, generic algorithms and other types of components needed by and specific to bioinformatics and molecular modeling. The classes include:

BTL_Vector, a vector of real numbers of N dimensions;

BTL_Matrix, a matrix of real numbers of N dimensions;

BTL_CholeskyInverse, for inverting a positive definite matrix;

BTL_FFT, for calculating 1-, 2- and 3-D FFTs;

BTL_Vertex, a template graph vertex;

BTL_Graph, a template graph with edges as simple pointers to vertices;

BTL_Graph1, a graphic container adaptor for use with most STL containers;

BTL_Graph2, a graphic container adaptor for the STL containers not handled by BTL_Graph1;

BTL_VertexWithEdges, a template graph vertex;

BTL_Edge, a template graph edge;

BTL_GraphWithEdges, a template graph with two template parameters determining the type of vertices and edges;

BTL_Graph3, a labelled graph container adaptor for use with 2 STL containers of most types;

BTL_Graph4, a labelled graph container adaptor for use with 2 STL containers of types not covered by BTL_Graph3;

BTL_DFSIterator, for iterating over a connected subgraph in depth-first order;

BTL_ConstDFSIterator, a constant version of the previous;

BTL_LeastSquaresFit, for least squares superposition of two sets of 3-D coordinates;

BTL_PDBSort, for sorting objects into Brookhaven Data Bank (PDB) format;

BTL_AminoAcidProperty, returns amino acid property values;

BTL_NumericLimits, returns floating point constants for the template parameter;

BTL_NumericUtilities, estimates the difference between two numbers in terms of number of significant decimal places;

BTL_XYZProcess, reads XYZ format coordinate files and puts the data in vectors;

BTL_PIRProcessor, parses PIR format sequence files; and

BTL_PPMProcessor, parses ASCII PPM format image files.

A source code distribution is available.
[http://www.cryst.bbk.ac.uk/classlib/bioinf/BTL.html]
BTN: The Block Truncated Newton package is for unconstrained nonlinear minimization for parallel computers suitable for large-scale optimization tasks. BTN uses a block truncated Netwon method in conjuction with a line search strategry. An approximate Newton direction is found by applying the block conjugate gradient method to the Newton equations, with blocking used to enable parallelism in both the linear algebra and function evaluation portions. Two versons of the algorithm are included. One is an easy-to-use version which requires only a subroutine to evaluate the objective function and its first derivatives. The other allows more complicated usage including parallel function evaluation.
BTN is TOMS algorithm number 711. It is written in Fortran 77 and uses double precision real variables. It sets machine constants via the D1MACH subroutine. It is documented in Nash and Sofer (1991) and Nash and Sofer (1992).
[http://www.acm.org/calgo/contents/]
[http://www.netlib.org/toms/index.html]
[http://www.acm.org/toms/V18.html]
btng: Beholder - The Next Generation is a package of network measurement software. It consists of: an RMON compliant network monitor; the Tricklet library of SNMP tools which can collect data from SNMP devices such as a running Beholder; Tricklet scripting support for Perl, the Bourne shell, and Tcl/Tk; and Tricklet/TK, an X11 front-end for Tricklet which is essentially a MIB browser. This can currently (4/97) only collect data from an Ethernet network.
The source code for btng is available and is written in ANSI C. It can be installed on OS/2, Linux Intel, Sun SunOS and Solaris, and DEC Ultrix platforms via installation scripts. Documentation for the system is included in the package.
[ftp://dnpap.et.tudelft.nl/pub/btng/]
[http://dnpap.et.tudelft.nl/DNPAP/Software/software.html]
bttv: A Linux driver for Brooktree Bt848-based frame grabbers.
[http://www.thp.uni-koeln.de/~rjkm/linux/bttv.html]
bttvgrab: A program for grabbing video sequences using the Video4Linux driver. This was originally built for the bttv driver which still provides the best results. The goal of this package is to provide high-quality grabbing suitable for video recording. This is accomplished by attempting to not leave out a single frame. This is done by buffering several frames as well as by synchronizing sound and frame loss tracing. An included converter creates MPEG-1 or -2 video sequences from the grabbed frames, converting the sound as well.
[http://moes.pmnet.uni-oldenburg.de/bttvgrab/]
[http://rufus.w3.org/linux/RPM/suse/6.0/gra1/bttvgrab-0.14.5-9.i386.html]
b2c: A compiler for the BETA language which reads BETA and translates it to C which is then compiled using the native C compiler. The compiler is written in BETA and is not yet (7/97) able to translate itself, although binary versions are currently available for Linux Intel and Sun Solaris platforms.
[http://troubadix.physik.tu-berlin.de/~petz0433/beta/eindex.html]
B2: An object-oriented extensible data analysis system implemented under the Oberon system environment. It is designed for the efficient analysis of data from multidetector nuclear physics experiments, although it has wider applicability. B2 can be used as either a histogramming and display subroutine library or as a component framework for developing complete acquisition and analysis systems. The system implements persistent object management, a histogramming library, the routing of experimental data packets, abstract data processing components, and interactive graphical display capabilities. Note: As of 12/98 this has disappeared and I can't find it.
[http://nuchem.nsrl.rochester.edu/~skulski/B2.html]
BtYacc: A modified version of yacc that supports automatic backtracking and semantic disambiguation to parse ambiguous grammars. It also has syntactic sugar for inherited attributes. It was originally written to make it easy to write a C++ parser. ByYacc generated parsers, upon running into a shift-reduce or reduce-reduce error in the parse table, remember the current parse point and go into trial parse mode. It then continues parsing, ignoring most rule actions, and if it runs into an error it backtracks to the most recent conflict point and tries another alternative. If it finds a successful parse it backtracks to the point where it entered trial mode and continues with a full parse. A source code distribution is available that can be compiled and used on most UNIX platforms.
[http://www.siber.com/btyacc/]
BUGS: Bayesian inference Using Gibbs Sampling is a program that carries out Bayesian inference on complex statistical problems for which there is no exact analytical solution and for which even standard approximation techniques have difficulties. BUGS assumes a Bayesian or full probability model in which all quantities are treated as random variables. The model consists of a defined joint distribution over all unobserved (parameters and missing data) and observed (data) quantities. It then conditions on the data to obtain a posterior distribution over the parameters and unobserved data, after which the distribution is marginalized using a Monte Carlo approach to numerical integration to obtain inferences on the main quantities. The statistical model is expressed in the BUGS language, a compiler processes the model and available data into an internal data structure suitable for efficient computation, and a sampler operates on this structure to generate appropriate values of the unknown quantities.
BUGS is intended for complex models in which there may be many unknown quantities but for which substantial conditional independence assumptions are appropriate. Examples include generalized linear models with hierarchical or crossed random effects, latent variable or frailty models, measurement errors in reponses and covariates, informative censoring, constrained estimation, and missing data. of interest.
BUGS is written in Modula 2 but distributed in binary format for various platforms including Linux Intel. An extensive user's manual is available in PostScript format.
[http://www.mrc-bsu.cam.ac.uk/bugs/]
Bugzilla: A data for bugs that allows bugs to be reported and then assigns them to appropriate software developers. The developers can use it to keep a to-do list as well as to prioritize, schedule and track dependencies. Bugzilla is used to track both bugs and Requests for Enhancement or RFEs, with the latter being requests for new or improved features. The bug/RFE reports consists of several fields including:

Component, i.e. which part of a multicomponent project a bug report applies to;

Status Whiteboard, a general notekeeping field that can be related to QA, used to store keywords, or used for noting when bugs have test cases;

Target Milestone, a field indicating when specific features are planned to be completed;

Dependency, a field indicating when fixing one bug is dependent on first fixing another; and

Attachment, a field containing additional information in the form of test cases, screen shots, editor logs, etc. that can aid in locating a bug.

Snapshots of Bugzilla are available both as tarballs and CVS versions.
[http://www.mozilla.org/bugs/]
BuildIT: A graphical user interface creator for Java version 1.1. BuildIT allows for the graphical creation and placement of widgets onto a dialog, and also for the setting of various properties for all components. The widgets can be mapped to variables so they can be controlled once the applet or application is launched. Version 0.1.1 (7/98) supports several components including button, canvas, choice, checkbox, label, list, menubar, menu, scrollbar, text area, and text field widgets. This is built on top of Qt 1.32. A source code distribution is available.
[http://www.stud.uni.torun.pl/~scisly/june/]
Bulldozer: A WYSIWYG HTML editor for the X Windows system. The goal behind this software was to create a decent authoring environment for the production of HTML pages. THe present version (7/96) can handle most HTML 2.0 and 3.0 tags as well as tables. Features include cut and paste, find/replace, spell checking, texst highlighting, easy link insertion, help, WYSIWYAG view and edit, editing in WYSIWYG mode, cgi script support, previewing, a syntax checker, entities, map support and more. Bulldozer is written in C and the X Window System and uses the Motif widget library. Binary versions are presently available for Sun SunOS and Solaris, SGI Irix, AIX, HP-UX, and Linux platforms. The Linux binary is available either statically or dynamically linked to the Motif libraries. Documentation is available as help files in the software.
[http://sunsite.unc.edu/pub/Linux/apps/www/editors/]
Burg: A program for fast optimal instruction selection and tree parsing. Burg generates a fast tree parser using Bottom-Up Rewrite System (BURS) technology. It accepts a cost-augmented tree grammar and produces a C program that discovers in linear time an optimal parse of trees in the language described by the grammar. This has been used to construct fast optimal instruction selectors for use in code generation.
[ftp://ftp.cs.arizona.edu/people/todd/]
BURGER: A collection of Fortran codes for solving the Burger's equation including:

BURG494, solves the scalar 1-D equation using TOMS 494;

BURG621, solves the scalar 2-D equation using TOMS 621;

BURG690, solves the coupled 1-D equation using TOMS 690;

BURG731, solves the scalar 1-D equation using TOMS 731;

BURG758, solves two coupled equations in 2-D using TOMS 758;

BURG2D, similar to BURG758 but for the scalar equation with known analytic solution;

BURG759, solves three coupled equations in 3-D using TOMS 759;

BURG3D, similar to BURG759 but for the scalar equation with known analytic solution;

BURGADV, solves the scalar equation in one space dimension using an adaptive algorithm;

BURGCL1, solves the scalar equation in one space dimension using CLAWPACK routines;

BURGCL2, solves the scalar equation in two space dimensions using CLAWPACK routines;

BURGIBT, solves three coupled equations in one space dimension using the LSOIBT solver from ODEPACK;

BURGLSO, solves the scalar equation in one space dimension using the LSODE solver from ODEPACK;

BURGRKF, solves the scalar 2-D equation using a Runge-Kutta routine;

BURGINT, solves the 3-D scalar equation with an adaptive integration code and tests it against an analytical solution;

BURGLCM, solves the 1-D scalar equation using Legendre and Chebyshev function expansions and tests them against an analytical solution;

BURGRAT, solves the 1-D scalar equation using rational Chebyshev expansions and tests it against an analytical solution;

BURGSP1, solves the 1-D equation using spline function expansions and tests it against an analytic solution; and

BURGSP2, solves the 2-D equation using spline function expansions and tests it against an analytic solution.

[ftp://blas.cis.mcmaster.ca/pub/fred/cfd/burger/]
BurnIT: A Java frontend to mkisofs and cdrecord which eases the task of burning CD-ROMs.
[http://sunsite.auc.dk/BurnIT/]
Burt: The BackUp and Recovery Tool is an extension to Tcl/Tk 8.0 designed to perform backups to and recoveries from tapes. Burt is a parallel network backup system designed with flexibility, speed and reliability as its primary concerns. It is fundamentally a multiplexor that takes data from any number of input streams and combines those streams into one output stream. The features include:

backing up data from virtually any sources;

support for the parallel backup of many systems directly to tape; and

verification of data integrity by checksumming data as it is written to tape, reading it from the completed backup tape, and checksumming again.

The new primitive Tcl commands implemented in BURT are:

schedule, builds a schedule table in memory to specify items scheduled for backup;

backup, starts the backup process by specifying the number of channels to be used, the output and log streams for the backup, and the label for the backup medium;

readtape, reads back what is written to a tape to verify data integrity;

recover, specifies input and log channels for backup recoveries; and

status, for querying the status of backup and recovery operations.

[http://www.cs.wisc.edu/~jmelski/burt/]
BusyBox: BusyBox - the swiss army knife of embedded Linux - is a suite of small UNIX utilities in a multi-call binary. It provides minimalist replacements for most of the utilities found in bsdutils, fileutils, findutils, grep, gzip, mount, procps, shellutils, sysklogd, sysutils, sysvinit, tar, textutils and util-linux. BusyBox provides a fairly complete POSIX environment in a very small package, i.e. a kernel, a shell and an editor are all that are additionally needed to create a working system. TinyLogin was designed as a sort of complement to this.
[http://busybox.lineo.com/]
BVPLSQ: The Boundary Value Problem Least SQuares program is a solver for highly nonlinear (and possibly overdetermined) two-point boundary value problems. The solution method is a local nonlinear two-point boundary value least squares solver, i.e. a multiple shooting approach. A source code distribution of this is available. It is written in Fortran 77 and documented via source code comment statements. This is part of CodeLib. See Deuflhard (1980b).
[ftp://elib.zib.de/pub/elib/codelib/bvplsq/]
BVPSOG: A Boundary Value Problem SOlver for highly nonlinear two-point boundary value problems using a Global sparse linear solver for the solution of the arising linear subproblems. This uses a multiple shooting approach. It is written in Fortran 77 and documented via source code comment statements. This is part of CodeLib. See Deuflhard (1980b).
[ftp://elib.zib.de/pub/elib/codelib/bvpsog/]
BVPSOL: A Boundary Value Problem SOlver for highly nonlinear two-point boundary value problems using a Local linear solver (i.e. a condensing algorithm) for the solution of the associated linear subproblems. This uses a multiple shooting approach. It is written in Fortran 77 and documented via source code comment statements. This is part of CodeLib. See Deuflhard (1980b).
[ftp://elib.zib.de/pub/elib/codelib/bvpsol/]
BVSPIS: A package for computing interpolating polynomial splines with arbitrary constraints on their shape and which satisfy separable or nonseparable boundary conditions. This is TOMS algorithm 770 and is documented in Costantini (1997).
[http://www.acm.org/calgo/contents/]
[http://www.acm.org/toms/V23.html]
BVSUP: A Fortran 77 subroutine which solves a linear two-point boundary-value problem using superposition coupled with an orthonormalization procedure and a variable-step integration scheme. Each time the superposition solutions start to lose their numerical linear independence, the vectors are reorthonormalized before integration proceeds. The underlying principle of the algorithm is to piece together the intermediate (orthogonalized) solutions defined on the various subintervals to obtain the desired solution.
The BVSUP routine, written in Fortran, is available as source code. Its use is documented in comment statements within the source code. See Scott and Watts (1977). This is part of CMLIB.
[http://sunsite.doc.ic.ac.uk/public/computing/general/statlib/cmlib/]
[http://www.hensa.ac.uk/ftp/mirrors/statlib/cmlib]
bWatch: A GUI that shows the load and memory statistics for each node of a Beowulf cluster. This was written using Tcl/Tk.
[http://www.sci.usq.edu.au/staff/jacek/bWatch/]
BWNFSD: An RPC daemon used in conjunction with BWNFS, a client NFS for DOS-based PCs. BWNFSD provides authentication, print spooling, DOS 3.1 locking and sharing, GID name mapping, UID name mapping services for BWNFS, and associated applications on the PC. It can also be used by Macintosh clients. It can run simultaneously as PCNFSD but provides many more features. A source code distribution is available as part of the Shadow Ina Box package.
[http://sunsite.unc.edu/pub/Linux/system/network/sunacm/Other/bwnfsd/]
byacc: An LALR(1) parser generator designed to be as compatible as possible with yacc.
[ftp://ftp.cs.berkeley.edu/ucb/4bsd/]
bzip: A freely available, patent-free, high-quality data compression package which typically compresses files to within 10-15% of the best available techniques while being around twice as fast at compression and six times faster at decompression. Bzip also supports limited recovery from media errors and has command line flags similar to those of gzip. It uses the Burrows-Wheeler blocksorting text compression algorithm and Huffman coding.
A source code distribution of bzip is available as are binaries for several platforms including Linux Intel. It is highly portable and can be compiled and used on about any 32 or 64 bit machine with an ANSI C compiler. It is documented in a man page.
[http://www.muraroa.demon.co.uk/]
[http://www.digistar.com/bzip2/index.html]
[http://www.bzip2.org/]

[ home / linux ]

Next: Ca-Cm Up: Linux Software Encyclopedia Previous: Ba-Bm Contents

Manbreaker Crag 2001-03-08