Free flavor software for linux

IdeaCart is an Open Source shopping cart based on PHP and MySQL.
IdeaCart is available under the GNU General Public License.
Out of the box, IdeaCart provides feature rich solutions for small to medium size ecommerce sites.
IdeaCart combines the power of MySQL with the ease and capability of PHP to offer a truly dynamic solution for todays growing ecommerce sites.
While in the development stages, IdeaCart will provide a robust solution for most ecommerce needs.
IdeaCart current functions on any PHP 4+ configuration running most flavors of Unix and Linux, BSD and most Windows configurations that operate Apache and PHP.

sidux is a desktop-oriented distribution and live CD based on the unstable branch of Debian GNU/Linux. This project was originally created by a group of developers who split from the KANOTIX project and launched their own distribution.
Main features:
- After three months of development, we are proud to announce the immediate availability of sidux 2007-02 for amd64 and i686 systems, shipping in a 425 MB lite KDE and a 690 MB full KDE flavor. Our second official sidux release has concentrated on overhauling the early boot sequence and adapting to a wider variety of desktop environments and window managers. While this release only ships in two KDE flavors (lite and full) again, were looking for interested maintainers contributing to special purpose releases or tweaking support for other desktop environments and window managers.
Enhancements:
- After less than three months of development, we are proud to announce the immediate availability of sidux 2007-03 Gaia for amd64 and i686 systems, shipping in a 440 MB lite KDE and a 700 MB full KDE flavors. Our third official sidux release concentrates on overhauling the SysV init sequence of the live CD, refactoring the installer backend, and laying the foundation for proper gettext localisations of our toolset, with additional efforts regarding general clean up and obsoleting the GTK+ 1.2 tools, while shipping kernel 2.6.22.3-rc1, using libata for most PATA chipsets, additional support for Intel IPW3945/4965, Realtek RTL8187 and RT2x00 wireless LAN devices has been added.

Doxygen project is a documentation system for C++, C, Java, Objective-C, IDL (Corba and Microsoft flavors) and to some extent PHP, C#, and D.
Main features:
- It can generate an on-line documentation browser (in HTML) and/or an off-line reference manual (in $mbox{LaTeX}$ ) from a set of documented source files. There is also support for generating output in RTF (MS-Word), PostScript, hyperlinked PDF, compressed HTML, and Unix man pages.The documentation is extracted directly from the sources, which makes it much easier to keep the documentation consistent with the source code.
- You can configure doxygen to extract the code structure from undocumented source files. This is very useful to quickly find your way in large source distributions. You can also visualize the relations between the various elements by means of include dependency graphs, inheritance diagrams, and collaboration diagrams, which are all generated automatically.
- You can even `abuse doxygen for creating normal documentation (as I did for this manual).
Doxygen is developed under Linux and Mac OS X, but is set-up to be highly portable. As a result, it runs on most other Unix flavors as well.

The Linux SMP kernel uses spinlocks to protect data structures from concurrent, potentially conflicting accesses. Linux Kernel Spinlock Metering is a kernel patch that allows you to build an i386, ia64, Alpha, Sparc64, or mips64 kernel that can perform simple "metering" (record-keeping) of spinlock usage. Also available is source for an associated new command, lockstat, that is used to instruct the kernel to turn this lock metering on or off, and to retrieve the metering data from the kernel and display it in a human-readable format.

Data displayed includes the number of lock attempts, per-spinlock per-caller, the number of those attempts that were immediately successful vs. those that required the attempting locker to wait for the current lock-holder to release; the mean and max hold-time, and the mean, max, and cumulative wait-time. Whenever possible, the locking caller and the spinlocks are identified by their symbolic names, not by their virtual addresses.

Various patch sets are available. Version 1.1.4 patches the 2.2.14 kernel and reflects a relatively old flavor of Lockmeter. Version 1.4.11 patches the 2.4.16, 2.4.17, 2.5.3, and 2.5.5 kernels, and the previous release v1.4.9 patches various other releases of the 2.4.x kernel. This version 1.4 supports i386, alpha, ia64, mips64, and sparc64. The most recent version 1.5 is available as a patch against the 2.4.18 and various 2.5.x kernels, and it additionally supports mips (32-bit mips). Each is approximately 22 KB in gziped size. (Patches against a few older kernel versions are also available in the old subdirectory.) After applying the appropriate patch, make oldconfig presents a new Kernel lock metering option in the Kernel hacking subsection -- although only if CONFIG_SMP (Symmetric multi-processing support) has been enabled. The spinlock metering code is compiled into the kernel only when this new option is turned on.

Compiling the spinlock metering code into the kernel does not materially affect the kernel size because the additional code is roughly compensated for by the shrinking effect of the normally in-line locking routines now becoming procedure calls. A metering-capable kernel (i.e., with the patch applied, but data collection turned off) is negligibly slower than a non-metering-capable kernel, though a metering-capable kernel does slow when the metering data collection is turned on using the lockstat command (typically 8% for a systime==25% workload). Care has been taken to minimize performance degradation, and further improvements are in progress.

The lockstat command must also be downloaded, compiled, and installed. lockstat is a privileged command that requires root access. It reads and writes to the node /proc/lockmeter to control the kernels metering as follows:

lockstat on enables the kernels metering data collection,
lockstat options displays the collected data, and
lockstat off disables the metering data collection.

Run lockstat with no arguments to see a verbose description of the command arguments and options.

When metering is enabled, count and time data is collected in malloced arrays that are private to each CPU, thereby avoiding costly cacheblock coherency operations that would otherwise be required if all CPUs updated the same count and time fields. The lockstat command accumulates and sorts the per-cpu data at display time.

Lockmetering attempts to provide both "cause" and "effect" information about spinlock usage. The "hold time" metering exposes which spinlocks are being held and for how long, identified by where they are held inside the kernel. The "wait-time" metering exposes the effects of these hold-times when multiple CPUs concurrently contend for the same lock.

Cook is a tool for constructing files. Cook project is given a set of files to create, and recipes of how to create them. In any non-trivial program there will be prerequisites to performing the actions necessary to creating any file, such as include files. Cook provides a mechanism to define these.
When a program is being developed or maintained, the programmer will typically change one file of several which comprise the program. Cook examines the last-modified times of the files to see when the prerequisites of a file have changed, implying that the file needs to be recreated as it is logically out of date.
Cook also provides a facility for implicit recipes, allowing users to specify how to form a file with a given suffix from a file with a different suffix. For example, to create filename.o from filename.c
Cook is a replacement for the traditional make(1) tool.
There is a make2cook utility included in the distribution to help convert makefiles into cookbooks.
Cook is more powerful than the traditional make tool.
Cook has true variables, not simple macros.
Cook has a simple but powerful string-based description language with many built-in functions. This allows sophisticated filename specification and manipulation without loss of readability or performance.
Cook has user defined functions.
Cook can build in parallel.
Cook is able to build your project with multiple parallel threads, with support for rules which must be single threaded. It is possible to distribute parallel builds over your LAN, allowing you to turn your network into a virtual parallel build engine.
Cook can distribute builds across your LAN.
Cook is able to use fingerprints to supplement file modification times. This allows build optimization without contorted rules.
Cook can be configured with an explicit list of primary source files. This allow the dependency graph to be constructed faster by not going down dead ends, and also allows better error messages when the graph cant be constructed. This requires an accurate source file manifest.
In addition to walking the dependency graph, Cook can turn the input rules into a shell script, or a web page.
Cook runs on almost any flavor of UNIX. The source distribution is self configuring using a GNU Autoconf generated configure script.
Cook has special cascade dependencies, allowing powerful include dependency specification, amongst other things.
Enhancements:
- Some build and portability fixes were made.
- The license was changed to the GPLv3.

Gobby project is a collaborative text editor.
Gobby is a free collaborative editor based on libobby, a library which provides synced document buffers.
It supports multiple documents in one session and a multi-user chat. It runs on Microsoft Windows, Mac OS X, Linux and other Unix-like platforms.
It uses GTK+ 2.6 as its windowing toolkit and thus integrates nicely into the GNOME desktop environment.
Main features:
- Realtime Collaboration
- Each user has its own colour (changeable) to be identified by others
- IRC-like Chat for communicating with your partners while coding
- Sidebar with all the others having joined the session
- Syntax highlighting for most programming languages
- Session password protection
- Multiple documents in one Session
- Dragndrop of documents into gobby
- Document synchronisation on request
- Zeroconf support
- Unicode support
- Cross-platform: It runs on Microsoft Windows, Linux, Mac OS X and other flavours of UN*X
- Gobby is free software and licenced under the GPL 2

Event is an Event loop processing.

SYNOPSIS

use Event qw(loop unloop);

# initialize application
Event->flavor(attribute => value, ...);

my $ret = loop();

# and some callback will call
unloop(ok);

The Event module provide a central facility to watch for various types of events and invoke a callback when these events occur. The idea is to delay the handling of events so that they may be dispatched in priority order when it is safe for callbacks to execute.

Events (in the ordinary sense of the word) are detected by watchers, which reify them as events (in the special Event module sense). For clarity, the former type of events may be called "source events", and the latter "target events". Source events, such as signals arriving, happen whether or not they are being watched. If a source event occurs which a watcher is actively watching then the watcher generates a corresponding target event. Target events are only created by watchers. If several watchers are interested in the same source event then each will generate their own target event. Hence, any particular source event may result in zero, one, two, or any number of target events: the same as the number of watchers which were actively watching for it.

Target events are queued to be processed in priority order (priority being determined by the creating watcher) and in FIFO order among events of the same priority. Queued ("pending") events can, in some cases, be cancelled before being processed. A queued event is processed by being passed to the callback function (or method on a particular object or class) which was specified to the watcher.

A watcher, once created, operates autonomously without the Event user having to retain any reference to it. However, keeping a reference makes it possible to modify most of the watchers characteristics. A watcher can be switched between active and inactive states. When inactive, it does not generate target events.

Some types of source event are not reified as target events immediately. Signals received, for example, are counted initially. The counted signals are reified at certain execution points. Hence, signal events may be processed out of order, and if handled carelessly, on the wrong side of a state change in event handling. A useful way to view this is that occurrence of the source event is not actually the arrival of the signal but is triggered by the counting of the signal.
Reification can be forced when necessary. The schedule on which some other events are created is non-obvious. This is especially the case with watchers that watch for a condition rather than an event. In some cases, target events are generated on a schedule that depends on the operation of the event loop.