php-memoize is a PHP extension which transparently caches PHP functions, much
like Perl's Memoize module.
It comes with the following storage modules which can be enabled at compile
time:
- memory: Simple per-request module with no dependencies.
Since this is a per-request cache, neither TTLs specified in the
`memoize()` call or `memoize.default_ttl` are used.
- memcached: Uses libmemcached or the memcached PHP extension
The Xdebug extension helps you debugging your script by providing a lot of
valuable debug information. The debug information that Xdebug can provide
includes the following:
* stack and function traces in error messages with:
o full parameter display for user defined functions
o function name, file name and line indications
o support for member functions
* memory allocation
* protection for infinite recursions
Xdebug also provides:
* profiling information for PHP scripts
* script execution analysis
* capabilities to debug your scripts interactively with a debug client
Log4J, a fast and flexible logging library for Java.
Log4J is an open source library based on the work of many authors.
It allows the developer to control which log statements are output
with arbitrary granularity. It is fully configurable at runtime
using external configuration files. Best of all, Log4J has a gentle
learning curve. Beware: judging from user feedback, it is also quite
addictive.
Netli Configuration library (NCNF) is the module for C applications to
efficiently read and use the configuration file contents. NCNF converts
the on-disk configuration file structure to the memory-based tree of
configuration objects. Basic NCNF API does not make a distinction
between different types of configuration objects. However, there are a
couple of additional functions present to ease the use of certain types
of configuration objects.
What is it?
-----------
NAnt is a .NET-based build tool. In theory it is kind of like make without
make's wrinkles. In practice it's a lot like Ant.
If you are not familiar with Jakarta Ant, you can get more information at the
Ant project web site (http://ant.apache.org/).
Why NAnt?
---------
Because Ant was too Java-specific.
Because Ant needed the Java runtime. NAnt only needs the .NET or Mono runtime.
This OCaml-library consists of a set of modules which implement
automatically resizing (= reallocating) data structures that consume
a contiguous part of memory. This allows appending and removing of
elements to/from arrays (both boxed and unboxed), strings (-> buffers),
bit strings and weak arrays while still maintaining fast constant-time
access to elements.
There are also functors that allow the generation of similar modules
which use different reallocation strategies.
Parmap is a minimalistic library allowing to exploit multicore
architecture for OCaml programs with minimal modifications: if you want
to use your many cores to accelerate an operation which happens to be a
map, fold or map/fold (map-reduce), just use Parmap's parmap, parfold
and parmapfold primitives in place of the standard List.map and friends,
and specify the number of subprocesses to use by the optional parameter
~ncores.
Algorithm::Dependency is a framework for creating simple read-only
dependency hierarchies, where you have a set of items that rely on other
items in the set, and require actions on them as well.
Despite the most visible of these being software installation systems like
the CPAN installer, or debian apt-get, they are useful in other
situations. This module intentionally uses implementation-neutral words,
to avoid confusion.
B::Deobfuscate is a backend module for the Perl compiler that generates perl
source code, based on the internal compiled structure that perl itself creates
after parsing a program. It adds symbol renaming functions to the B::Deparse
module. An obfuscated program is already parsed and interpreted correctly by
the B::Deparse program. Unfortunately, if the obfuscation involved variable
renaming then the resulting program also has obfuscated symbols.
This module, when inherited by a package, allows that package's class to define
attribute handler subroutines for specific attributes. Variables and
subroutines subsequently defined in that package, or in packages derived from
that package may be given attributes with the same names as the attribute
handler subroutines, which will then be called in one of the compilation phases
(i.e. in a BEGIN, CHECK, INIT, run-time, or END block).