source: general/prog/other-tools.xml@ bccbdaea

<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE sect1 PUBLIC "-//OASIS//DTD DocBook XML V4.4//EN"
   "http://www.oasis-open.org/docbook/xml/4.4/docbookx.dtd" [
  <!ENTITY % general-entities SYSTEM "../../general.ent">
  %general-entities;
]>

<sect1 id="other-tools" xreflabel="Other Programming Tools">
  <?dbhtml filename="other-tools.html"?>

  <sect1info>
    <othername>$LastChangedBy$</othername>
    <date>$Date$</date>
  </sect1info>

  <title>Other Programming Tools</title>

  <indexterm zone="other-tools">
    <primary sortas="a-Other-Programming-Tools">Other Programming Tools</primary>
  </indexterm>

  <sect2 role="introduction">
    <title>Introduction</title>

    <para>This section is provided to show you some additional programming
    tools for which instructions have not yet been created in the book or for
    those that are not appropriate for the book. Note that these packages may
    not have been tested by the BLFS team, but their mention here is meant to
    be a convenient source of additional information.</para>

  </sect2>

  <sect2>
    <title>Programming Frameworks, Languages and Compilers</title>

    <!-- This is a template for additions to this page. Cut 18 lines and
         paste them in alphabetical order for the new package. '18dd' and
         move down to the alpha order and 'p' works great (using vi).

    <sect3 role="package">
      <title></title>

      <para><application></application> This is the description.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url=""/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url=""/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    -->

    <sect3 role="package">
      <title>A+</title>

      <para><application>A+</application> is a powerful and efficient
      programming language. It is freely available under the GNU General
      Public License. It embodies a rich set of functions and operators, a
      modern graphical user interface with many widgets and automatic
      synchronization of widgets and variables, asynchronous execution of
      functions associated with variables and events, dynamic loading of user
      compiled subroutines, and many other features. Execution is by a rather
      efficient interpreter. <application>A+</application> was created at
      Morgan Stanley. Primarily used in a computationally-intensive business
      environment, many critical applications written in
      <application>A+</application> have withstood the demands of real world
      developers over many years. Written in an interpreted language,
      <application>A+</application> applications tend to be portable.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://www.aplusdev.org/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://www.aplusdev.org/Download/index.html"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>ABC</title>

      <para><application>ABC</application> is an interactive programming
      language and environment for personal computing, originally intended as a
      good replacement for BASIC. It was designed by first doing a task
      analysis of the programming task. <application>ABC</application> is easy
      to learn (an hour or so for someone who has already programmed), and yet
      easy to use. Originally intended as a language for beginners, it has
      evolved into a powerful tool for beginners and experts alike. Some
      features of the language include: a powerful collection of only five data
      types that easily combines strong typing, yet without declarations,
      no limitations (such as max int), apart from sheer exhaustion of memory
      refinements to support top-down programming, nesting by indentation and
      programs typically are one fourth or one fifth the size of the equivalent
      Pascal or C program. </para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://homepages.cwi.nl/~steven/abc/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://homepages.cwi.nl/~steven/abc/implementations.html"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>ALF</title>

      <para><application>ALF</application> is a language which combines
      functional and logic programming techniques. The foundation of
      <application>ALF</application> is Horn clause logic with equality which
      consists of predicates and Horn clauses for logic programming, and
      functions and equations for functional programming. The
      <application>ALF</application> system is an efficient implementation of
      the combination of resolution, narrowing, rewriting and rejection.
      Similarly to Prolog, <application>ALF</application> uses a backtracking
      strategy corresponding to a depth-first search in the derivation
      tree.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://www.informatik.uni-kiel.de/~mh/systems/ALF.html"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://www.informatik.uni-kiel.de/~mh/systems/ALF/"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>ASM</title>

      <para><application>ASM</application> is a Java bytecode manipulation
      framework. It can be used to dynamically generate stub classes or other
      proxy classes, directly in binary form, or to dynamically modify
      classes at load time, i.e., just before they are loaded into the Java
      Virtual Machine. <application>ASM</application> offers similar
      functionalities as BCEL or SERP, but is much smaller (33KB instead of
      350KB for BCEL and 150KB for SERP) and faster than these tools (the
      overhead of a load time class transformation is of the order of 60% with
      <application>ASM</application>, 700% or more with BCEL, and 1100% or
      more with SERP). Indeed <application>ASM</application> was designed to be
      used in a dynamic way (though it works statically as well) and was
      therefore designed and implemented to be as small and as fast as
      possible.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://asm.objectweb.org/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://forge.objectweb.org/projects/asm/"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>BCPL</title>

      <para><application>BCPL</application> is a simple typeless language that
      was designed in 1966 by Martin Richards and implemented for the first
      time at MIT in the Spring of 1967.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://www.cl.cam.ac.uk/users/mr/BCPL.html"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://www.cl.cam.ac.uk/users/mr/BCPL/"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>BETA</title>

      <para><application>BETA</application> is developed within the
      Scandinavian School of object-orientation, where the first
      object-oriented language, Simula, was developed.
      <application>BETA</application> is a modern language in the Simula
      tradition. The resulting language is smaller than Simula in spite of
      being considerably more expressive. <application>BETA</application> is a
      strongly typed language like Simula, Eiffel and C++, with most type
      checking being carried out at compile-time. It is well known that it is
      not possible to obtain all type checking at compile time without
      sacrificing the expressiveness of the language.
      <application>BETA</application> has optimum balance between compile-time
      type checking and run-time type checking.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://www.daimi.au.dk/~beta/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="ftp://ftp.daimi.au.dk/pub/beta/"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>&lt;bigwig&gt;</title>

      <para><application>&lt;bigwig&gt;</application> is a high-level
      programming language for developing interactive Web services. Programs
      are compiled into a conglomerate of lower-level technologies such as C
      code, HTTP, HTML, JavaScript, and SSL, all running on top of a runtime
      system based on an Apache Web server module. It is a descendant of the
      Mawl project but is a completely new design and implementation with
      vastly expanded ambitions. The <application>&lt;bigwig&gt;</application>
      language is really a collection of tiny domain-specific languages
      focusing on different aspects of interactive Web services. These
      contributing languages are held together by a C-like skeleton language.
      Thus, <application>&lt;bigwig&gt;</application> has the look and feel of
      C-programs but with special data and control structures.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://www.brics.dk/bigwig/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://www.brics.dk/bigwig/download/"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>Byte Code Engineering Library (BCEL)</title>

      <para><application>BECL</application> is intended to give users a
      convenient possibility to analyze, create, and manipulate (binary) Java
      class files (those ending with
      <filename class='extension'>.class</filename>). Classes are represented
      by objects which contain all the symbolic information of the given class:
      methods, fields and byte code instructions, in particular. Such objects
      can be read from an existing file, be transformed by a program (e.g., a
      class loader at run-time) and dumped to a file again. An even more
      interesting application is the creation of classes from scratch at
      run-time. The Byte Code Engineering Library may be also useful if you
      want to learn about the Java Virtual Machine (JVM) and the format of Java
      <filename class='extension'>.class</filename> files.
      <application>BCEL</application> is already being used successfully in
      several projects such as compilers, optimizers, obsfuscators, code
      generators and analysis tools.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://jakarta.apache.org/bcel/index.html"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://jakarta.apache.org/site/downloads/downloads_bcel.cgi/"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>Bigloo</title>

      <para><application>Bigloo</application> is a Scheme implementation
      devoted to one goal: enabling Scheme based programming style where C(++)
      is usually required. <application>Bigloo</application> attempts to make
      Scheme practical by offering features usually presented by traditional
      programming languages but not offered by Scheme and functional
      programming. Bigloo compiles Scheme modules and delivers small and fast
      stand-alone binary executables. It enables full connections between
      Scheme and C programs, between Scheme and Java programs, and between
      Scheme and C# programs.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://www-sop.inria.fr/mimosa/fp/Bigloo/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="ftp://ftp-sop.inria.fr/mimosa/fp/Bigloo/"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>C--</title>

      <para><application>C--</application> is a portable assembly language that
      can be generated by a front end and implemented by any of several code
      generators. It serves as an interface between high-level compilers and
      retargetable, optimizing code generators. Authors of front ends and code
      generators can cooperate easily.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://www.cminusminus.org/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://www.cminusminus.org/code.html"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>Caml</title>

      <para><application>Caml</application> is a general-purpose programming
      language, designed with program safety and reliability in mind. It is
      very expressive, yet easy to learn and use.
      <application>Caml</application> supports functional, imperative, and
      object-oriented programming styles. It has been developed and distributed
      by INRIA, France's national research institute for computer science,
      since 1985. The Objective Caml system is the main implementation of the
      <application>Caml</application> language. It features a powerful module
      system and a full-fledged object-oriented layer. It comes with a
      native-code compiler that supports numerous architectures, for high
      performance; a bytecode compiler, for increased portability; and an
      interactive loop, for experimentation and rapid development.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://caml.inria.fr/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://caml.inria.fr/pub/distrib/"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>Cayenne</title>

      <para><application>Cayenne</application> is a simple(?) functional
      language with a powerful type system. The basic types are functions,
      products, and sums. Functions and products use dependent types to gain
      additional power. There are very few building blocks in the language, but
      a lot of <quote>syntactic sugar</quote> to make it more readable. There
      is no separate module language in <application>Cayenne</application>
      since the dependent types allow the normal expression language to be used
      at the module level as well. The design of
      <application>Cayenne</application> has been heavily influenced by
      <application>Haskell</application> and constructive type theory and with
      some things borrowed from Java. The drawback of such a powerful type
      system is that the type checking becomes undecidable.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://www.cs.chalmers.se/~augustss/cayenne/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://www.cs.chalmers.se/~augustss/cayenne/get.html"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>Ch</title>

      <para><application>Ch</application> is an embeddable C/C++ interpreter
      for cross-platform scripting, shell programming, 2D/3D plotting,
      numerical computing, and embedded scripting.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://www.softintegration.com/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://www.softintegration.com/products/chstandard/download/"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>Clean</title>

      <para><application>Clean</application> is a general purpose,
      state-of-the-art, pure and lazy functional programming language designed
      for making real-world applications. <application>Clean</application> is
      the only functional language in the world which offers uniqueness typing.
      This type system makes it possible in a pure functional language to
      incorporate destructive updates of arbitrary data structures (including
      arrays) and to make direct interfaces to the outside imperative world.
      The type system makes it possible to develop efficient
      applications.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://www.cs.ru.nl/~clean/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://www.cs.ru.nl/~clean/Download/download.html"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>CORN</title>

      <para><application>CORN</application> is designed for modeling
      concurrency and advanced computation. It provides lazy evaluation between
      concurrently worked threads, with object-oriented and functional style of
      semantic. This language can be also used for parallel computation.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://corn.telefonia.pl/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://corn.telefonia.pl/download/download.html"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>Cyclone</title>

      <para><application>Cyclone</application> is a programming language based
      on C that is safe, meaning that it rules out programs that have buffer
      overflows, dangling pointers, format string attacks, and so on.
      High-level, type-safe languages, such as Java, Scheme, or ML also provide
      safety, but they don't give the same control over data representations
      and memory management that C does (witness the fact that the run-time
      systems for these languages are usually written in C.) Furthermore,
      porting legacy C code to these languages or interfacing with legacy C
      libraries is a difficult and error-prone process. The goal of
      <application>Cyclone</application> is to give programmers the same
      low-level control and performance of C without sacrificing safety, and to
      make it easy to port or interface with legacy C code.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://www.research.att.com/projects/cyclone/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://www.eecs.harvard.edu/~greg/cyclone/software/"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>D</title>

      <para><application>D</application> is a general purpose systems and
      applications programming language. It is a higher level language than
      C++, but retains the ability to write high performance code and interface
      directly with the operating system APIs and with hardware.
      <application>D</application> is well suited to writing medium to large
      scale million line programs with teams of developers. It is easy to
      learn, provides many capabilities to aid the programmer, and is well
      suited to aggressive compiler optimization technology.
      <application>D</application> is not a scripting language, nor an
      interpreted language. It doesn't come with a VM, a religion, or an
      overriding philosophy. It's a practical language for practical
      programmers who need to get the job done quickly, reliably, and leave
      behind maintainable, easy to understand code.
      <application>D</application> is the culmination of decades of experience
      implementing compilers for many diverse languages, and attempting to
      construct large projects using those languages. It draws inspiration from
      those other languages (most especially C++) and tempers it with
      experience and real world practicality.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://www.digitalmars.com/d/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="ftp://ftp.digitalmars.com/"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>DMDScript</title>

      <para><application>DMDScript</application> is Digital Mars'
      implementation of the ECMA 262 scripting language. Netscape's
      implementation is called JavaScript, Microsoft's implementation is
      called JScript. <application>DMDScript</application> is much faster
      than other implementations, which you can verify with the included
      benchmark.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://www.digitalmars.com/dscript/index.html"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="ftp://ftp.digitalmars.com/"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>DotGNU Portable.NET</title>

      <para><application>DotGNU Portable.NET</application> goal is to build a
      suite of free software tools to build and execute .NET applications,
      including a C# compiler, assembler, disassembler, and runtime engine.
      While the initial target platform was GNU/Linux, it is also known to run
      under Windows, Solaris, NetBSD, FreeBSD, and MacOS X. The runtime engine
      has been tested on the x86, PowerPC, ARM, Sparc, PARISC, s390, Alpha, and
      IA-64 processors. <application>DotGNU Portable.NET</application> is part
      of the DotGNU project, built in accordance with the requirements of the
      GNU Project. DotGNU Portable.NET is focused on compatibility with the
      ECMA specifications for CLI. There are other projects under the DotGNU
      meta-project to build other necessary pieces of infrastructure, and to
      explore non-CLI approaches to virtual machine implementation.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://www.southern-storm.com.au/portable_net.html"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://www.southern-storm.com.au/portable_net.html#download"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>Dylan</title>

      <para><application>Dylan</application> is an advanced, object-oriented,
      dynamic language which supports rapid program development. When needed,
      programs can be optimized for more efficient execution by supplying more
      type information to the compiler. Nearly all entities in
      <application>Dylan</application> (including functions, classes, and basic
      data types such as integers) are first class objects. Additionally,
      <application>Dylan</application> supports multiple inheritance,
      polymorphism, multiple dispatch, keyword arguments, object introspection,
      macros, and many other advanced features... --Peter Hinely.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://www.gwydiondylan.org/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://www.gwydiondylan.org/downloading.phtml"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>E</title>

      <para><application>E</application> is a secure distributed Java-based
      pure-object platform and p2p scripting language. It has two parts: ELib
      and the <application>E</application> Language. Elib provides the stuff
      that goes on between objects. As a pure-Java library, ELib provides for
      inter-process capability-secure distributed programming. Its
      cryptographic capability protocol enables mutually suspicious Java
      processes to cooperate safely, and its event-loop concurrency and promise
      pipelining enable high performance deadlock free distributed pure-object
      computing. The <application>E</application> Language can be used to
      express what happens within an object. It provides a convenient and
      familiar notation for the ELib computational model, so you can program
      in one model rather than two. Under the covers, this notation expands
      into Kernel-E, a minimalist lambda-language much like Scheme or
      Smalltalk. Objects written in the <application>E</application> language
      are only able to interact with other objects according to ELib's
      semantics, enabling object granularity intra-process security, including
      the ability to safely run untrusted mobile code (such as caplets).</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://www.erights.org/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://www.erights.org/download/"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>elastiC</title>

      <para><application>elastiC</application> is a portable high-level
      object-oriented interpreted language with a C like syntax. Its main
      characteristics are: open source, interpreted, has portable bytecode
      compilation, dynamic typing, automatic real very fast garbage collection,
      object oriented with meta-programming support (a la Smalltalk),
      functional programming support (Scheme-like closures with lexical
      scoping, and eval-like functionality), hierarchical namespaces, a rich
      set of useful built-in types (dynamic arrays, dictionaries, symbols,
      ...), extensibile with C (you can add functions, types, classes, methods,
      packages, ...), embeddable in C. <application>elastiC</application> has
      been strongly influenced by C, Smalltalk, Scheme and Python and tries to
      merge the best characteristics of all these languages, while still
      coherently maintaining its unique personality.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://www.elasticworld.org/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://www.elasticworld.org/download.html"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>Erlang/OTP</title>

      <para><application>Erlang/OTP</application> is a development environment
      based on Erlang. Erlang is a programming language which has many features
      more commonly associated with an operating system than with a programming
      language: concurrent processes, scheduling, memory management,
      distribution, networking, etc. The initial open-source Erlang release
      contains the implementation of Erlang, as well as a large part of
      Ericsson's middleware for building distributed high-availability systems.
      Erlang is characterized by the following features: robustness, soft
      real-time, hot code upgrades and incremental code loading.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://www.erlang.org/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://www.erlang.org/download.html"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>Euphoria</title>

      <para><application>Euphoria</application> is a simple, flexible, and
      easy-to-learn programming language. It lets you quickly and easily
      develop programs for Windows, DOS, Linux and FreeBSD. Euphoria was first
      released in 1993. Since then Rapid Deployment Software has been steadily
      improving it with the help of a growing number of enthusiastic users.
      Although <application>Euphoria</application> provides subscript checking,
      uninitialized variable checking and numerous other run-time checks, it is
      extremely fast. People have used it to develop high-speed DOS games,
      Windows GUI programs, and Linux X Windows programs. It is also very
      useful for CGI (Web-based) programming.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://www.rapideuphoria.com/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://www.rapideuphoria.com/v20.htm"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>Felix</title>

      <para><application>Felix</application> is an advanced Algol like
      procedural programming language with a strong functional subsystem. It
      features ML style static typing, first class functions, pattern matching,
      garabge collection, polymorphism, and has built in support for high
      performance microthreading, regular expressions and context free parsing.
      The system provides a scripting harness so the language can be used like
      other scripting languages such as Python and Perl, but underneath it
      generates native code to obtain high performance. A key feature of the
      system is that it uses the C/C++ object model, and provides an advanced
      binding sublanguage to support integration with C/C++ at both the source
      and object levels, both for embedding C/C++ data types and functions into
      <application>Felix</application>, and for embedding
      <application>Felix</application> into exitsing C++ architectures. The
      <application>Felix</application> compiler is written in Objective Caml,
      and generates ISO C++ which should compile on any platform.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://felix.sourceforge.net/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://felix.sourceforge.net/current/www/download.html"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>ferite</title>

      <para><application>ferite</application> is a scripting language and
      engine all in one managable chunk. It is designed to be easily extended
      in terms of API, and to be used within other applications making them
      more configurable and useful to the end user. It has a syntax similiar to
      a number of other langauges but remains clean and its own
      language.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://www.ferite.org/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://www.ferite.org/download.html"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>Forth</title>

      <para><application>Forth</application> is a stack-based, extensible
      language without type-checking. It is probably best known for its
      "reverse Polish" (postfix) arithmetic notation, familiar to users of
      Hewlett-Packard calculators. <application>Forth</application> is a
      real-time programming language originally developed to control
      telescopes. <application>Forth</application> has many unique features
      and applications: it can compile itself into a new compiler,
      reverse-polish coding, edit time error checking and compiling (similiar
      to BASIC), extremely efficient thread based language, can be used to
      debug itself, extensible; thus can become what ever you need it to be.
      The links below lead to the website of the Forth Interest Group (FIG),
      a world-wide, non-profit organization for education in and the promotion
      of the <application>Forth</application> computer language. Another
      worthwhile website dedicated to the <application>Forth</application>
      community is <ulink url="http://wiki.forthfreak.net/"/>.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://www.forth.org/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://www.forth.org/compilers.html"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>GNU Smalltalk</title>

      <para><application>GNU Smalltalk</application> is a free implementation
      of the Smalltalk-80 language which runs on most versions on Unix and, in
      general, everywhere you can find a POSIX-compliance library. An uncommon
      feature of it is that it is well-versed to scripting tasks and headless
      processing. See <ulink
      url="http://www.gnu.org/software/smalltalk/gst-manual/gst_1.html#SEC1"/>
      for a more detailed explanation of
      <application>GNU Smalltalk</application>.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://www.gnu.org/software/smalltalk/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://ftp.gnu.org/gnu/smalltalk/"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>Haskell</title>

      <para>Haskell is a computer programming language. In particular, it is a
      polymorphicly typed, lazy, purely functional language, quite different
      from most other programming languages. The language is named for Haskell
      Brooks Curry, whose work in mathematical logic serves as a foundation for
      functional languages. Haskell is based on lambda calculus. There are many
      implementations of Haskell, among them:</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>GHC: <ulink
          url="http://www.haskell.org/ghc/"/></para>
        </listitem>
        <listitem>
          <para>HBC: <ulink
          url="http://www.cs.chalmers.se/~augustss/hbc/hbc.html"/></para>
        </listitem>
        <listitem>
          <para>Helium: <ulink
          url="http://www.cs.uu.nl/helium/"/></para>
        </listitem>
        <listitem>
          <para>Hugs: <ulink
          url="http://www.haskell.org/hugs/"/></para>
        </listitem>
        <listitem>
          <para>nhc98: <ulink
          url="http://www.haskell.org/nhc98/"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>HLA (High Level Assembly)</title>

      <para>The <application>HLA</application> language was developed as a tool
      to help teach assembly language programming and machine organization to
      University students at the University of California, Riverside. The basic
      idea was to teach students assembly language programming by leveraging
      their knowledge of high level languages like C/C++ and Pascal/Delphi. At
      the same time, <application>HLA</application> was designed to allow
      advanced assembly language programmers write more readable and more
      powerful assembly language code.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://webster.cs.ucr.edu/AsmTools/HLA/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://webster.cs.ucr.edu/AsmTools/HLA/dnld.html"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>Icon</title>

      <para><application>Icon</application> is a high-level, general-purpose
      programming language with a large repertoire of features for processing
      data structures and character strings. It is an imperative, procedural
      language with a syntax reminiscent of C and Pascal, but with semantics at
      a much higher level.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://www.cs.arizona.edu/icon/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="ftp://ftp.cs.arizona.edu/icon/"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>J</title>

      <para><application>J</application> is a modern, high-level,
      general-purpose, high-performance programming language. It is portable
      and runs on Windows, Unix, Mac, and PocketPC handhelds, both as a GUI
      and in a console. True 64-bit <application>J</application> systems are
      available for XP64 or Linux64, on AMD64 or Intel EM64T platforms.
      <application>J</application> systems can be installed and distributed
      for free.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://www.jsoftware.com/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://www.jsoftware.com/download/"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>Jamaica</title>

      <para><application>Jamaica</application>, the JVM Macro Assembler, is an
      easy-to-learn and easy-to-use assembly language for JVM bytecode
      programming. It uses Java syntax to define a JVM class except for the
      method body that takes bytecode instructions, including
      <application>Jamaica</application>'s built-in macros. In
      <application>Jamaica</application>, bytecode instructions use mnemonics
      and symbolic names for all variables, parameters, data fields, constants
      and labels.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://www.judoscript.com/jamaica.html"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://www.judoscript.com/download.html"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>Joy</title>

      <para><application>Joy</application> is a purely functional programming
      language. Whereas all other functional programming languages are based on
      the application of functions to arguments, <application>Joy</application>
      is based on the composition of functions. All such functions take a stack
      as an argument and produce a stack as a value. Consequently much of
      <application>Joy</application> looks like ordinary postfix notation.
      However, in <application>Joy</application> a function can consume any
      number of parameters from the stack and leave any number of results on
      the stack. The concatenation of appropriate programs denotes the
      composition of the functions which the programs denote.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://www.latrobe.edu.au/philosophy/phimvt/joy.html"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>Judo</title>

      <para><application>Judo</application> is a practical, functional
      scripting language. It is designed to cover the use cases of not only
      algorithmic/object-oriented/multi-threaded programming and Java scripting
      but also a number of major application domain tasks, such as scripting
      for JDBC, WSDL, ActiveX, OS, multiple file/data formats, etc. Despite its
      rich functionality, the base language is extremely simple, and domain
      support syntax is totally intuitive to domain experts, so that even
      though you have never programmed in <application>Judo</application>, you
      would have little trouble figuring out what the code does.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://www.judoscript.com/home.html"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://www.judoscript.com/download.html"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>JWIG</title>

      <para><application>JWIG</application> is a Java-based high-level
      programming language for development of interactive Web services. It
      contains an advanced session model, a flexible mechanism for dynamic
      construction of XML documents, in particular XHTML, and a powerful API
      for simplifying use of the HTTP protocol and many other aspects of Web
      service programming. To support program development,
      <application>JWIG</application> provides a unique suite of highly
      specialized program analyses that at compile time verify for a given
      program that no runtime errors can occur while building documents or
      receiving form input, and that all documents being shown are valid
      according to the document type definition for XHTML 1.0. The main goal of
      the <application>JWIG</application> project is to simplify development of
      complex Web services, compared to alternatives, such as, Servlets, JSP,
      ASP, and PHP. <application>JWIG</application> is a descendant of the
      <application>&lt;bigwig&gt;</application> research language.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://www.brics.dk/JWIG/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://www.brics.dk/JWIG/download.html"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>Lava</title>

      <para><application>Lava</application> is a name unfortunately chosen for
      several unrelated software development languages/projects. So it doesn't
      appear as though BLFS has a preference for one over another, the project
      web sites are listed below, without descriptions of the capabilities or
      features for any of them.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://lavape.sourceforge.net/index.htm"/></para>
        </listitem>
        <listitem>
          <para>Project Home Page: <ulink
          url="http://javalab.cs.uni-bonn.de/research/darwin/#The%20Lava%20Language"/></para>
        </listitem>
        <listitem>
          <para>Project Home Page: <ulink
          url="http://www.md.chalmers.se/~koen/Lava/"/></para>
        </listitem>
        <listitem>
          <para>Project Home Page: <ulink
          url="http://members.tripod.com/mathias/IavaHomepage.html"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>Lua</title>

      <para><application>Lua</application> is a powerful light-weight
      programming language designed for extending applications. It is also
      frequently used as a general-purpose, stand-alone language. It is free
      software. <application>Lua</application> combines simple procedural
      syntax with powerful data description constructs based on associative
      arrays and extensible semantics. It is dynamically typed, interpreted
      from bytecodes, and has automatic memory management with garbage
      collection, making it ideal for configuration, scripting, and rapid
      prototyping. A fundamental concept in the design of
      <application>Lua</application> is to provide meta-mechanisms for
      implementing features, instead of providing a host of features directly
      in the language. For example, although <application>Lua</application> is
      not a pure object-oriented language, it does provide meta-mechanisms for
      implementing classes and inheritance. <application>Lua</application>'s
      meta-mechanisms bring an economy of concepts and keep the language small,
      while allowing the semantics to be extended in unconventional ways.
      Extensible semantics is a distinguishing feature of
      <application>Lua</application>. <application>Lua</application> is a
      language engine that you can embed into your application. This means
      that, besides syntax and semantics, it has an API that allows the
      application to exchange data with <application>Lua</application> programs
      and also to extend <application>Lua</application> with C functions. In
      this sense, it can be regarded as a language framework for building
      domain-specific languages. <application>Lua</application> is implemented
      as a small library of C functions, written in ANSI C, and compiles
      unmodified in all known platforms. The implementation goals are
      simplicity, efficiency, portability, and low embedding cost. The result
      is a fast language engine with small footprint, making it ideal in
      embedded systems too.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://www.lua.org/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://www.lua.org/download.html"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>Mercury</title>

      <para><application>Mercury</application> is a new logic/functional
      programming language, which combines the clarity and expressiveness of
      declarative programming with advanced static analysis and error detection
      features. Its highly optimized execution algorithm delivers efficiency
      far in excess of existing logic programming systems, and close to
      conventional programming systems. <application>Mercury</application>
      addresses the problems of large-scale program development, allowing
      modularity, separate compilation, and numerous optimization/time
      trade-offs.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://www.cs.mu.oz.au/research/mercury/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://www.cs.mu.oz.au/research/mercury/download/release.html"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>Mono</title>

      <para><application>Mono</application> provides the necessary software to
      develop and run .NET client and server applications on Linux, Solaris,
      Mac OS X, Windows, and Unix. Sponsored by Novell, the
      <application>Mono</application> open source project has an active and
      enthusiastic contributing community and is positioned to become the
      leading choice for development of Linux applications.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://www.mono-project.com/Main_Page"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://go-mono.com/sources/"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>Mozart</title>

      <para>The <application>Mozart</application> Programming System is an
      advanced development platform for intelligent, distributed applications.
      <application>Mozart</application> is based on the Oz language, which
      supports declarative programming, object-oriented programming, constraint
      programming, and concurrency as part of a coherent whole. For
      distribution, <application>Mozart</application> provides a true network
      transparent implementation with support for network awareness, openness,
      and fault tolerance. Security is upcoming. It is an ideal platform for
      both general-purpose distributed applications as well as for hard
      problems requiring sophisticated optimization and inferencing
      abilities.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://www.mozart-oz.org/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://www.mozart-oz.org/download/view.cgi"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>MPD</title>

      <para><application>MPD</application> is a variant of the
      <application>SR</application> programming language.
      <application>SR</application> has a Pascal-like syntax and uses guarded
      commands for control statements. <application>MPD</application> has a
      C-like syntax and C-like control statements. However, the main components
      of the two languages are the same: resources, globals, operations, procs,
      procedures, processes, and virtual machines. Moreover,
      <application>MPD</application> supports the same variety of concurrent
      programming mechanisms as <application>SR</application>: co statements,
      semaphores, call/send/forward invocations, and receive and input
      statements.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://www.cs.arizona.edu/mpd/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://www.cs.arizona.edu/mpd/download/"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>Nemerle</title>

      <para><application>Nemerle</application> is a high-level statically-typed
      programming language for the .NET platform. It offers functional,
      object-oriented and imperative features. It has a simple C#-like syntax
      and a powerful meta-programming system. Features that come from the
      functional land are variants, pattern matching, type inference and
      parameter polymorphism (aka generics). The meta-programming system allows
      great compiler extensibility, embedding domain specific languages,
      partial evaluation and aspect-oriented programming.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://nemerle.org/Main_Page"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://nemerle.org/Download"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>Octave</title>

      <para>GNU <application>Octave</application> is a high-level language,
      primarily intended for numerical computations. It provides a convenient
      command line interface for solving linear and nonlinear problems
      numerically, and for performing other numerical experiments using a
      language that is mostly compatible with Matlab. It may also be used as
      a batch-oriented language. <application>Octave</application> has
      extensive tools for solving common numerical linear algebra problems,
      finding the roots of nonlinear equations, integrating ordinary functions,
      manipulating polynomials, and integrating ordinary differential and
      differential-algebraic equations. It is easily extensible and
      customizable via user-defined functions written in
      <application>Octave</application>'s own language, or using dynamically
      loaded modules written in C++, C, Fortran, or other languages.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://www.octave.org/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://www.octave.org/download.html"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>OO2C (Optimizing Oberon-2 Compiler)</title>

      <para><application>OO2C</application> is an Oberon-2 development
      platform. It consists of an optimizing compiler, a number of related
      tools, a set of standard library modules and a reference manual.
      Oberon-2 is a general-purpose programming language in the tradition of
      Pascal and Modula-2. Its most important features are block structure,
      modularity, separate compilation, static typing with strong type checking
      (also across module boundaries) and type extension with type-bound
      procedures. Type extension makes Oberon-2 an object-oriented
      language.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://ooc.sourceforge.net/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://prdownloads.sourceforge.net/ooc/"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>Ordered Graph Data Language (OGDL)</title>

      <para><application>OGDL</application> is a structured textual format that
      represents information in the form of graphs, where the nodes are strings
      and the arcs or edges are spaces or indentation.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://ogdl.sourceforge.net/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://prdownloads.sourceforge.net/ogdl/"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>Pike</title>

      <para><application>Pike</application> is a dynamic programming language
      with a syntax similar to Java and C. It is simple to learn, does not
      require long compilation passes and has powerful built-in data types
      allowing simple and really fast data manipulation. Pike is released under
      the GNU GPL, GNU LGPL and MPL.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://pike.ida.liu.se/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://pike.ida.liu.se/download/pub/pike"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>pyc</title>

      <para><application>pyc</application> is a compiler that compiles
      <application>Python</application> source code to bytecode (from
      <filename class='extension'>.py</filename> to
      <filename class='extension'>.pyc</filename>), written entirely in
      <application>Python</application> (based on code from the <quote>compiler
      package</quote>). It can compile itself and pass a 3-stage bootstrap.
      <application>pyc</application> performs advanced optimizations which
      results in better (smaller) bytecode.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://students.ceid.upatras.gr/~sxanth/pyc/"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>Pyrex</title>

      <para><application>Pyrex</application> is a language specially designed
      for writing Python extension modules. It's designed to bridge the gap
      between the nice, high-level, easy-to-use world of
      <application>Python</application> and the messy, low-level world of C.
      <application>Pyrex</application> lets you write code that mixes
      <application>Python</application> and C data types any way you want, and
      compiles it into a C extension for
      <application>Python</application>.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://www.cosc.canterbury.ac.nz/~greg/python/Pyrex/"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>Q</title>

      <para><application>Q</application> is a functional programming language
      based on term rewriting. Thus, a <application>Q</application> program or
      <quote>script</quote> is simply a collection of equations which are used
      to evaluate expressions in a symbolic fashion. The equations establish
      algebraic identities and are interpreted as rewriting rules in order to
      reduce expressions to <quote>normal forms</quote>.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://q-lang.sourceforge.net/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://prdownloads.sourceforge.net/q-lang/"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>R</title>

      <para><application>R</application> is a language and environment for
      statistical computing and graphics. It is a GNU project similar to the
      <application>S</application> language and environment which was developed
      at Bell Laboratories (formerly AT&amp;T, now Lucent Technologies) by
      John Chambers and colleagues. <application>R</application> can be
      considered as a different implementation of <application>S</application>.
      There are some important differences, but much code written for
      <application>S</application> runs unaltered under
      <application>R</application>. <application>R</application> provides a
      wide variety of statistical (linear and nonlinear modelling, classical
      statistical tests, time-series analysis, classification, clustering, ...)
      and graphical techniques, and is highly extensible. The
      <application>S</application> language is often the vehicle of choice for
      research in statistical methodology, and <application>R</application>
      provides an Open Source route to participation in that activity.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://www.r-project.org/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://cran.r-project.org/mirrors.html"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>Regina Rexx</title>

      <para><application>Regina</application> is a Rexx interpreter that has
      been ported to most Unix platforms (Linux, FreeBSD, Solaris, AIX, HP-UX,
      etc.) and also to OS/2, eCS, DOS, Win9x/Me/NT/2k/XP, Amiga, AROS, QNX4.x,
      QNX6.x BeOS, MacOS X, EPOC32, AtheOS, OpenVMS, SkyOS and OpenEdition.
      Rexx is a programming language that was designed to be easy to use for
      inexperienced programmers yet powerful enough for experienced users. It
      is also a language ideally suited as a macro language for other
      applications.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://regina-rexx.sourceforge.net/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://prdownloads.sourceforge.net/regina-rexx"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>Serp</title>

      <para><application>Serp</application> is an open source framework for
      manipulating Java bytecode. The goal of the
      <application>Serp</application> bytecode framework is to tap the full
      power of bytecode modification while lowering its associated costs. The
      framework provides a set of high-level APIs for manipulating all aspects
      of bytecode, from large-scale structures like class member fields to the
      individual instructions that comprise the code of methods. While in order
      to perform any advanced manipulation, some understanding of the class
      file format and especially of the JVM instruction set is necessary, the
      framework makes it as easy as possible to enter the world of bytecode
      development.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://serp.sourceforge.net/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://serp.sourceforge.net/files/"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>Small Device C Compiler (SDCC)</title>

      <para><application>SDCC</application> is a Freeware, retargettable,
      optimizing ANSI-C compiler that targets the Intel 8051, Maxim 80DS390
      and the Zilog Z80 based MCUs. Work is in progress on supporting the
      Motorola 68HC08 as well as Microchip PIC16 and PIC18 series. The entire
      source code for the compiler is distributed under GPL.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://sdcc.sourceforge.net/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://sdcc.sourceforge.net/snap.php#Source"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>SmartEiffel (The GNU Eiffel Compiler)</title>

      <para><application>SmartEiffel</application> claims to be <quote>the
      fastest and the slimmest multi-platform Eiffel compiler on Earth</quote>.
      Eiffel is an object-oriented programming language which emphasizes the
      production of robust software. Its syntax is keyword-oriented in the
      ALGOL and Pascal tradition. Eiffel is strongly statically typed, with
      automatic memory management (typically implemented by garbage
      collection). Distinguishing characteristics of Eiffel include Design by
      contract (DbC), liberal use of inheritance including multiple
      inheritance, a type system handling both value and reference semantics,
      and generic classes. Eiffel has a unified type system&mdash;all types in
      Eiffel are classes, so it is possible to create subclasses of the basic
      classes such as INTEGER. Eiffel has operator overloading, including the
      ability to define new operators, but does not have method
      overloading.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://smarteiffel.loria.fr/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="ftp://ftp.loria.fr/pub/loria/SmartEiffel/"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>Squeak</title>

      <para><application>Squeak</application> is an open, highly-portable
      Smalltalk implementation whose virtual machine is written entirely in
      Smalltalk, making it easy to debug, analyze, and change. To achieve
      practical performance, a translator produces an equivalent C program
      whose performance is comparable to commercial Smalltalks. Other
      noteworthy aspects of <application>Squeak</application> include:
      real-time sound and music synthesis written entirely in Smalltalk,
      extensions of BitBlt to handle color of any depth and anti-aliased
      image rotation and scaling, network access support that allows simple
      construction of servers and other useful facilities, it runs
      bit-identical on many platforms (Windows, Mac, Unix, and others), a
      compact object format that typically requires only a single word of
      overhead per object and a simple yet efficient incremental garbage
      collector for 32-bit direct pointers efficient bulk-mutation of
      objects.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://www.squeak.org/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://www.squeak.org/Download/"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>SR (Synchronizing Resources)</title>

      <para><application>SR</application> is a language for writing concurrent
      programs. The main language constructs are resources and operations.
      Resources encapsulate processes and variables they share; operations
      provide the primary mechanism for process interaction.
      <application>SR</application> provides a novel integration of the
      mechanisms for invoking and servicing operations. Consequently, all of
      local and remote procedure call, rendezvous, message passing, dynamic
      process creation, multicast, and semaphores are supported.
      <application>SR</application> also supports shared global variables and
      operations.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://www.cs.arizona.edu/sr/index.html"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="ftp://ftp.cs.arizona.edu/sr/"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>Standard ML</title>

      <para>Standard ML is a safe, modular, strict, functional, polymorphic
      programming language with compile-time type checking and type inference,
      garbage collection, exception handling, immutable data types and
      updatable references, abstract data types, and parametric modules. It has
      efficient implementations and a formal definition with a proof of
      soundness. There are many implementations of Standard ML, among them:</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>ML Kit: <ulink
          url="http://www.it-c.dk/research/mlkit/"/></para>
        </listitem>
        <listitem>
          <para>MLton: <ulink
          url="http://mlton.org/"/></para>
        </listitem>
        <listitem>
          <para>Moscow ML: <ulink
          url="http://www.dina.kvl.dk/~sestoft/mosml.html"/></para>
        </listitem>
        <listitem>
          <para>Poly/ML: <ulink
          url="http://www.polyml.org/"/></para>
        </listitem>
        <listitem>
          <para>Standard ML of New Jersey: <ulink
          url="http://www.smlnj.org/"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>Steel Bank Common Lisp (SBCL)</title>

      <para><application>SBCL</application> is an open source (free software)
      compiler and runtime system for ANSI Common Lisp. It provides an
      interactive environment including an integrated native compiler, a
      debugger, and many extensions. <application>SBCL</application> runs on a
      number of platforms.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://www.sbcl.org/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://prdownloads.sourceforge.net/sbcl/"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>Tiny C Compiler (TCC)</title>

      <para><application>Tiny C Compiler</application> is a small C compiler
      that can be used to compile and execute C code everywhere, for example
      on rescue disks (about 100KB for x86 TCC executable, including C
      preprocessor, C compiler, assembler and linker).
      <application>TCC</application> is fast. It generates optimized x86 code,
      has no byte code overhead and compiles, assembles and links several times
      faster than <application>GCC</application>.
      <application>TCC</application> is versatile, any C dynamic library can be
      used directly. It is heading torward full ISOC99 compliance and can
      compile itself. The compiler is safe as it includes an optional memory
      and bound checker. Bound checked code can be mixed freely with standard
      code. <application>TCC</application> compiles and executes C source
      directly. No linking or assembly necessary. A full C preprocessor and
      GNU-like assembler is included. It is C script supported; just add
      <quote>#!/usr/local/bin/tcc -run</quote> on the first line of your C
      source, and execute it directly from the command line. With libtcc, you
      can use <application>TCC</application> as a backend for dynamic code
      generation.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://www.tinycc.org/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://fabrice.bellard.free.fr/tcc/"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>TinyCOBOL</title>

      <para><application>TinyCOBOL</application> is a COBOL compiler being
      developed by members of the free software community. The mission is to
      produce a COBOL compiler based on the COBOL 85 standards.
      <application>TinyCOBOL</application> is avaliable for the Intel
      architecture (IA32) and compatible processors on the following platforms:
      BeOS, FreeBSD, Linux and MinGW on Windows.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://tinycobol.org/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://prdownloads.sourceforge.net/tiny-cobol/"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>Yorick</title>

      <para><application>Yorick</application> is an interpreted programming
      language, designed for postprocessing or steering large scientific
      simulation codes. Smaller scientific simulations or calculations, such as
      the flow past an airfoil or the motion of a drumhead, can be written as
      standalone yorick programs. The language features a compact syntax for
      many common array operations, so it processes large arrays of numbers
      very efficiently. Unlike most interpreters, which are several hundred
      times slower than compiled code for number crunching,
      <application>Yorick</application> can approach to within a factor of four
      or five of compiled speed for many common tasks. Superficially,
      <application>Yorick</application> code resembles C code, but
      <application>Yorick</application> variables are never explicitly declared
      and have a dynamic scoping similar to many Lisp dialects. The
      <quote>unofficial</quote> home page for <application>Yorick</application>
      can be found at <ulink url="http://www.maumae.net/yorick"/>.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="ftp://ftp-icf.llnl.gov/pub/Yorick/doc/index.html"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="ftp://ftp-icf.llnl.gov/pub/Yorick/doc/download.html"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>ZPL</title>

      <para><application>ZPL</application> is an array programming language
      designed from first principles for fast execution on both sequential
      and parallel computers. It provides a convenient high-level programming
      medium for supercomputers and large-scale clusters with efficiency
      comparable to hand-coded message passing. It is the perfect alternative
      to using a sequential language like C or Fortran and a message passing
      library like MPI.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://www.cs.washington.edu/research/zpl/home/index.html"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://www.cs.washington.edu/research/zpl/download/download.html"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

  </sect2>

  <sect2>
    <title>Programming Libraries and Bindings</title>

    <sect3 role="package">
      <title>Boost</title>

      <para><application>Boost</application> provides free peer-reviewed
      portable C++ source libraries. The emphasis is on libraries which work
      well with the C++ Standard Library. The libraries are intended to be
      widely useful, and are in regular use by thousands of programmers across
      a broad spectrum of applications, platforms and programming
      environments.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://www.boost.org/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://prdownloads.sourceforge.net/boost/"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>Choco</title>

      <para><application>Choco</application> is a Java library for constraint
      satisfaction problems (CSP), constraint programming (CP) and
      explanation-based constraint solving (e-CP). It is built on a event-based
      propagation mechanism with backtrackable structures.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://choco.sourceforge.net/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://choco.sourceforge.net/download.html"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>FFTW (Fastest Fourier Transform in the West)</title>

      <para><application>FFTW</application> is a C subroutine library for
      computing the discrete Fourier transform (DFT) in one or more dimensions,
      of arbitrary input size, and of both real and complex data (as well as of
      even/odd data, i.e., the discrete cosine/sine transforms or DCT/DST).</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://www.fftw.org/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://www.fftw.org/download.html"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>GOB (GObject Builder)</title>

      <para><application>GOB</application> (<application>GOB2</application>
      anyway) is a preprocessor for making GObjects with inline C code so that
      generated files are not edited. Syntax is inspired by
      <application>Java</application> and <application>Yacc</application> or
      <application>Lex</application>. The implementation is intentionally kept
      simple, and no C actual code parsing is done.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://www.5z.com/jirka/gob.html"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://ftp.5z.com/pub/gob/"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>GTK+/GNOME Language Bindings (wrappers)</title>

      <para><application>GTK+</application>/<application>GNOME</application>
      language bindings allow <application>GTK+</application> to be used from
      other programming languages, in the style of those languages.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://www.gtk.org/bindings.html"/></para>
        </listitem>
      </itemizedlist>

      <sect4 role="package">
        <title>gtkmm</title>

        <para><application>gtkmm</application> is the official C++ interface
        for the popular GUI library <application>GTK+</application>. Highlights
        include typesafe callbacks, widgets extensible via inheritance and a
        comprehensive set of widgets. You can create user interfaces either in
        code or with the Glade designer, using
        <application>libglademm</application>.</para>

        <itemizedlist spacing="compact">
          <listitem>
            <para>Project Home Page: <ulink
            url="http://www.gtkmm.org/"/></para>
          </listitem>
          <listitem>
            <para>Download Location: <ulink
            url="http://www.gtkmm.org/download.shtml"/></para>
          </listitem>
        </itemizedlist>

      </sect4>

      <sect4 role="package">
        <title>Java-GNOME</title>

        <para><application>Java-GNOME</application> is a set of Java bindings
        for the <application>GNOME</application> and
        <application>GTK+</application> libraries that allow
        <application>GNOME</application> and <application>GTK+</application>
        applications to be written in Java. The
        <application>Java-GNOME</application> API has been carefully designed
        to be easy to use, maintaining a good OO paradigm, yet still wrapping
        the entire functionality of the underlying libraries.
        <application>Java-GNOME</application> can be used with the
        <application>Eclipse</application> development environment and Glade
        user interface designer to create applications with ease.</para>

        <itemizedlist spacing="compact">
          <listitem>
            <para>Project Home Page: <ulink
            url="http://java-gnome.sourceforge.net/cgi-bin/bin/view"/></para>
          </listitem>
          <listitem>
            <para>Download Location: <ulink
            url="http://java-gnome.sourceforge.net/cgi-bin/bin/view/Main/GetJavaGnome#Source_Code"/></para>
          </listitem>
        </itemizedlist>

      </sect4>

      <sect4 role="package">
        <title>gtk2-perl</title>

        <para><application>gtk2-perl</application> is the collective name for
        a set of perl bindings for <application>GTK+</application> 2.x and
        various related libraries. These modules make it easy to write
        <application>GTK</application> and <application>GNOME</application>
        applications using a natural, perlish, object-oriented syntax.</para>

        <itemizedlist spacing="compact">
          <listitem>
            <para>Project Home Page: <ulink
            url="http://gtk2-perl.sourceforge.net/"/></para>
          </listitem>
          <listitem>
            <para>Download Location: <ulink
            url="http://prdownloads.sourceforge.net/gtk2-perl"/></para>
          </listitem>
        </itemizedlist>

      </sect4>

      <sect4 role="package">
        <title>PyGTK</title>

        <para><application>PyGTK</application> provides a convenient wrapper
        for the <application>GTK</application> library for use in
        <application>Python</application> programs, and takes care of many of
        the boring details such as managing memory and type casting. When
        combined with <application>PyORBit</application> and
        <application>gnome-python</application>, it can be used to write full
        featured <application>GNOME</application> applications.</para>

        <itemizedlist spacing="compact">
          <listitem>
            <para>Project Home Page: <ulink
            url="http://www.pygtk.org/"/></para>
          </listitem>
          <listitem>
            <para>Download Location: <ulink
            url="http://www.pygtk.org/downloads.html"/></para>
          </listitem>
        </itemizedlist>

      </sect4>

    </sect3>

    <sect3 role="package">
      <title>KDE Language Bindings</title>

      <para><application>KDE</application> and most
      <application>KDE</application> applications are implemented using the
      C++ programming language, however there are number of bindings to other
      languages are available. These include scripting languages like
      <application>Perl</application>, <application>Python</application> and
      <application>Ruby</application>, and systems programming languages such
      as Java and C#.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://developer.kde.org/language-bindings/"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>Numerical Python (Numpy)</title>

      <para><application>Numerical Python</application> adds a fast array
      facility to the <application>Python</application> language.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://numeric.scipy.org/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://prdownloads.sourceforge.net/numpy/"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>Perl Scripts and Additional Modules</title>

      <para>There are many <application>Perl</application> scripts and
      additional modules located on the Comprehensive Perl Archive Network
      (CPAN) web site. Here you will find
      <quote>All Things Perl</quote>.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://cpan.org/"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>SWIG</title>

      <para><application>SWIG</application> is a software development tool
      that connects programs written in C and C++ with a variety of high-level
      programming languages. <application>SWIG</application> is used with
      different types of languages including common scripting languages such as
      <application>Perl</application>, <application>Python</application>,
      <application>Tcl</application>/<application>Tk</application> and
      <application>Ruby</application>. The list of supported languages also
      includes non-scripting languages such as <application>C#</application>,
      <application>Common Lisp</application> (Allegro CL),
      <application>Java</application>, <application>Modula-3</application>
      and <application>OCAML</application>. Also several interpreted and
      compiled Scheme implementations (<application>Chicken</application>,
      <application>Guile</application>, <application>MzScheme</application>)
      are supported. <application>SWIG</application> is most commonly used to
      create high-level interpreted or compiled programming environments, user
      interfaces, and as a tool for testing and prototyping C/C++ software.
      <application>SWIG</application> can also export its parse tree in the
      form of XML and Lisp s-expressions.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://www.swig.org/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://prdownloads.sourceforge.net/swig/"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

  </sect2>

  <sect2>
    <title>Other Development Tools</title>

    <sect3 role="package">
      <title>A-A-P</title>

      <para><application>A-A-P</application> makes it easy to locate, download,
      build and install software. It also supports browsing source code,
      developing programs, managing different versions and distribution of
      software and documentation. This means that
      <application> A-A-P</application> is useful both for users and for
      developers.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://www.a-a-p.org/index.html"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://www.a-a-p.org/download.html"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>cachecc1</title>

      <para><application>cachecc1</application> is a
      <application>GCC</application> cache. It can be compared with the well
      known <application>ccache</application> package. It has some unique
      features including the use of an LD_PRELOADed shared object to catch
      invocations to <command>cc1</command>, <command>cc1plus</command> and
      <command>as</command>, it transparently supports all build methods, it
      can cache <application>GCC</application> bootstraps and it can be
      combined with <application>distcc</application> to transparently
      distribute compilations.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://cachecc1.sourceforge.net/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://prdownloads.sourceforge.net/cachecc1"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>ccache</title>

      <para><application>ccache</application> is a compiler cache. It acts as
      a caching pre-processor to C/C++ compilers, using the <option>-E</option>
      compiler switch and a hash to detect when a compilation can be satisfied
      from cache. This often results in 5 to 10 times faster speeds in common
      compilations.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://ccache.samba.org/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://ccache.samba.org/ftp/ccache/"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>DDD (GNU Data Display Debugger)</title>

      <para><application>GNU DDD</application> is a graphical front-end for
      command-line debuggers such as <application>GDB</application>,
      <application>DBX</application>, <application>WDB</application>,
      <application>Ladebug</application>, <application>JDB</application>,
      <application>XDB</application>, the <application>Perl</application>
      debugger, the <application>Bash</application> debugger, or the
      <application>Python</application> debugger. Besides <quote>usual</quote>
      front-end features such as viewing source texts,
      <application>DDD</application> has an interactive graphical data display,
      where data structures are displayed as graphs..</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://www.gnu.org/software/ddd/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://ftp.gnu.org/gnu/ddd/"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>distcc</title>

      <para><application>distcc</application> is a program to distribute builds
      of C, C++, Objective C or Objective C++ code across several machines on a
      network. <application>distcc</application> should always generate the
      same results as a local build, is simple to install and use, and is
      usually much faster than a local compile.
      <application>distcc</application> does not require all machines to share
      a filesystem, have synchronized clocks, or to have the same libraries or
      header files installed. They can even have different processors or
      operating systems, if cross-compilers are installed.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://distcc.samba.org/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://distcc.samba.org/download.html"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>Exuberant Ctags</title>

      <para><application>Exuberant Ctags</application> generates an index (or
      tag) file of language objects found in source files that allows these
      items to be quickly and easily located by a text editor or other utility.
      A tag signifies a language object for which an index entry is available
      (or, alternatively, the index entry created for that object). Tag
      generation is supported for the following languages: Assembler, AWK, ASP,
      BETA, Bourne/Korn/Zsh Shell, C, C++, COBOL, Eiffel, Fortran, Java, Lisp,
      Lua, Make, Pascal, Perl, PHP, Python, REXX, Ruby, S-Lang, Scheme, Tcl,
      Vim, and YACC. A list of editors and tools utilizing tag files may be
      found at <ulink url="http://ctags.sourceforge.net/tools.html"/>.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://ctags.sourceforge.net/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://prdownloads.sourceforge.net/ctags/"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>GDB (GNU Debugger)</title>

      <para><application>GDB</application> is the GNU Project debugger. It
      allows you to see what is going on <quote>inside</quote> another program
      while it executes. It also allows you to see what another program was
      doing at the moment it crashed.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://www.gnu.org/software/gdb/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="ftp://ftp.gnu.org/gnu/gdb/"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>gocache (GNU Object Cache)</title>

      <para><application>ccache</application> is a clone of
      <application>ccache</application>, with the goal of supporting
      compilers other than <application>GCC</application> and adding additional
      features. Embedded compilers will especially be in focus.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://sourceforge.net/projects/gocache/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://prdownloads.sourceforge.net/gocache/"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>OProfile</title>

      <para><application>OProfile</application> is a system-wide profiler for
      Linux systems, capable of profiling all running code at low overhead.
      <application>OProfile</application> is released under the GNU GPL. It
      consists of a kernel driver and a daemon for collecting sample data, and
      several post-profiling tools for turning data into information.
      <application>OProfile</application> leverages the hardware performance
      counters of the CPU to enable profiling of a wide variety of interesting
      statistics, which can also be used for basic time-spent profiling. All
      code is profiled: hardware and software interrupt handlers, kernel
      modules, the kernel, shared libraries, and applications.
      <application>OProfile</application> is currently in alpha status; however
      it has proven stable over a large number of differing configurations. It
      is being used on machines ranging from laptops to 16-way NUMA-Q
      boxes.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://oprofile.sourceforge.net/news/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://oprofile.sourceforge.net/download/"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>SCons</title>

      <para><application>SCons</application> is an Open Source software
      construction tool, i.e, a next-generation build tool. Think of
      <application>SCons</application> as an improved, cross-platform
      substitute for the classic <command>make</command> utility with
      integrated functionality similar to
      <application>Autoconf</application>/<application>Automake</application>
      and compiler caches such as <command>ccache</command>.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://scons.sourceforge.net/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://prdownloads.sourceforge.net/scons/"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>strace</title>

      <para><application>strace</application> is a system call tracer, i.e., a
      debugging tool which prints out a trace of all the system calls made by
      another process or program.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://www.liacs.nl/~wichert/strace/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://prdownloads.sourceforge.net/strace/"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

    <sect3 role="package">
      <title>Valgrind</title>

      <para><application>Valgrind</application> is a collection of five tools:
      two memory error detectors, a thread error detector, a cache profiler and
      a heap profiler used for debugging and profiling Linux programs. Features
      include automatic detection of many memory management and threading bugs
      as well as detailed profiling to speed up and reduce memory use of your
      programs.</para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>Project Home Page: <ulink
          url="http://valgrind.org/"/></para>
        </listitem>
        <listitem>
          <para>Download Location: <ulink
          url="http://valgrind.org/downloads/source_code.html"/></para>
        </listitem>
      </itemizedlist>

    </sect3>

  </sect2>

</sect1>