Codeville is a distributed Version Control System. It began with a novel
idea for a merge algorithm, and has grown from there. It is designed to
be easy to use, and scale from small personal projects, to very large
distributed ones. If you'd like to know why there's need for new merge
algorithms, consider what the lead monotone developer had to say:
http://article.gmane.org/gmane.comp.version-control.monotone.devel/3264
Codeville works by creating an identifier for each change that is done,
and remembering the list of all changes which have been applied to each
file, and the last change which modified each line in each file. When
there's a conflict, it checks to see if one of the two sides has already
been applied to the other one, and if so, makes the other side win
automatically. When there's a non automatically mergeable version conflict,
Codeville behaves in almost exactly the same way as CVS.
The definition of conform is "Adapt or conform oneself to new or
different conditions". As this library is used to adapt your
application to its deployed environment, I think it's rather fitting.
It's also a play on the word configuration, and the fact that Conform
uses an init-style configuration, maintained in a .conf file.
Conform is a library for Elixir applications. Its original intended
use is in exrm as means of providing a simplified configuration
file for deployed releases, but is flexible enough to work for any
use case where you want init-style configuration translated to
Elixir/Erlang terms. It is inspired directly by basho/cuttlefish,
and in fact uses its .conf parser. Beyond that, you can look at
conform as a reduced (but growing!) implementation of cuttlefish
in Elixir.
IPython is a free software project which tries to:
1. Provide an interactive shell superior to Python's
default. IPython has many features for object introspection,
system shell access, and its own special command system for
adding functionality when working interactively. It tries to be
a very efficient environment both for Python code development
and for exploration of problems using Python objects (in
situations like data analysis).
2. Serve as an embeddable, ready to use interpreter for your own
programs. IPython can be started with a single call from inside
another program, providing access to the current namespace. This
can be very useful both for debugging purposes and for
situations where a blend of batch-processing and interactive
exploration are needed.
3. Offer a flexible framework which can be used as the base
environment for other systems with Python as the underlying
language. Specifically scientific environments like Mathematica,
IDL and Mathcad inspired its design, but similar ideas can be
useful in many fields.
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.
Gitolite is an access control layer on top of git, which allows access control
down to the branch level, including specifying who can and cannot rewind a
given branch.
Gitolite lets you use a single user on a server to host many git repositories
and provide access to many developers, without having to give them real
userids on or shell access to the server. Authentication is most commonly done
using sshd, but you can also use httpd if you prefer.
Gitolite can restrict who can read from (clone/fetch) or write to (push) a
repository. It can also restrict who can push to what branch or tag, which is
very important in a corporate environment.
Developing and debugging UIs can be a pain. When something
goes wrong, it's not always obvious why. You can waste hours
writing logging statements only to find out that a widget is
in the wrong container, or an attribute wasn't set correctly.
Developing isn't much better either. Ever spend time writing
temporary code just to test a new feature, code you know you're
going to throw away in an hour, and yet you end up spending the
next 20 minutes debugging your temporary code? Sucks, doesn't
it?
What your program really needs is a good Parasite infestation.
Parasite is a debugging and development tool that runs inside
your GTK+ application's process. It can inspect your application,
giving you detailed information on your UI, such as the hierarchy,
X window IDs, widget properties, and more. You can modify properties
on the fly in order to experiment with the look of your UI.
convertible provides a typeclass with a single function that is designed
to help convert between different types: numeric values, dates and times,
and the like. The conversions perform bounds checking and return a pure
Either value. This means that you need not remember which specific function
performs the conversion you desire. Also included in the package are
optional instances that provide conversion for various numeric and time
types, as well as utilities for writing your own instances. Finally, there
is a function that will raise an exception on bounds-checking violation,
or return a bare value otherwise, implemented in terms of the safer function
described above. Convertible is also used by HDBC 2.0 for handling
marshalling of data to and from databases. Convertible is backed by an
extensive test suite and passes tests on GHC and Hugs.
Shake is a Haskell library for writing build systems - designed as a
replacement for make. To use Shake the user writes a Haskell program that
imports the Shake library, defines some build rules, and calls shake.
Thanks to do notation and infix operators, a simple Shake program is not
too dissimilar from a simple Makefile. However, as build systems get more
complex, Shake is able to take advantage of the excellent abstraction
facilities offered by Haskell and easily support much larger projects.
The Shake library provides all the standard features available in other
build systems, including automatic parallelism and minimal rebuilds. Shake
provides highly accurate dependency tracking, including seamless support
for generated files, and dependencies on system information (e.g. compiler
version).
libarena is a custom memory allocator interface and implementation. Four
allocators are provided: flat LIFO arena allocator, object pool allocator
and two malloc(3) wrappers: one which returns the pointers unadulterated
and one which obeys the requested, arbitrary alignment. These can be used
directly, or through their exported prototype interfaces.
libarena is meant to provide a baseline interface so allocators can be
stacked, and to provide a simple and well defined interface for libraries
and applications without becoming mired in features or capabilities. It is
not meant to restrict or confine what custom allocators can actually
accomplish. For instance, the included pool and arena allocators include a
suite of string utilities which aren't available in the generic exportable
interface. Note that these string utilities are built upon a generic
interface (see util.h) which can take the prototypical allocation context,
so they are also available to any 3rd party compatible allocators.
Libdict is a compact, ANSI C library which provides access to a set of
generic and flexible ``dictionary'' data structures. All algorithms
used in libdict have been optimized, and, with one very small exception,
are not recursive but iterative. It was written by Farooq Mela, and is
released under a BSD style licence.
Libdict implements the following data structures: AVL Tree, Red-Black
Tree, Splay Tree, Treap, Weight-balanced tree, Path-reduction tree,
Hashtable (Chained).
These structures can be used to efficiently store and retrieve key-data
pairs. Each of these structures can be accessed using its direct API, or
it can be accessed using a dictionary abstraction. Despite it's name,
libdict can be used to store any kind of data and any kind of key (provided
it fits into a 'void' pointer on your system).