[[Software-development::programming-language]]

Acts as fu: When you need a dash of ActiveRecord and nothing more. Now you have no excuse for not test-driving your ActiveRecord extending plugins.

Ada Components: A component library for the Ada language. The four main categories are data structures, math, Ada programming tools, and OS interface.

Ada Motif binding library: SERC's Ada/Motif is a complete binding to X Windows and OSF/Motif for the Ada programming language it was based in part upon the SAIC/Unisys (STARS) public-domain bindings it incorporates many of the bug fixes and additional capabilities beyond the public-domain releases in Ada/Motif. Most noteworthy are the capabilities included in Ada/Motif for Ada tasking, callback registration, memory leak detection/prevention and capabilities for developing customized widgets. Paramax/STARS considers Ada/Motif to be the commercial version of their STARS bindings, according to SERC.

AdaDoc: AdaDoc is a tool for Ada 95 developers. It creates an HTML file from a package specification for documentation purposes.

AdaSockets: 'AdaSockets' is a library that lets you use sockets in Ada 95. It supports unicast and multicast sockets, and uses object oriented structures to ease sockets manipulation.

AdaUnits: 'AdaUnits' provides an implementation of dimensioned values for Ada. Unit checks are made at run-time, if not optimized out by the compiler. The package supports SI and irregular measurement units and shifted units (like degrees Celsius). Conversions from and back to strings are provided for all various irregular units.

AdacURL: AdacURL is an Ada95 binding to the popular curl library for fetching files over various protocols such as HTTP, FTP, or TELNET.

Algol 68 Genie: Algol68G (Algol 68 Genie) is an Algol 68 implementation. Its front-end parses an entire Algol 68 source program. If parsing is successful, the syntax tree (that serves as an intermediate program representation) is interpreted by Algol68G's back-end. The interpreter performs many runtime checks.

Amnesia: Hopefully with Amnesia you'll know exactly whats happening with memory when it comes to memcached. Its always nice to have some statistics to see how everything is performing within your stack. Memcached seems to be a mystery box that people don't really pay alot of attention to. Amnesia tells you how your application is performing, when it misses, when it is running sweet, when you're about to run out of memcached and (perhaps) fall down in a screaming heap.

Anemone: Anemone is a Ruby library that makes it quick and painless to write programs that spider a website. It provides a simple DSL for performing actions on every page of a site, skipping certain URLs, and calculating the shortest path to a given page on a site. The multi-threaded design makes Anemone fast. The API makes it simple. And the expressiveness of Ruby makes it powerful.

Apl: GNU APL is an interpreter for APL as described in ISO standard 13751, aka. "Programming Language APL, Extended". This free version of the programming language APL has already implemented the latest and greatest features (nested arrays and related functions, complex numbers, shared variables) and is intended to be a full implementation of the standard. GNU APL has builtin support for Emacs (gnu-apl-mode). GNU APL has a predefined keyboard layout in order to produce APL characters when the "Alt" key is held down. The layout can be customized by the program xmodmap and a new keyboard mapping table like "apl.xmodmap" provided in source: xmodmap apl.xmodmap Text files beginning with #!apl run the interpreter as a shell with the subsequent lines as input.

Apydia: Apydia is an API reference documentation generator for Python. It's designed as an instantly serviceable replacement for Pudge's API-documentation generator. It won't generate complete websites from reST etc. like Pudge does, though - Apydia is only about the API.

AsmEdit: 'AsmEdit' is an editor and IDE written in assembler. It includes source highlighting and support for external helper programs for compiling and debugging. It contains word processing features such as paragraphing and spelling in a binary of less than 20,000 bytes.

AsmRef: 'AsmRef' includes a menu system and search function to display data on the Linux kernel and most topics associated with x86 assembler development on GNU/Linux systems.

Asset Trip: Asset Trip bundles JavaScript and CSS files at deploy time. The assets are then served from a Git-esque object store in the applicationÃ¢â¬â¢s public directory.

Association Freezer: Freeze an Active Record belongs_to association to ignore any future changes.

Atrack

Atrack is a ntrack / Bittorrent tracker designed from the ground up to run on Google's App Engine grid. Its main goals are:

As small codebase as possible.
As fast as possible.
As low bandwidth usage as possible.
As low memory usage as possible.
For this it relies heavily (and almost completely) on memcached, no data is stored anywhere, and it lets memcached do most of the lifecycle management. Atrack also aims to respect your privacy: other than what is needed for the most basic tracking (hashes/keys and ip/ports) atrack gathers no information whatsoever. Beyond that no aggregate statistics are kept of anything (at least once the testing/debugging phase is over), and nothing is stored permanently anywhere, not even hashes and ip/ports, they are kept in memory until they are expired by memcached and never written to disk or any other kind of permanent storage.

Avrotest: Arbitrary performance test between avro and thrift.

Awesome (node.js): A Redis implementation in node.js.

BFFFT: Using a simple array as input, a 2-dimensional Fast Fourier Transform consists of two one-dimensional FFTs performed (for instance) on each line first, and on each column next. An important limitation in FFT computer applications dealing with large arrays is the fact that the algorithm is not well suited to parallelization, due to the huge amount of data that has to be transfered between computers. Since the transfers are proportional to the number of operations, network time soon becomes prominent when the number of processors is high. This program uses vectorization as an alternative to parallelization methods.

BRL: BRL is a language designed for server-side WWW-based applications, particularly database applications as it is particularly good at constructing output that is a mix of static and dynamic content. It is based on Scheme, which makes the syntax extremely simple yet powerful. This implementation is a Java Servlet using the Kawa Scheme compiler.

BWidget Toolkit: The BWidget Toolkit is a high-level widget set for Tcl/Tk that uses native Tcl/Tk 8.x namespaces. They feature a professional look and feel and don't require a compiled extension library. Tools included are XLFDfont, assert, clonename, focus, get3dcolor, getname, grab, lreorder, parsetext, and place.

Babel

A collection of tools for internationalizing Python applications Babel is composed of two major parts:

tools to build and work with gettext message catalogs
a Python interface to the CLDR (Common Locale Data Repository), providing access to various locale display names, localized number and date formatting, etc.

Bacon: Bacon is a small RSpec clone weighing less than 350 LoC but nevertheless providing all essential features.

Badger: Badger is a library used to generate badge sheets for events, given a PDF template and data for the badges.

Bakery: 'bakery' is a C++ Framework for creating GNOME applications using Gnome-- and Gtk--. It provides a Document/View architecture without forcing the user to use the whole architecture. It also makes it easy to start developing GNOME applications by inheriting and overriding.

Barista: Barista is very, very similar to bistro_car (infact, credit where credit is due - it shares similar code / is almost a fork). The main difference being, it lets you use coffee as you would javascript. Simply put, Write coffee and place it in app/coffeescripts and Barista will automatically serve it as if it was placed in public/javascripts.

Bas55: bas55 is an editor and interpreter for the Minimal BASIC programming language, as defined by the ECMA-55 standard.

Beanstalkc: beanstalkc is a simple beanstalkd client library for Python. beanstalkd is a fast, distributed, in-memory workqueue service.

Bff: bff is a relatively fast (due to slight optimizations) Brainf*ck language interpreter written in portable C.

Bfloop: bfloop is an interpreter for the BLooP and FLooP programming languages described in the book Gödel, Escher, Bach by Douglas Hofstadter. BLooP is a language that has only bounded loops, in other words before you enter a loop you have to give a fixed upper limit on the number of times to run the body, and you can’t change the limit while in the loop. It is impossible for a BLooP program to run forever; it always quits with an output in some finite time, an upper limit for which is predictable in advance. Functions that BLooP can compute are called primitive recursive functions, and it turns out that not all functions are primitive recursive. The FLooP language is the same as BLooP with the addition of an unbounded loop (MU-LOOP). FLooP can calculate anything your computer can calculate, but you cannot say in general whether a FLooP program will eventually terminate.

Biferno: Biferno is a new object-oriented, HTML embedded, scripting language for web development. Its high-level built-in classes, with their methods and properties, make the code very clean and easy to mantain. It has a plug-in architecture that makes the language completely extensible, allowing other developer to easily add functionality through internal and external classes.

BigFORTH: bigFORTH is a native code Forth for x86 processors. It is 32 bit and complies fully with ANS Forth. Tools include a multitasker; source-able decompiler; source level debugger (even using optimized macros) with single step and trace, and as many breakpoints as you want; post mortem dump and return stack trace; and a Pentium-MMX-assembler/disassembler. MINOS is a portable GUI library, written in object oriented Forth, and includes the GUI development editor Theseus. It is on a separate release schedule from bigFORTH; 0.9.8 beta of MINOS was released 2002-06-23.

Bigloo: Bigloo is an implementation of the Scheme programming language. It relies on an optimizing compiler from Scheme to C. Bigloo enables connections between Scheme code and C code. It proposes many extensions to Scheme such as a regular parser compiler, an lalr parser compiler, pattern matching, an object layer, etc.

Bisonc++: Bisonc++ is a parser generator like bison, but it generates C++ code Bisonc++ is a general-purpose parser generator that converts a grammar description for an LALR(1) context-free grammar into a C++ class to parse that grammar. Once you are proficient with bisonc++, you may use it to develop a wide range of language parsers, from those used in simple desk calculators to complex programming languages. Bisonc++ is highly comparable to the program bison++, written by Alain Coetmeur: all properly-written bison++ grammars ought to be convertible to bisonc++ grammars after very little or no change. Anyone familiar with bison++ or its precursor, bison, should be able to use bisonc++ with little trouble. You need to be fluent in using the C++ programming in order to use bisonc++. Bisonc++ expands the concepts initially implemented in bison and bison++, offering a cleaner setup of the generated parser class. The parser class is derived from a base-class, mainly containing the parser's token- and type-definitions as well as several member func- tions which should not be modified by the programmer. To create the program from its sources, either descend into the bisonc++ directory, or unpack a created archive, cd into its top-level directory and follow the instructions provided in the INSTALL file found there. Alternatively, binary ready-to-install versions of the Bisonc++ parser generator are available in verious GNU/Linux distributions, in particular Debian. See, e.g., https://packages.debian.org/search?keywords=bisonc%2B%2B&searchon=names&suite=all&section=all Gitlab's web-pages for Bisonc++ are here: https://fbb-git.gitlab.io/bisoncpp/

Bitstring: bitstring is a pure Python module designed to help make the creation and analysis of binary data as simple and natural as possible. BitStrings can be constructed from integers (big and little endian), hex, octal, binary, strings or files. They can be sliced, joined, reversed, inserted into, overwritten, etc. with simple functions or slice notation. They can also be read from, searched and replaced, and navigated in, similar to a file or stream.

Bitten: Bitten is a Python-based framework for collecting various software metrics via continuous integration. It builds on Trac to provide an integrated web-based user interface.

Blade: Blade emphasizes algorithm over syntax, and for this reason it has a very small but powerful syntax set with a very natural feel. It is object-oriented, fast, dynamically typed, and features comprehensive built-in functions, exceptions, closures, custom iterable classes, garbage collection, stack-based VM, and REPL. Package management is built into the language module system.

Bobcat: The (shared) Bobcat library contains classes and templates used by, e.g., the Stealth and Bisonc++ programs. The Bobcat library contains a variety of C++ classes and templates, some of them based on well-known Design Patterns. The library offers classes handling, e.g., Child Processes, Forks, Pipes and Redirection Command-to-Function associations Command-line arguments and history handling Command-line editing using streams Configuration Files Decryption and Encryption Extended String Operations Hash-tables Integers of unlimited size File-descriptor based streams (e.g. handle sockets using streams) Mail headers and mail filtering (milters) Message Digests Pattern matching Single (Direct) Key Input Syslog- and other kinds of messages Temporary files Universal Type Conversions (Templates)

Booleano: Booleano is an interpreter of boolean expressions, a library to define and run filters available as text (e.g., in a natural language) or in Python code. In order to handle text-based filters, Booleano ships with a fully-featured parser whose grammar is adaptive: Its properties can be overridden using simple configuration directives.

Boost

Boost is a repository of portable and peer-reviewed C++ libraries.

Accumulators: Framework for incremental calculation, and collection of statistical accumulators. Math and numerics
Algorithm: A collection of useful generic algorithms. Algorithms
Any: Safe, generic container for single values of different value types. Data structures
Array: STL compliant container wrapper for arrays of constant size. Containers
Asio: Portable networking, including sockets, timers, hostname resolution and socket iostreams. Concurrent Programming
Assign: Filling containers with constant or generated data has never been easier. Input/Output
Bimap: Bidirectional maps library for C++. With Boost.Bimap you can create associative containers in which both types can be used as key. Containers
Bind: boost::bind is a generalization of the standard functions std::bind1st and std::bind2nd. It supports arbitrary function objects, functions, function pointers, and member function pointers, and is able to bind any argument to a specific value or route input arguments into arbitrary positions. Function objects and higher-order programming
Call Traits: Defines types for passing parameters. Generic Programming
Chrono: Useful time utilities. Domain Specific
Circular Buffer: A STL compliant container also known as ring or cyclic buffer. Containers
Compatibility: Help for non-conforming standard libraries. Broken compiler workarounds
Compressed Pair: Empty member optimization. Data structures
Concept Check: Tools for generic programming. Generic Programming
Config: Helps Boost library developers adapt to compiler idiosyncrasies; not intended for library users. Broken compiler workarounds
Container: Standard library containers and extensions. Containers
Context: Context switching library. Concurrent Programming
Conversion: Polymorphic and lexical casts. String and text processing
CRC: The Boost CRC Library provides two implementations of CRC (cyclic redundancy code) computation objects and two implementations of CRC computation functions. The implementations are template-based. Domain Specific
Date Time: A set of date-time libraries based on generic programming concepts. Domain Specific
Dynamic Bitset: The dynamic_bitset class represents a set of bits. It provides accesses to the value of individual bits via an operator[] and provides all of the bitwise operators that one can apply to builtin integers, such as operator& and operator<<. The number of bits in the set is specified at runtime via a parameter to the constructor of the dynamic_bitset. Containers
Enable If: Selective inclusion of function template overloads. Generic Programming
Exception: The Boost Exception library supports transporting of arbitrary data in exception objects, and transporting of exceptions between threads. Language Features Emulation
Filesystem: The Boost Filesystem Library provides portable facilities to query and manipulate paths, files, and directories. System
Flyweight: Design pattern to manage large quantities of highly redundant objects. Patterns and Idioms
Foreach: In C++, writing a loop that iterates over a sequence is tedious. We can either use iterators, which requires a considerable amount of boiler-plate, or we can use the std::for_each() algorithm and move our loop body into a predicate, which requires no less boiler-plate and forces us to move our logic far from where it will be used. In contrast, some other languages, like Perl, provide a dedicated "foreach" construct that automates this process. BOOST_FOREACH is just such a construct for C++. It iterates over sequences for us, freeing us from having to deal directly with iterators or write predicates. Algorithms
Format: The format library provides a class for formatting arguments according to a format-string, as does printf, but with two major differences: format sends the arguments to an internal stream, and so is entirely type-safe and naturally supports all user-defined types; the ellipsis (...) can not be used correctly in the strongly typed context of format, and thus the function call with arbitrary arguments is replaced by successive calls to an argument feeding operator%. String and text processing
Function: Function object wrappers for deferred calls or callbacks. Function objects and higher-order programming
Function Types: Boost.FunctionTypes provides functionality to classify, decompose and synthesize function, function pointer, function reference and pointer to member types. Generic Programming
Functional: The Boost.Function library contains a family of class templates that are function object wrappers. Function objects and higher-order programming
Functional/Factory: Function object templates for dynamic and static object creation Function objects and higher-order programming
Functional/Forward: Adapters to allow generic function objects to accept arbitrary arguments Function objects and higher-order programming
Functional/Hash: A TR1 hash function object that can be extended to hash user defined types. Function objects and higher-order programming
Functional/Overloaded Function: Overload different functions into a single function object. Function objects and higher-order programming
Fusion: Library for working with tuples, including various containers, algorithms, etc. Template Metaprogramming
Geometry: Geometry Library. Algorithms
GIL: Generic Image Library Containers
Graph: The BGL graph interface and graph components are generic, in the same sense as the the Standard Template Library (STL). Containers
Heap: Priority queue data structures. Data structures
ICL: Interval Container Library, interval sets and maps and aggregation of associated values Containers
Identity Type: Wrap types within round parenthesis so they can always be passed as macro parameters. Preprocessor Metaprogramming
In Place Factory, Typed In Place Factory: Generic in-place construction of contained objects with a variadic argument-list. Generic Programming
Integer: The organization of boost integer headers and classes is designed to take advantage of <stdint.h> types from the 1999 C standard without resorting to undefined behavior in terms of the 1998 C++ standard. The header <boost/cstdint.hpp> makes the standard integer types safely available in namespace boost without placing any names in namespace std. Math and numerics
Interprocess: Shared memory, memory mapped files, process-shared mutexes, condition variables, containers and allocators. Concurrent Programming
Interval: Extends the usual arithmetic functions to mathematical intervals. Math and numerics
Intrusive: Intrusive containers and algorithms. Containers
IO State Savers: The I/O sub-library of Boost helps segregate the large number of Boost headers. This sub-library should contain various items to use with/for the standard I/O library. Input/Output
Iostreams: Boost.IOStreams provides a framework for defining streams, stream buffers and i/o filters. String and text processing
Iterators: The Boost Iterator Library contains two parts. The first is a system of concepts which extend the C++ standard iterator requirements. The second is a framework of components for building iterators based on these extended concepts and includes several useful iterator adaptors. Iterators
Lambda: Define small unnamed function objects at the actual call site, and more. Function objects and higher-order programming
Lexical Cast: General literal text conversions, such as an int represented a string, or vice-versa, from Kevlin Henney. String and text processing
Local Function: Program functions locally, within other functions, directly within the scope where they are needed. Function objects and higher-order programming
Locale: Provide localization and Unicode handling tools for C++. String and text processing
Math: Boost.Math includes several contributions in the domain of mathematics: The Greatest Common Divisor and Least Common Multiple library provides run-time and compile-time evaluation of the greatest common divisor (GCD) or least common multiple (LCM) of two integers. The Special Functions library currently provides eight templated special functions, in namespace boost. The Complex Number Inverse Trigonometric Functions are the inverses of trigonometric functions currently present in the C++ standard. Quaternions are a relative of complex numbers often used to parameterise rotations in three dimentional space. Octonions, like quaternions, are a relative of complex numbers. Math and numerics
Math Common Factor: Greatest common divisor and least common multiple. Math and numerics
Math Octonion: Octonions. Math and numerics
Math Quaternion: Quaternions. Math and numerics
Math/Special Functions: A wide selection of mathematical special functions. Math and numerics
Math/Statistical Distributions: A wide selection of univariate statistical distributions and functions that operate on them. Math and numerics
Member Function: Generalized binders for function/object/pointers and member functions. Function objects and higher-order programming
Meta State Machine: A very high-performance library for expressive UML2 finite state machines. State Machines
Min-Max: Standard library extensions for simultaneous min/max and min/max element computations. Algorithms
Move: Portable move semantics for C++03 and C++11 compilers. Language Features Emulation
MPI: Message Passing Interface library, for use in distributed-memory parallel application programming. Concurrent Programming
MPL: The Boost.MPL library is a general-purpose, high-level C++ template metaprogramming framework of compile-time algorithms, sequences and metafunctions. It provides a conceptual foundation and an extensive set of powerful and coherent tools that make doing explict metaprogramming in C++ as easy and enjoyable as possible within the current language. Template Metaprogramming
Multi-Array: Boost.MultiArray provides a generic N-dimensional array concept definition and common implementations of that interface. Containers
Multi-Index: The Boost Multi-index Containers Library provides a class template named multi_index_container which enables the construction of containers maintaining one or more indices with different sorting and access semantics. Containers
Numeric Conversion: Optimized Policy-based Numeric Conversions. Math and numerics
Operators: Templates ease arithmetic classes and iterators. Iterators
Optional: Discriminated-union wrapper for optional values. Miscellaneous
Parameter: Boost.Parameter Library - Write functions that accept arguments by name. Programming Interfaces
Phoenix: Define small unnamed function objects at the actual call site, and more. Function objects and higher-order programming
Pointer Container: Containers for storing heap-allocated polymorphic objects to ease OO-programming. Containers
Polygon: Booleans/clipping, resizing/offsetting and more for planar polygons with integral coordinates. Miscellaneous
Pool: Memory pool management. Memory
Preprocessor: Preprocessor metaprogramming tools including repetition and recursion. Preprocessor Metaprogramming
Program Options: The program_options library allows program developers to obtain program options, that is (name, value) pairs from the user, via conventional methods such as command line and config file. Input/Output
Property Map: Concepts defining interfaces which map key objects to value objects. Containers
Property Tree: A tree data structure especially suited to storing configuration data. Containers
Proto: Expression template library and compiler construction toolkit for domain-specific embedded languages. Template Metaprogramming
Python: The Boost Python Library is a framework for interfacing Python and C++. It allows you to quickly and seamlessly expose C++ classes functions and objects to Python, and vice-versa, using no special tools -- just your C++ compiler. Inter-language support
Random: A complete system for random number generation. Math and numerics
Range: A new infrastructure for generic algorithms that builds on top of the new iterator concepts. Algorithms
Ratio: Compile time rational arithmetic. Math and numerics
Rational: A rational number class. Math and numerics
Ref: A utility library for passing references to generic functions. Function objects and higher-order programming
Regex: Regular expression library. String and text processing
Result Of: Determines the type of a function call expression. Function objects and higher-order programming
Scope Exit: Execute arbitrary code at scope exit. Language Features Emulation
Serialization: Serialization for persistence and marshalling. Input/Output
Signals: Managed signals & slots callback implementation. Function objects and higher-order programming
Signals2: Managed signals & slots callback implementation (thread-safe version 2). Function objects and higher-order programming
Smart Ptr: Smart pointer class templates. Memory
Spirit: LL parser framework represents parsers directly as EBNF grammars in inlined C++. String and text processing
Statechart: Boost.Statechart - Arbitrarily complex finite state machines can be implemented in easily readable and maintainable C++ code. State Machines
Static Assert: Static assertions (compile time assertions). Generic Programming
String Algo: String algorithms library. String and text processing
Swap: Enhanced generic swap function. Miscellaneous
System: Operating system support, including the diagnostics support that will be part of the C++0x standard library. System
Test: Support for simple program testing, full unit testing, and for program execution monitoring. Correctness and testing
Thread: Portable C++ multi-threading. Concurrent Programming
Timer: Event timer, progress timer, and progress display classes. Miscellaneous
Tokenizer: Break of a string or other character sequence into a series of tokens. String and text processing
TR1: The TR1 library provides an implementation of the C++ Technical Report on Standard Library Extensions. This library does not itself implement the TR1 components, rather it's a thin wrapper that will include your standard library's TR1 implementation (if it has one), otherwise it will include the Boost Library equivalents, and import them into namespace std::tr1. Miscellaneous
Tribool: 3-state boolean type library. Miscellaneous
Tuple: Ease definition of functions returning multiple values, and more. Data structures
Type Traits: Templates for fundamental properties of types. Generic Programming
Typeof: Typeof operator emulation. Language Features Emulation
uBLAS: uBLAS provides matrix and vector classes as well as basic linear algebra routines. Several dense, packed and sparse storage schemes are supported. Math and numerics
Units: Zero-overhead dimensional analysis and unit/quantity manipulation and conversion. Domain Specific
Unordered: Unordered associative containers. Containers
Utility: Class noncopyable plus checked_delete(), checked_array_delete(), next(), prior() function templates, plus base-from-member idiom. Algorithms
Uuid: A universally unique identifier. Data structures
Value Initialized: Wrapper for uniform-syntax value initialization, based on the original idea of David Abrahams. Miscellaneous
Variant: Safe, generic, stack-based discriminated union container. Containers
Wave: The Boost.Wave library is a Standards conformant, and highly configurable implementation of the mandated C99/C++ preprocessor functionality packed behind an easy to use iterator interface. String and text processing
Xpressive: Regular expressions that can be written as strings or as expression templates, and which can refer to each other and themselves recursively with the power of context-free grammars. String and text processing

Bottle: Bottle is a fast and simple WSGI web-framework for Python packed into a single file with no external dependencies.

Bundler: Bundler is a tool that manages gem dependencies for your ruby application. It takes a gem manifest file and is able to fetch, download, and install the gems and all child dependencies specified in this manifest. It can manage any update to the gem manifest file and update the bundled gems accordingly. It also lets you run any ruby code in context of the bundled gem environment.

Busted: Busted is a tool for gathering and reporting information about a broken gem.

C ElementTree: * " cElementTree is included with Python 2.5 and later, as xml.etree.cElementTree. " The cElementTree module is a C implementation of the ElementTree API, optimized for fast parsing and low memory use. On typical documents, cElementTree is 15-20 times faster than the Python version of ElementTree, and uses 2-5 times less memory. On modern hardware, that means that documents in the 50-100 megabyte range can be manipulated in memory, and that documents in the 0-1 megabyte range load in zero time (0.0 seconds). This allows you to drastically simplify many kinds of XML applications.

C to C++ converter: This packages is a set of Python scripts that perform each stage of code conversion from C to C++. First, header files are converted into classes and declarations become members. Then, references to variables and functions are transformed into references to attributes and methods of classes. Additional tools provided include a generator/updater of header files, and a trans-directory mover with update of include statements.

C++ Annotations: The C++ Annotations offer an extensive tutorial about the C++ programming language. It can be used as a textbook for C/C++ programming courses.

C2hs: 'c2hs' is an interface generator that simplifies the development of Haskell bindings to C libraries. It processes existing C header files that determine data layout and function signatures on the C side in conjunction with Haskell modules that specify Haskell-side type signatures and marshaling details. Hooks embedded in the Haskell code signal access to C structures and functions; they are expanded by the interfacing tool in dependence on information from the corresponding C header file.

CMDln: `cmdln.py` is an extension of Python's default `cmd.py` module that provides "a simple framework for writing line-oriented command interpreters". The idea (with both cmd.py and cmdln.py) is to be able to quickly build multi-sub-command tools (think cvs or svn) and/or simple interactive shells (think gdb or pdb). Cmdln's extensions make it more natural to write sub-commands, integrate optparse for simple option processing, and make having good command documentation easier.

CMUCL: CMUCL is a free, high performance implementation of the Common Lisp programming language which runs on most major Unix platforms. It mainly conforms to the ANSI Common Lisp standard. CMUCL provides a sophisticated native code compiler; a powerful foreign function interface; an implementation of CLOS, the Common Lisp Object System; which includes multimethods and a metaobject protocol; a source-level debugger and code profiler; and an Emacs-like editor implemented in Common Lisp.

Free Software Foundation!

Semantic search

Query log

Navigation menu

Personal tools

Namespaces

Variants

Views

More

Search

Interaction

Navigation

Creation

Print

Tools