This is a small shell script intended to be used in portable Unix install
scripts for showing progress bars.
The overall goal is to write a minimally complex shell script (thus a program
that needs no compilation) that is as robust as possible to work on as many
Bourne shells and operating systems as possible, and that implements 'cat'
with an ASCII progress bar and some other nifty features.
This is pure Bourne shell code. (For sh, ash, ksh, zsh, bash, ...)
The script is mainly indented to be used in portable install scripts, where
you can use the body of the script.
This is a Perl extension to XML::Parser. It adds a new 'Style' to
XML::Parser, called 'Dom', that allows XML::Parser to build an Object
Oriented datastructure with a DOM Level 1 compliant interface.
The XML::XQL module implements the XQL (XML Query Language) proposal
submitted to the XSL Working Group in September 1998. The spec can
be found at
http://www.w3.org/TandS/QL/QL98/pp/xql.html
Most of the contents related to the XQL syntax can also be found
in the XML::XQL::Tutorial that comes with this distribution. Note
that XQL is not the same as XML-QL!
Boa is a single-tasking HTTP server. That means that unlike
traditional web servers, it does not fork for each incoming
connection, nor does it fork many copies of itself to handle multiple
connections. It internally multiplexes all of the ongoing HTTP
connections, and forks only for CGI programs (which must be separate
processes.) Preliminary tests show boa is about twice as fast as
Apache, and is capable of handling 50 hits per second on a 66 MHz '486.
The primary design goals of Boa are speed and security. Security,
in the sense of "can't be subverted by a malicious user", not "fine
grained access control and encrypted communications".
Net::Async::HTTP implements an asynchronous HTTP user agent. It sends requests
to servers, returning Future instances to yield responses when they are
received. The object supports multiple concurrent connections to servers, and
allows multiple requests in the pipeline to any one connection. Normally, only
one such object will be needed per program to support any number of requests.
As well as using futures the module also supports a callback-based interface.
Net::Async::HTTP optionally supports SSL connections, if IO::Async::SSL is
installed. If so, SSL can be requested either by passing a URI with the https
scheme, or by passing a true value as the SSL parameter.
django-reversion is an extension to the Django web framework that
provides comprehensive version control facilities:
- Roll back to any point in a model's history - an unlimited undo
facility!
- Recover deleted models - never lose data again!
- Admin integration for maximum usability.
- Group related changes into revisions that can be rolled back in a
single transaction.
- Automatically save a new version whenever your model changes using
Django's flexible signalling framework.
- Automate your revision management with easy-to-use middleware.
django-reversion can be easily added to your existing Django project
with an absolute minimum of code changes.
Dynamic programming is a simple yet powerful technique for solving optimisation
problems. When the problem at hand can be split in smaller problems, such that
the smaller solutions of an optimal solution are themselves optimal, dynamic
programming can be used to avoid re-calculating solutions to shared sub-
problems.
Simple problems are both easily specified and easily implemented, but for
complex problems translating the specification of the problem into the
implementation of the dynamic programming algorithm becomes tedious and error
prone. The goal of DPROG is to alleviate this by automatically translating the
specification of the problem into an implementation of the solution.
The DPROG language is designed to be close to the ``mathematical'' notation
used for expressing recurrences, thus making it easier to specify the problem.
Using the DPROG compiler, the manual implementation step can be completely
avoided.
Often in program logic, multiple different steps need to be taken that
are independent of each other, but their total result is needed before
the next step can be taken. In synchonous code, the usual approach is
to do them sequentially.
An asynchronous or event-based program could do this, but if each step
involves some IO idle time, better overall performance can often be
gained by running the steps in parallel. A Async::MergePoint object
can then be used to wait for all of the steps to complete, before
passing the combined result of each step on to the next stage.
This module was originally part of the IO::Async distribution, but was
removed under the inspiration of Pedro Melo's Async::Hooks
distribution, because it doesn't itself contain anything IO-specific.
MicroEMACS is a tool for creating and changing documents,
programs, and other text files. It is both relatively easy for the
novice to use, but also very powerful in the hands of an expert.
MicroEMACS can be extensively customized for the needs of the individual
user.
MicroEMACS allows several files to be edited at the same time.
The screen can be split into different windows and screens, and text may
be moved freely from one window on any screen to the next. Depending on
the type of file being edited, MicroEMACS can change how it behaves to
make editing simple. Editing standard text files, program files and
word processing documents are all possible at the same time.
There are extensive capabilities to make word processing and
editing easier. These include commands for string searching and
replacing, paragraph reformatting and deleting, automatic word wrapping,
word move and deletes, easy case controlling, and automatic word counts.
fwlogwatch is a packet filter and firewall log analyzer
General features:
- Can detect and process log entries in the following formats:
- Linux ipchains, Linux netfilter/iptables, Solaris/BSD/Irix/HP-UX
ipfilter, BSD ipfw, Cisco IOS, Cisco PIX / FWSM, NetScreen,
Windows XP firewall, Elsa Lancom router, Snort IDS
- Entries can be parsed from single, multiple and combined log files,
the parsers to be used can be selected.
- Gzip-compressed logs are supported transparently.
- Can separate recent from old entries and detects timewarps in log files.
- Can recognize 'last message repeated' entries concerning the firewall.
- Integrated resolver for protocols, services and host names.
- Can do lookups in the whois database.
- Own DNS and whois information cache for faster lookups.
- Hosts, networks, ports, chains and branches (targets) can be selected or
excluded as needed.
- Support for internationalization (available in english, german,
portuguese, simplified and traditional chinese, swedish and japanese).
CSS::Minifier removes unnecessary whitespace from CSS. The primary requirement
developing this module is to not break working stylesheets: if working CSS is in
input then working CSS is output. The Mac/Internet Explorer comment hack will be
minimized but not stripped and so will continue to function.
This module understands space, horizontal tab, new line, carriage return, and
form feed characters to be whitespace. Any other characters that may be
considered whitespace are not minimized. These other characters include
paragraph separator and vertical tab.
For static CSS files, it is recommended that you minify during the build stage
of web deployment. If you minify on-the-fly then it might be a good idea to
cache the minified file. Minifying static files on-the-fly repeatedly is
wasteful.