Terminology

associative list:

in LISP a list whose elements are pairs of a key and data. To search for data by keys is supported by the language.

BISON:

an implementation of the UNIX parser code generator YACC available under the GNU General Public License.

bug:

an error in a program.

build process:

the process of generating, compiling and linking a whole software system either totally from scratch or from partly prebuilt sources, thus, updating the software project's targets.

callback:

a function which is registered and is activated (called) later upon an event. The function has three arguments. The first is associated to the object in which the event occurs, the second is client data registered together with the function and the third one is call data which carries additional information about the occuring event.

CAD:

Computer Aided Design, special techniques and programs to automate the design process.

CASE:

Computer Aided Software Engineering, mostly tools to support software production and management.

checking area:

defines where the goal is evaluated and how dependences are checked.

class:

is an aggregate containing members and methods for implementing functionality using the programming paradigms of data and function encapsulation in object-oriented programming languages.

class hierarchy:

is the hierarchy of classes obtained by inheritance beginning from the superclass as the root of the class hierarchy. Each node in the hierarchy represents a class with classes inheriting information from their respective parent node(s).

configuration:

information describing a platform.

configuration dependent directory:

a directory created by VMake to store any information which depends on the current configuration and cannot be shared between different configurations, e.g., object files and executables.

configuration file:

a file where configuration definitions for a platform is stored.

CVS:

a Code Version System available under the GNU General Public License. It is based on RCS to manage source code of different developers.

depth first:

an algorithm in evaluation a list of goals by recursively evaluating from left to right.

description file:

a file holding information about goals and dependences. These files are interpreted during the build process.

developer:

a programmer actively working on a project.

domain:

source for a TAC interface definition or target for a TAC interface creation.

environment:

external information for a process inherited from the parent. Under UNIX this are environment variables, under VMS the environment is divided into logicals and symbols.

FLEX:

an implementation of the UNIX lexical analyzer code generator LEX available under the GNU General Public License.

FSF:

Free Software Foundation, a non profit organization which is dedicated to eliminating restrictions on copying, redistribution, understanding, and modification of computer programs.

garbage collection:

in LISP a method to reclaim the memory of LISP nodes no longer accessible to the interpreter.

global design loop:

testing of a project using the global sources from the code repository. The developers are informed about the status of this design loop.

GNU:

GNU's Not Unix! A project of the FSF to develop a complete integrated software system upwardly compatible with Unix.

goal:

a target known by the software management tool either implicitly or by definition in a description file.

inheritance:

a member method or variable is inherited (used) from the parent object class when no local definition in the class exists.

job:

one update action managed by the queuing sub-agent of VMake.

key:

an optional parameter to a LISP function specified by name. This allows non-positional syntax in function calls.

LEX:

a program to generate a lexical analyzer for input processing.

lexical function:

a LISP function with or without parameters used by UNFUG during automatic code generation.

local design loop:

the edit, compile, run, and test of a project done locally by one developer.

logical function:

a LISP function with or without parameters used by UNFUG during automatic code generation to control some internal state of UNFUG.

LISP:

an interpretive programming language used in artificial intelligence. The name stands for LISt Processing.

LISP node:

a data structure in the LISP interpreter representing a typed value, e.g., a string, integer, or floating point value.

major release:

a new version of a software with possible incompatible enhancements.

manual:

one kind of documentation that holds either user or programming information about a software project, e.g., references of implemented functionality.

member:

a single data item contained in a class.

method:

a function implemented in a class context.

minor release:

a new version of a software enhancing the functionality but with no incompatibilities to previous versions.

module:

is part of a project but to small to build a sub-project.

object:

the instance of a class in object-oriented programming languages, identified uniquely through an object handle.

parent class:

a class from which members and methods are inherited.

parent project:

project which depends on the project under consideration.

parser:

a program or program part to analyze a sequence of words using a set of grammatical rules to create a structure for further processing.

patch release:

a minor correction to a software without introducing new functionality.

PIF:

the Profile Interchange file Format used by the VISTA framework.

platform:

a combination of software and hardware for which the project is built.

position independent code:

a special compilation mode of compilers to generate code which can be executed at any virtual address without relocation. This is needed to generate shared libraries on some systems.

project:

the whole software which is managed as one part during the building phase. A project may depend on other projects.

project information save file:

a specially formatted file in which information -- like dependences of a managed project -- is stored.

rapid prototyping:

quick implementation to test a design.

RCS:

a code management system for version management of source files available under the GNU General Public License.

repository:

the current copy of a software project source tree including a revision history such that previous versions of the project can be reconstructed automatically if needed (either by date or tag).

revision:

a certain status of a software project or an individual file usually identified by a revision tag or number.

rule:

is used to define dependences and update actions between sources and targets by a high level description language.

selftest:

checking the output of a built program against a known good data set.

shell script:

a file interpreted by the command line interpreter of the operating system.

software process:

is the total set of software engineering activities necessary to develop and maintain software products.

software system:

a collection of software projects with dependences.

source:

a file used as input for an update action to generate a target.

sub-project:

project with is required as dependent by the project under consideration.

symbolic name:

is used to identify files, directories, and projects globally by a unique name in VMake.

TAC:

Tool Abstraction Concept, a LISP utility used for automatic function and constant binding between different languages (e.g., C to VLisp or FORTRAN).

target:

one or more files which are generated by an update action from their corresponding sources.

TCAD:

Technology Computer Aided Design, special techniques and programs to automate the process of technology development.

template:

a file or object containing ``placeholders'' which can be used as a prototype for creating a meaningful instance of this file or object using a tuple.

tuple:

a list of strings which are placed into the ``placeholders'' of a template file to build the real output file.

UNFUG:

Universal Function Generator, a LISP utility to generate files automatically from a template and a tuple file.

update action:

an action to build the target out of the dependent sources.

user:

person using a project without developing it.

VBS:

Vienna Base System, a project supporting low level access in system independent manner.

VISTA:

the Viennese Integrated System for Technology CAD Applications.

VLisp:

the Vienna LISP interpreter.

VMake:

the Vienna Make Utility.

wrapping function:

a function used during language binding for transforming the name space and the parameters.

XLISP:

an implementation of a LISP interpreter which is freely available for non commercial use.

YACC:

a parser generator.