Gamin is a file and directory monitoring system defined to be a subset of the
FAM (File Alteration Monitor) system. This is a service provided by a library
which allows to detect when a file or a directory has been modified.
Whereas the FreeBSD port of FAM polls files every few seconds, this port
includes a kqueue(2) backend for immediate notification of most alterations.
GUI builder for the GTK+ toolkit designed to be ultra easy to use
A set of C++ front-end for cvs distributed under GPL.
CvsGui features
WinCvs is written in C++ using the Microsoft MFC.
MacCvs is written in C++ using Metrowerks PowerPlant.
gCvs is written in C++ using GNU gtk+.
They are using the latest cvs source code.
They are making cvs easier for the novice.
They are increasing the power of cvs by providing an high-end interface.
The project is growing because it is supported and developed
by several cvs users.
FAM, the File Alteration Monitor, provides an API which applications can use
to be notified when specific files or directories are changed.
FC++ is a library for functional programming in C++. Functional programming
is a programming paradigm in which functions are treated as regular values.
Thus, we can have functions that take other functions as parameters. The
former functions are called "higher-order" functions. A common feature of
functions is that they can be polymorphic. "Polymorphic" means that the same
function can be used with arguments of many types. FC++ is distinguished from
other libraries (including the C++ Standard Library) by its complete support
for polymorphism: FC++ polymorphic higher-order functions can take other
polymorphic functions as arguments and return polymorphic functions as results.
This is particularly useful (i.e., simplifies code) in C++ where type inference
is limited and we often need to pass polymorphic functions around and determine
their type later.
With FC++ you can define your own higher-order polymorphic functions, but the
library also contains a large amount of functionality that can be re-used as-is
in C++ programs. This includes infinite ("lazy") lists, useful higher-order
functions (like map, compose, etc.), a reference-counting facility that can be
used to replace C++ pointers, many common logical and arithmetic operators in
a form that can be used with higher-order functions, and more.
This is an implementation of a Fibonacci Heap. A Fibonacci Heap is
a very efficient heap. The cost of an insert is O(1), and the amortized
cost of an extract minimum is O(lgn). You can extract an already inserted
item out of order in O(lgn). The way the Fibonacci heap obtains this is
by delaying the organizing of the items until you extract.
The Flex SDK provides a highly productive, open source framework for
building and maintaining expressive web applications that deploy
consistently on all major browsers, desktops and operating systems.
It provides a modern, standards-based language and programming model
that supports common design patterns suitable for developers from many
backgrounds.
Flex applications run in the ubiquitous Adobe Flash Player and Adobe
AIR.
Gecode is a toolkit for developing constraint-based systems and
applications. Gecode provides a constraint solver with state-of-the-art
performance while being modular and extensible.
Generate is a text preprocessor that I originally wrote to help me write
custom accounting applications based on the Progress database product. I
felt that the built in wasn't useful enough so I designed a new one and
implemented it. It actually started life as a package configuration and
batch file generator for DOS and mutated to a simple script interpreter
to replace shar file distribution. At this point it has almost nothing in
common with that first program.
The basic idea behind generate is to create a script which generates files.
There is some simple flow control constructs but the power lies in its
macro processing. I have shamelessly stolen ideas from cpp, m4, make and
David Tilbrook's dtree.
GeneratorRunner is a tool that eases the development of binding generators
for C++ and Qt-based libraries by providing a framework to help automating
most of the process. It uses the ApiExtractor library to parse the header
files and manipulate the classes information while generating the binding
code using front-end modules provided by the user.
GeneratorRunner is based on the QtScriptGenerator project