[ excerpt from developer's www site ]
Jam is a small open-source build tool that can be used as a replacement
for Make. Even though Jam is a lot simpler to use than Make, it is
far more powerful and easy to master. It already works on a large
variety of platforms (Unix, Windows, OS/2, VMS, MacOS, BeOS, etc..),
it is trivial to port, and its design is sufficiently clear to allow
any average programmer to extend it with advanced features at will.
The main differences between Jam and Make are the following:
- Jam uses "Jamfiles" instead of "Makefiles".
- Jamfiles do not normally contain toolset-specific rules or actions.
They're thus portable among distinct compilers
- Jamfiles are a lot simpler than Makefiles to write and understand,
while providing the same functionality, and much, much more !!
tolua++ is an extended version of tolua, a tool to integrate C/C++ code
with Lua. tolua++ includes new features oriented to c++ such as:
* Support for std::string as a basic type (this can be turned off by a
command line option).
* Support for class templates
As well as other features and bugfixes.
tolua is a tool that greatly simplifies the integration of C/C++ code with
Lua. Based on a cleaned header file (or extracts from real header files),
tolua automatically generates the binding code to access C/C++ features
from Lua. Using Lua API and tag method facilities, tolua maps C/C++
constants, external variables, functions, classes, and methods to Lua.
GNU mifluz has two main characteristics : it is very
simple (one might say stupid :-) and uses 50% of the size of the
indexed text for the index. It is simple because it provides only
a few basic functionalities. It does not contain document parsers
(HTML, PDF etc...). It does not contain a full text query parser.
It does not provide result display functions or other user friendly
stuff. It only provides functions to store word occurrences and retrieve
them. The fact that it uses 50% of the size of the indexed text is
rather atypical. Most well known full text indexing systems only use
30%. The advantage GNU mifluz has over most full text indexing systems
is that it is fully dynamic (update, delete, insert), uses only a
controlled amount of memory while resolving a query, has higher upper
limits and has a simple storage scheme. Consuming more disk space
allows all this.
This plugin lets you import into Trac a series of tickets from a CSV
file or (if the xlrd library is installed) from an Excel file.
You can also use it to modify tickets in batch, by saving a report as
CSV, editing the CSV file, and re-importing the tickets.
This plugin is very useful when starting a new project: you can import a
list of requirements that may have come from meeting notes, list of
features, other ticketing systems... It's also great to review the
tickets off-line, or to do massive changes to tickets.
Based on the ticket id (or, if no id exists, on the summary) in the
imported file, tickets are either created or updated.
gpsd is a service daemon that monitors one or more GPSes
attached to a host computer through serial or USB ports,
making all data on the location/course/velocity of the
sensors available to be queried on TCP port 2947 of the
host computer. With gpsd, multiple GPS client applications
(such as navigational and wardriving software) can share
access to GPSes without contention or loss of data. Also,
gpsd responds to queries with a format that is substantially
easier to parse than the NMEA 0183 emitted by most GPSes.
DDD is the Data Display Debugger, a common graphical front-end for
GDB, DBX, and XDB debuggers.
DDD is an Motif application that besides the "usual" features such as viewing
source texts and breakpoints, DDD provides a _graphical_data_display_, where
data structures are displayed as graphs. A simple mouse click dereferences
pointers or reveals structure contents. Complex data structures can be
explored incrementally and interactively, using automatic layout if
preferred. Each time the program stops, the data display reflects the
current variable values.
Data Display Debugger requires pty(4) functionality to talk to GDB, so
make sure to either load appropriate kernel module or use custom kernel
with pty(4) compiled in.
This program generate a C function that uses getopt_long function to parse
the command line options, validate them and fill a struct.
Thus your program can now handle options such as:
myprog --input foo.c -o foo.o --no-tabs -i 100 *.class
And both long options (those that start with --) and short options (start
with - and consist of only one character) can be handled. For standards
about short and long options you may want to take a look at the GNU Coding
Standards.
Converts a data structure into a sequence of perl statements sufficient for
recreating the original via eval. This module is very similar in concept to
Data::Dumper and Data::Dump, with the major differences being that this module
is designed to output to a stream instead of constructing its output in memory,
and that the traversal over the data structure is effectively breadth first
versus the depth first traversal done by the others.
In fact the data structure is scanned twice, first in breadth first mode to
perform structural analysis, and then in depth first mode to actually produce
the output, but obeying the depth relationships of the first pass.
liboping is a C library to generate ICMP echo requests, better known as
'ping packets'. It is intended for use in network monitoring applications
or applications that would otherwise need to fork ping(1) frequently.
Included is a sample application, called oping, which demonstrates the
library's abilities. It is like ping, ping6, and fping rolled into one.
Version 1.4.0, a second example application, noping, provides an
ncurses-based front-end to liboping. Using curses windows it is able
to display the ping statistics online 'live'. An aberrant behavior
detection highlights all round-trip times that are unusually high or
low.
Webunit is a framework for unit testing websites:
Features in a nutshell:
1. Browser-like page fetching including fetching the images and stylesheets
needed for a page and following redirects
2. Cookies stored and trackable (all automatically handled)
3. HTTP, HTTPS, GET, POST, basic auth all handled, control over expected status
codes, ...
4. DOM parsing of pages to retrieve and analyse structure, including simple
form re-posting
5. Two-line page-fetch followed by form-submit possible, with error checking
6. Ability to register error page content across multiple tests
7. Uses python's standard unittest module as the underlying framework