linux-from-scratch/glfs
1
0
Fork 0
mirror of https://github.com/Zeckmathederg/glfs.git synced 2025-01-23 22:42:14 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Added several programming languages to the 'Other Programming Tools' section

Browse Source 
git-svn-id: svn://svn.linuxfromscratch.org/BLFS/trunk/BOOK@5264 af4574ff-66df-0310-9fd7-8a98e5e911e0
This commit is contained in:
Randy McMurchy 2005-11-07 02:42:39 +00:00
parent 67f2f78a07
commit e92c670e36
3 changed files with 838 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
general.ent
View File

@ -1,4 +1,4 @@
<!ENTITY day "05">
<!ENTITY day "07">
<!ENTITY month "11">
<!ENTITY year "2005">
<!ENTITY version "svn-&year;&month;&day;">

827
general/prog/other-tools.xml
View File

@ -57,6 +57,455 @@
-->
<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>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>&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>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>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>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>
@ -84,6 +533,195 @@
</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>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>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>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>Mono</title>
@ -127,6 +765,28 @@
</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>R</title>
@ -159,6 +819,173 @@
</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>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>
</sect2>
<sect2>

10
introduction/welcome/changelog.xml
View File

@ -41,6 +41,16 @@
-->
<listitem>
<para>November 7th, 2005</para>
<itemizedlist>
<listitem>
<para>[randy] - Added several programming languages to the 'Other
Programming Tools' section.</para>
</listitem>
</itemizedlist>
</listitem>
<listitem>
<para>November 5th, 2005</para>
<itemizedlist>