PARD: Programming
The Debian bug tracking system is a set of scripts which maintain a database
of problem reports. All input and manipulation of reports is done by email,
and the outstanding, recently closed and other listings of reports are made
available via a webserver. People who wish to interact with it do not need
to have accounts on the system running the database. An email client and web
browser will do.
The scripts have been parameterised so that they can be used for other
projects besides Debian.
JitterBug is a web based bug tracking system. It operates by receiving bug
reports via email or a web form. Authenticated users can then reply to the
message, move it between different categories or add notes to it. JitterBug
is used by important software development projects like The Gimp, Gnome or
the Linux Kernel.
egcs is a collaborative effort involving several groups of hackers using an
open development model to accelerate development and testing of GNU
compilers and runtime libraries.
An important goal of egcs is to allow wide scale testing of experimental
features and optimizations; therefore, egcs contains some features and
optimizations which are still under development. However, egcs has been
carefully tested and should be comparable in quality to most gcc releases.
egcs contains many improvements and features not found in gcc-2.7 and even
in the gcc-2.8 compilers.
- Integrated C++ runtime libraries, including support for most major linux
systems!
- The integrated libstdc++ library includes a verbatim copy of
SGI's STL release.
- Integrated GNU Fortran compiler
- New instruction
scheduler
- New alias analysis code
- Clig creates for your C-Program
- a command line interpreter with those features:
-
- Flag, Float, Int or String options
- number of parameters of options
can be specified
- range can be specified for the numerical options
-
options can have defaults
- options can be mandatory (not really optional
then :-)
Existence of mandatory options, correct range of numerical option arguments
and correct number of arguments for every option is checked. Violation
results in readable error messages.
Parsed results are delivered to your program in a custom-built structure.
- a readable, up-to-date usage-message
- a basic manual page
- Clig takes as input a simple description file.
- Clig generates
standard C (well, I tried as hard as I can :-) It is reported to work well
with C++.
- The resulting code is self contained and does not depend on a
library (except for libc, of course).
GCC can compile programs written in C, C++, Objective C, Ada 95, Fortran 77,
and Pascal. GCC is a full featured compiler, providing everything you need
in a C compiler.
A library of easy-to-use generic re-allocating container types for C, plus
re-allocating strings, plus some utility functions.
The Arachne ORB is for portable C++ software development. It is getting
close to 100% CORBA 2.x compliant, although the language mapping has some
elements that are not yet updated from our original adhoc 1.1ish mapping.
The ORB includes implementations of TypeCode, any, IR, DII, IIOP (still new,
but it basically works), and some COS specs (currently, just Naming and
Externalization).
Arachne runs on HP/UX 10.x, Linux 2.x, SunOS 4.x and HP/UX 9.x and also on
Windows 95/NT and Macintosh. Software that is developed with it is portable
to these platforms. Active development is on Linux 2.x, HP/UX 10.x, and
Windows 95/NT. Since we deliver software based on Arachne on the Windows
95/NT platform, some of the GUI functionality works best there. The SunOS,
HP/UX 9.x and Macintosh ports are all less recent.
It is perhaps important to note that the ORB, although it can stand on its
own, is in fact a part of a whole suite of tools. These are collectively
called Arachne, and are designed to facilitate distributed collaborative
development of component-based software systems, especially in a research
setting.
For this reason, Arachne is accompanied by a CORBA-based C++ class library
for portable GUI application development, with optional support for
multithreading (which needs work), and has some possibly interesting (but
incomplete) tools for leveraging the CORBA TypeCode for semi-automatic
generation of persistent data repositories, runtime data structures, and
data collection and display interfaces.
MetaKit is a general purpose C++ class library for highly-structured
persistent containers.
fgen is a makefile/dependencies generator for Fortran 77/90 This Perl5
script produces Makefiles for GNU Make and has already configuration files
for several compilers and is easy to customize.
Included is also f2html, a Fortran 77/90 to html converter. The user can
specify a set of colors for keywords, comments, and soon.
The Apache JServ is a Java servlet engine, an external process written in
Java which runs separate from the web server and handles requests to Java
servlets.
Japhar is the Hungry Programer's Java VM. It has been built from the ground
up without consulting Sun's sources.
ADL, or the Assertion Definition Language, is a formal notation for
describing the behavior of interfaces. This very general concept can be
applied to any interface for which the behavior can be described. The
purpose of this notation is two-fold. First, it permits the translation of
the formal description into natural languages such as English and Japanese.
Second, it permits the automatic translation of the formal description into
tests that will evaluate the behavior of an implementation of the interface
being described.
BOIL (Brunnis Own Interpreter Language) is a C-like language that was
developed by netEstate (www.netestate.de)
under Linux for special purposes. We are releasing it because it has some
special features that you will miss in other similar languages:
- Distributed programming with RPC (a BOIL-function can be declared as
external and will transparently be executed on a distant 'BOIL-server').
- Accounting and limiting of resources is possible for the whole program
or single functions.
- You can isolate single functions from the rest of
the program and disable the use of every library function. A
sandbox-environment for the whole program or single functions is easy
to implement.
- Parsing, definition and deletion of functions at runtime is
possible.
You can embed BOIL-code in ASCII/HTML and read POST/GET-data into variables.
This makes BOIL to a useful interpreter for CGI scripts.
We don't want to hide the drawbacks:
- The database-functions only support postgres.
- Portability was not a
big issue till now.
- Binary data and derivated datatypes like pointers are
not supported (possible datatypes are long,unsigned long,double,string and
void).
Oz is a high-level programming language combining constraint inference with
concurrency. Typical application areas of Oz include optimization problems
like scheduling, time tabling, placement and configuration, reasoning and
knowledge representation, processing of natural language, simulations, multi
agent systems, and sophisticated graphical user interfaces.
Oz is dynamically typed and has first-class procedures, classes, objects,
exceptions and sequential threads synchronizing over a constraint store. It
supports finite domain and feature constraints and has powerful primitives
for programming constraint inference engines at a high level.
DFKI Oz is an interactive implementation of Oz featuring an incremental
compiler, support for stand-alone applications, an object-oriented interface
to Tcl/Tk, and unique graphical tools for constraint programming. It
provides an extensive library of constraint propagators, distributors, and
search engines, including special support for scheduling. Users can add
their own constraint propagators through a C++ interface. Performance is
competitive with the best Prolog, Lisp, and constraint programming systems.
DFKI Oz is available for Unix and Windows.
NGS JavaScript interpreter is a free interpreter for the JavaScript
language. It is designed to be re-entrant, extensible, and fast. It comes
with a library and a C-API. The package has also a separate program
js to execute JavaScript script files.
GNU m4 is an implementation of the traditional Unix macro processor. It is
mostly SVR4 compatible, although it has some extensions (for example,
handling more than 9 positional parameters to macros). m4 also has built-in
functions for including files, running shell commands, doing arithmetic,
etc. Autoconf needs GNU m4 for generating configure scripts,
but not for running them.
Object Rexx is a powerful scripting language that is also available on IBM's
OS/2 and Windows95/NT.
Pike is a dynamic programming language with a syntax similar to C. It is
simple to learn, does not require long compilation passes and has powerful
built-in data types allowing simple and fast data manipulation.
The ADAPTIVE Communication Environment (ACE) is an object-oriented (OO) C++
framework that can help you develop and deploy high-performance software
systems faster and better. ACE is especially useful for systems that use
network and/or inter-process communications and that take advantage of
multithreading. While the ACE source code is free, that's not the only way
you save money with ACE. ACE's wrappers and higher-level patterns help you
develop your software quickly and portably, helping you to complete your
projects on time and within budget.
The Portable Object Compiler is a Objective-C-compatible precompiler.
Python is an interpreted, interactive, object-oriented, extensible
programming language. It provides an extraordinary combination of clarity
and versatility.
GUILE, GNU's Ubiquitous Intelligent Language for Extension, is a library
implementation of the Scheme language plus various convenient facilities.
It's designed so that you can link it into an application or utility to make
it extensible. Our plan is to link this library into all GNU programs that
call for extensibility.
Libraries that provide an interpreter for extensibility are not new. But
most of them implement ``scripting languages'' that were not designed to be
as powerful as a real programming language. GUILE uses Scheme, a powerful
yet simple dialect of Lisp. One advantage of GUILE over TCL is that Scheme
is a more powerful language. Scheme was designed as a ``programming
language'', not as a ``scripting language''. Scheme is also simpler and
cleaner than other extension languages such as Perl and Python.
But the big advantage of GUILE is that it allows support for multiple
languages. This is because Scheme is powerful enough that other languages
can conveniently be translated into it.
We have already implemented one translator, CTAX, which understands simple
C-like language. This means that any application program which is linked
with GUILE supports the CTAX language as well as Scheme. Any user can
decide, at run time, to load the CTAX translator and start typing programs
in CTAX. The application developer does not need to do anything special to
support CTAX.
Ultimately we hope to have translators for Perl, Python, TCL, REXX and Emacs
Lisp---plus any other languages that users like. Users can write their own
translators for their other languages, too. A translator should substitute
for the Scheme read function; it should read text and return a Scheme
expression which could then be evaluated. Translators should be written in
Scheme so that a user can load them into GUILE at run time.
SCM is a Scheme implementation conforming to Revised Report on the Algorithmic Language Scheme
and the IEEE P1178 specification. Scm is written in C and runs under Amiga,
Atari-ST, MacOS, MS-DOS, OS/2, NOS/VE, Unicos, VMS, Unix and similar
systems.
SART is a guile library for raytracing and high-complexity 3d modelling. You
can use it to create and render extremely complex images (such as 3D
fractals, CSGs and splines), powerful procedural textures and even mix
rendering techniques (using Z buffer, raytracing and radiosity where
appropriate, in a single image).
SLIB is a portable scheme library meant to provide compatibiliy and utility
functions for all standard scheme implementations.
SLIB supports Chez, ELK 2.1, GAMBIT, MacScheme, MITScheme, scheme->C,
Scheme48, SCM, scsh, T3.1, and VSCM.
Artistic Style is a fast, small and free reindentation and reformatting tool
for C, C++ and Java source codes, written in C++.
© 1999 by Stefan Hornburg
<racke@linuxia.de>
Last modified 03. June 1999
