M.A.M.E./M.E.S.S. Catalog / Launcher II - also referred to as QMC2 - is
the successor of one of the first UNIX MAME GUI front ends available on
this planet called QMamecat (derived from MAMECAT, which was text-only).
QMamecat was based upon Qt 2; its development was frozen in 2003. QMC2
has been rebuilt from scratch as a Qt 4 project. Parts of the design and
code were inspired by its predecessor, but it's not just a remake. We
tried to make the new design as flexible as possible to minimize
dependencies from front end and CLI related MAME changes, which was a
major deficiency of QMamecat. QMC2 now uses a template based emulator
configuration scheme, which can easily be enhanced with additional
command line options (defined in an XML template file).
As a result of this flexible design, QMC2 can be used for multiple
emulators. Currently we support SDLMAME & SDLMESS on UNIX and Mac, and
the original variants of MAME & MESS on Windows.
OBApps is a graphical tool for configuring the per-application settings
(window matching) in the Openbox window manager.
OBApps uses ~/.config/openbox/rc.xml
(or the config-file Openbox was started with) by default.
You can specify another file as an argument, e.g.
obapps.py .config/openbox/myrc.xml
Enter or change the name, class, role, or type settings by clicking in their
entries in the listbox.
Using the Find button to get settings by clicking on a window changes the
settings for the CURRENTLY SELECTED item in the listbox; it does not add
a new entry unless nothing is highlighted. You'll usually want to use the New
button to create a new item first.
Blank entries for name/class/role/type are ignored. If you want any of those
fields to be stored as literally blank attributes (e.g. to match only a window
with a blank role), enter "" or '' in the field.
Changes are written to the rc.xml file only when the apply button is used.
Openbox will automatically be reconfigured when this is done.
The DBD::AnyData module provides a DBI/SQL interface to data in many formats
and from many sources.
Regardless of the format or source of the data, it may be accessed and/or
modified using all standard DBI methods and a subset of SQL syntax.
In addition to standard database access to files, the module also supports
in-memory tables which allow you to create temporary views; to combine data
from a number of sources; to quickly prototype database systems; and to display
or save the data in any of the supported formats (e.g. to display data in a CSV
file as an HTML table). These in-memory tables can be created from any
combination of DBI databases or files of any format. They may also be created
from perl data structures which means it's possible to quickly prototype a
database system without any file access or rdbms backend.
The module also supports converting files between any of the supported formats
(e.g. save selected data from MySQL or Oracle to an XML file).
CAL is a nicely-enhanced version of the Unix `cal' command.
Features:
* Hilights today's date when displaying a monthly calendar.
* Displays an optional user-definable list of `special day'
descriptions (like appointments) to the right of the monthly
calendar display. Cal can be set optionally to ignore appointments
older than the current day. Next month's appointments are shown if
there is room to do so. Multiple appointment data files may also
be specified on the commandline.
* You can specify your own appointment and color definition files on the
commandline, or use the defaults.
* Date descriptions can display "years since" a given year, useful for
birthdays and anniversaries.
* Completely configurable colors -- eight separate color attributes.
* No ANSI driver needed for colors, and the output may be redirected
anywhere, just like the Unix version. However, ANSI color control may
be enabled (e.g. for Unix) with a #define in the source code.
* Commandline-compatible with Unix `cal' command, but with several
enhanced switch settings.
Requests, bug reports, suggestions, donations, proposals for
contract work, and so forth may be sent to:
Attn: Alex Matulich
Unicorn Research Corporation
4621 N. Landmark Drive
Orlando, FL 32817-1235
USA
407-657-4974 FAX 407-657-6149
or send e-mail to matulich_a@seaa.navsea.navy.mil.
Pycerberus is a framework to check user data thoroughly so that you can
protect your application from malicious (or just garbled) input data.
* Remove stupid code which converts input values: After values are
validated, you can work with real Python types instead of strings -
e.g. 42 instead of '42', convert database IDs to model objects
transparently.
* Implement custom validation rules: Writing custom validators is
straightforward, everything is well documented and pycerberus only
uses very little Python magic.
* Focus on your value-adding application code: Save time by
implementing every input validation rule only once, but 100% right
instead of implementing a dozen different half-baked solutions.
* Ready for global business: i18n support (based on GNU gettext) is
built in, adding custom translations is easy.
* Tune it for your needs: You can implement custom behavior in your
validators, e.g. fetch translations from a database instead of using
gettext or define custom translations for built-in validators.
* Use it wherever you like: pycerberus is used in a SMTP server, trac
macros as well as web applications - there are no dependecies on a
specific context like web development.
The snow package provides support for simple parallel computing on a
network of workstations using R. A master R process calls makeCluster
to start a cluster of worker processes; the master process then uses
functions such as clusterCall and clusterApply to execute R code on
the worker processes and collect and return the results on the master.
This framework supports many forms of "embarrassingly parallel"
computations.
Snow can use one of four communications mechanisms: sockets, PVM, MPI,
or NetWorkSpaces (NWS). NWS support was provided by Steve Weston.
PVM clusters use the rpvm package; MPI clusters use package Rmpi; NWS
clusters use package nws. If pvm is used, then pvm must be started,
either using a pvm console (e.g the pvm text console or the graphical
xpvm console, both available with pvm) or from R using functions
provided by rpvm. Similarly, LAM-MPI must be started, e.g. using
lamboot, for MPI clusters that use Rmpi and LAM-MPI. If NWS is used,
the NetWorkSpaces server must be running. SOCK clusters are the
easiest approach for using snow on a single multi-core computer as
they require no additional software.
Spamd is a fake sendmail(8)-like daemon which rejects false mail. It is
designed to be very efficient so that it does not slow down the receiving
machine.
spamd considers sending hosts to be of three types:
blacklisted hosts are redirected to spamd and tarpitted i.e. they are
communicated with very slowly to consume the sender's resources. Mail is
rejected with either a 450 or 550 error message. A blacklisted host will not
be allowed to talk to a real mail server.
whitelisted hosts do not talk to spamd. Their connections are instead sent to
a real mail server, such as sendmail(8).
greylisted hosts are redirected to spamd, but spamd has not yet decided if
they are likely spammers. They are given a temporary failure message by spamd
when they try to deliver mail.
ABACUS is a software system written in C++ that provides a framework for the
implementation of branch-and-bound algorithms using linear programming
relaxations. Cutting planes or columns can be generated dynamically
(branch-and-cut, branch-and-price, branch-and-cut-and-price).
ABACUS allows the software developer to concentrate merely on the problem
specific parts, i.e., the separation of cutting planes, column generation, and
primal heuristics. ABACUS supports the Open Solver Interface (Osi) developed
by the COIN-OR (COmputational INfrastructure for Operations Research) project
which means that every solver supported by OSI can be used to solve the
relaxations.
Moreover, ABACUS provides a variety of general algorithmic concepts, e.g., a
list of different enumeration and branching strategies from which the best
alternative for the user's application can be chosen.
Finally, ABACUS provides many basic data structures and useful tools for the
implementation of such algorithms. It is designed both for general mixed
integer optimization problems and for combinatorial optimization problems. It
unifies cutting plane and column generation within one algorithm framework.
Simple reuse of code and the design of abstract data structures and algorithms
are met by object oriented programming modules.
Zxfer is a fork of zfs-replicate. It allows the easy and reliable backup,
restore or transfer of ZFS filesystems, either locally or remotely.
Some of the features zxfer has:
* Written in sh with only one dependency, rsync. Rsync mode is not used
in a typical restore, hence in that situation all you need is the
zxfer script, your backup and an install CD/DVD.
* Reliability is first priority - the only methods of transfer allowed
are those that checksum/hash the transferred data.
* Transfer to or from a remote host via ssh.
* Recursive and incremental transfer of filesystems (via snapshots).
* Transfer properties and sources of those properties (e.g. local or
inherited).
* Override properties in the transfer, e.g. for archival purposes
it is useful to override "copies" and "compression".
* Create all filesystems on the destination as necessary.
* A comprehensive man page with examples.
* Can be set to beep on error or when done, useful for long transfers.
* Features an rsync mode for when two different snapshotting regimes are on
source and destination, and zfs send/receive won't work.
LICENSE: BSD
This module implements asynchronous I/O using whatever means your
operating system supports.
Asynchronous means that operations that can normally block your
program (e.g. reading from disk) will be done asynchronously: the
operation will still block, but you can do something else in the
meantime. This is extremely useful for programs that need to stay
interactive even when doing heavy I/O (GUI programs, high performance
network servers etc.), but can also be used to easily do operations in
parallel that are normally done sequentially, e.g. stat'ing many files,
which is much faster on a RAID volume or over NFS when you do a number
of stat operations concurrently.
While most of this works on all types of file descriptors (for example
sockets), using these functions on file descriptors that support
nonblocking operation (again, sockets, pipes etc.) is very inefficient
or might not work (aio_read fails on sockets/pipes/fifos). Use an
event loop for that (such as the Event module): IO::AIO will naturally
fit into such an event loop itself.