source: archive/other-tools.xml

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

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


  <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>

    <para condition="html" role="usernotes">User Notes:
    <ulink url="&blfs-wiki;/OtherProgrammingTools"/></para>

  </sect2>

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

    <!-- This is a template for additions to this page. Cut 22 lines and
         paste them in alphabetical order for the new package. '22yy' 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>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>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://wiki.clean.cs.ru.nl/Clean"/>
          </para>
        </listitem>
        <listitem>
          <para>
            Download Location: <ulink
            url="http://wiki.clean.cs.ru.nl/Download_Clean"/>
          </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://cyclone.thelanguage.org/"/>
          </para>
        </listitem>
        <listitem>
          <para>
            Download Location: <ulink
            url="http://cyclone.thelanguage.org/wiki/Download/"/>
          </para>
        </listitem>
      </itemizedlist>

    </sect3>
    <!-- Now comes with gcc
    <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.gnu.org/software/dotgnu/"/>
          </para>
        </listitem>
        <listitem>
          <para>
            Download Location: <ulink
            url="http://www.gnu.org/software/dotgnu/pnet-packages.html"/>
          </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.opendylan.org/"/>
          </para>
        </listitem>
        <listitem>
          <para>
            Download Location: <ulink
            url="http://opendylan.org/download/index.html"/>
          </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, ...), extensible 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 X Window
        System 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, garbage 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 existing 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-lang.org/$/usr/local/lib/felix/tarballs"/>
          </para>
        </listitem>
      </itemizedlist>

    </sect3>

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

      <para>
        <application>ferite</application> is a scripting language and engine
        all in one manageable 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 similar
        to a number of other languages 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 (similar
        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/manual/html_node/Overview.html
        "/> for a more detailed explanation of
        <application>GNU Smalltalk</application>.
      </para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>
            Project Home Page: <ulink
          url="http://smalltalk.gnu.org/"/>
          </para>
        </listitem>
        <listitem>
          <para>
            Download Location: <ulink
          url="&gnu-http;/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>
            Helium: <ulink
            url="http://www.cs.uu.nl/wiki/bin/view/Helium/WebHome"/>
          </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://www.plantation-productions.com/Webster/HighLevelAsm/index.html"/>
          </para>
        </listitem>
        <listitem>
          <para>
            Download Location: <ulink
            url="http://www.plantation-productions.com/Webster/HighLevelAsm/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>Io</title>

      <para>
        <application>Io</application> is a small, prototype-based
        programming language. The ideas in <application>Io</application> are
        mostly inspired by <application>Smalltalk</application> (all values are
        objects), <application>Self</application> (prototype-based),
        <application>NewtonScript</application> (differential inheritance),
        <application>Act1</application> (actors and futures for concurrency),
        <application>LISP</application> (code is a runtime
        inspectable/modifiable tree) and <application>Lua</application>
        (small, embeddable).
      </para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>
            Project Home Page: <ulink
            url="http://iolanguage.org"/>
          </para>
        </listitem>
        <listitem>
          <para>
            Download Location: <ulink
            url="http://iobin.suspended-chord.info/"/>
          </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/stable.htm"/>
          </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://judoscript.org/jamaica.html"/>
          </para>
        </listitem>
        <listitem>
          <para>
            Download Location: <ulink
            url="http://judoscript.org/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/humanities/research/research-projects/past-projects/joy-programming-language"/>
          </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://judoscript.org/judo.html"/>
          </para>
        </listitem>
        <listitem>
          <para>
            Download Location: <ulink
            url="http://judoscript.org/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 analysers 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>
        <!-- URL broken
          <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://mathias.tripod.com/IavaHomepage.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://mercurylang.org/"/>
          </para>
        </listitem>
        <listitem>
          <para>
            Download Location: <ulink
            url="http://mercurylang.org/download.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://ftp.novell.com/pub/mono/archive/"/>
          </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/About"/>
          </para>
        </listitem>
        <listitem>
          <para>
            Download Location: <ulink
            url="http://nemerle.org/Downloads"/>
          </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.gnu.org/software/octave/"/>
          </para>
        </listitem>
        <listitem>
          <para>
            Download Location: <ulink
          url="http://www.gnu.org/software/octave/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://sourceforge.net/projects/ooc/"/>
          </para>
        </listitem>
        <listitem>
          <para>
            Download Location: <ulink
            url="&sourceforge-dl;/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="&sourceforge-dl;/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>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.ewing/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="&sourceforge-dl;/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="&sourceforge-dl;/regina-rexx"/>
          </para>
        </listitem>
      </itemizedlist>

    </sect3>

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

      <para>
        <application>SDCC</application> is a Freeware, retargetable,
        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="https://gforge.inria.fr/frs/?group_id=184"/>
          </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>
            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="&sourceforge-dl;/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 toward 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://bellard.org/tcc/"/>
          </para>
        </listitem>
        <listitem>
          <para>
            Download Location: <ulink
            url="http://download.savannah.gnu.org/releases-noredirect/tinycc/"/>
          </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 available 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://sourceforge.net/projects/tiny-cobol/"/>
          </para>
        </listitem>
        <listitem>
          <para>
            Download Location: <ulink
            url="&sourceforge-dl;/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="http://yorick.sourceforge.net/index.php"/>
          </para>
        </listitem>
        <listitem>
          <para>
            Download Location: <ulink
            url="http://sourceforge.net/projects/yorick/files/"/>
          </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>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, obfuscators, 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://archive.apache.org/dist/jakarta/bcel/"/>
          </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://sourceforge.net/projects/choco/"/>
          </para>
        </listitem>
        <listitem>
          <para>
            Download Location: <ulink
            url="http://choco.sourceforge.net/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/language-bindings.php"/>
          </para>
        </listitem>
      </itemizedlist>

      <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/4.0/"/>
            </para>
          </listitem>
          <listitem>
            <para>
              Download Location: <ulink
              url="http://java-gnome.sourceforge.net/4.0/get/"/>
            </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="&sourceforge-dl;/gtk2-perl"/>
            </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://techbase.kde.org/Development/Languages"/>
          </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="&sourceforge-dl;/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>

  </sect2>

  <sect2>
    <title>Integrated Development Environments</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>Anjuta</title>

      <para>
        <application>Anujuta</application> is a versatile Integrated
        Development Environment (IDE) for C and C++ on GNU/Linux. It has been
        written for <application>GTK</application>/GNOME and features a number
        of advanced programming facilities. These include project management,
        application wizards, an on-board interactive debugger, and a powerful
        source editor with source browsing and syntax highlighting.
      </para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>
            Project Home Page: <ulink
            url="http://projects.gnome.org/anjuta/index.shtml"/>
          </para>
        </listitem>
        <listitem>
          <para>
            Download Location: <ulink
            url="http://projects.gnome.org/anjuta/downloads.html"/>
          </para>
        </listitem>
      </itemizedlist>

    </sect3>

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

      <para>
        <application>Eclipse</application> is an open source community
        whose projects are focused on providing an extensible development
        platform and application frameworks for building software.
        <application>Eclipse</application> contains many projects, including an
        Integrated Development Environment (IDE) for Java.
      </para>

      <itemizedlist spacing="compact">
        <listitem>
          <para>
            Project Home Page: <ulink
            url="http://www.eclipse.org/"/>
          </para>
        </listitem>
        <listitem>
          <para>
            Download Location: <ulink
            url="http://www.eclipse.org/downloads/"/>
          </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://mozart.github.io/"/>
          </para>
        </listitem>
        <listitem>
          <para>
            Download Location: <ulink
            url="https://github.com/mozart/mozart2#downloads"/>
          </para>
        </listitem>
      </itemizedlist>

    </sect3>

  </sect2>

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

    <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="&sourceforge-dl;/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="https://ccache.dev"/>
          </para>
        </listitem>
        <listitem>
          <para>
            Download Location: <ulink
            url="https://github.com/ccache/ccache/releases/"/>
          </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="&gnu-http;/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="https://distcc.github.io/"/>
          </para>
        </listitem>
        <listitem>
          <para>
            Download Location: <ulink
            url="https://github.com/distcc/distcc/releases"/>
          </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="&sourceforge-dl;/ctags/"/>
          </para>
        </listitem>
      </itemizedlist>

    </sect3>
<!-- Untouched since 2008. There is a variable with a similar name that can be
     used when compiling Go projects. So this porject can be considered dead.
    <sect3 role="package">
      <title>gocache (GNU Object Cache)</title>

      <para>
        <application>goache</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="&sourceforge-dl;/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>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="https://strace.io"/>
          </para>
        </listitem>
        <listitem>
          <para>
            Download Location: <ulink
            url="https://strace.io/files/"/>
          </para>
        </listitem>
      </itemizedlist>

    </sect3>

  </sect2>

</sect1>