Free robin williams golf software for linux

ctrlxmms XMMS plugin is a small Perl script designed to increase the useability of XMMS. With it, you can use most of the common GUI functions of XMMS from the CLI.

You also have a few handy commands which are not available from the GUI. Together with lirc and a remote (eg. Anir Multimedia Magic), this is a wonderful tool.

Xyria:DNSd is an high performance DNS server that supports only the most important features and resource records while being extremely fast and secure.
Xyria:DNSd peoject also supports round-robin load balancing.
Main features:
- extemely fast implementation (main target)
- very secure
- ip-address based listen()ing
- supporting IPv6 addresses and resource records
- load ballancing via round robbin
- running under an low-privileged UID & GID
- running under little endian systems: (at least) Linux, Solaris, OpenBSD
- nice configuration syntax/easy to configure
- DNSd able to forward querys
- DNSd can run as caching only-server
Enhancements:
- The database was modified. Now DNSd uses a hashed array of pointers to binary trees including single linked lists for double valued hashes.
- It sorts the zones (by TTL) by itself (the admin doesnt has to care in which order he has to place the zones in the config file).
- Some code cleanup and a small bugfix are also included.

L4ip is a daemon that extends IPFilters simple round-robin L4 load balancing with health checks. It takes care of monitoring and dynamically adding and removing ipnat rules in the kernel.
L4ip fully supports UDP, TCP, and system()-style executions for health checks, including send/expect scripts, SSL connections, and much more.
Main features:
- Define as many clusters, with as many members as you need.
- Automatically adds and removes "ipnat" rules as needed.
- Flexible health check support, tcp-open, tcp-close, udp-open, udp-close, system.
- Simple scripting available for health checks in send/expect syntax with fnmatch pattern comparison
- Binary protocol supported in url-encoding style syntax (eg %0D)
- system() like execution of external commands available. (spawn your own health-check testers)
- Reload and restart leaving last-known-state available for less service impact.
- SSL supported for TCP testers.
- Optional IPF rules to sense RST return-packets for faster failure detection.
Enhancements:
- Solaris SMF example files were added along with a "proxy" command for protocols that need it, such as FTP and IPSec.

Module::Build is a Perl module for build and install Perl modules.

SYNOPSIS

Standard process for building & installing modules:
perl Build.PL
./Build
./Build test
./Build install
Or, if youre on a platform (like DOS or Windows) that doesnt require the "./" notation, you can do this:
perl Build.PL
Build
Build test
Build install

Module::Build is a system for building, testing, and installing Perl modules. It is meant to be an alternative to ExtUtils::MakeMaker. Developers may alter the behavior of the module through subclassing in a much more straightforward way than with MakeMaker.

It also does not require a make on your system - most of the Module::Build code is pure-perl and written in a very cross-platform way. In fact, you dont even need a shell, so even platforms like MacOS (traditional) can use it fairly easily. Its only prerequisites are modules that are included with perl 5.6.0, and it works fine on perl 5.005 if you can install a few additional modules.

File::Spec::Link is a Perl extension for reading and resolving symbolic links.

SYNOPSIS

use File::Spec::Link;
my $file = File::Spec::Link->linked($link);
my $file = File::Spec::Link->resolve($link);
my $dirname = File::Spec::Link->chopfile($file);
my $newname = File::Spec::Link->relative_to_file($path, $link);

my $realname = File::Spec::Link->full_resolve($file);
my $realname = File::Spec::Link->resolve_path($file);
my $realname = File::Spec::Link->resolve_all($file);

File::Spec::Link is an extension to File::Spec, adding methods for resolving symbolic links; it was created to implement File::Copy::Link.

linked($link)

Returns the filename linked to by $link: by readlinking $link, and resolving that path relative to the directory of $link.

resolve($link)

Returns the non-link ultimately linked to by $link, by repeatedly calling linked. Returns undef if the link can not be resolved.

chopfile($file)

Returns the directory of $file, by splitting the path of $file and returning (the volumne and) directory parts.

relative_to_file($path, $file)

Returns the path of $path relative to the directory of file $file. If $path is absolute, just returns $path.

resolve_all($file)

Returns the filename of $file with all links in the path resolved, wihout using Cwd.

full_resolve($file)

Returns the filename of $file with all links in the path resolved.
This sub tries to use Cwd::abs_path via ->resolve_path.

resolve_path($file)

Returns the filename of $file with all links in the path resolved.

This sub uses Cwd::abs_path and is independent of the rest of File::Spec::Link.

Module::Build::Authoring are authoring Module::Build modules.

When creating a Build.PL script for a module, something like the following code will typically be used:

use Module::Build;
my $build = Module::Build->new
(
module_name => Foo::Bar,
license => perl,
requires => {
perl => 5.6.1,
Some::Module => 1.23,
Other::Module => >= 1.2, != 1.5, < 2.0,
},
);
$build->create_build_script;

A simple module could get away with something as short as this for its Build.PL script:

use Module::Build;
Module::Build->new(
module_name => Foo::Bar,
license => perl,
)->create_build_script;

The model used by Module::Build is a lot like the MakeMaker metaphor, with the following correspondences:

In Module::Build In ExtUtils::MakeMaker
--------------------------- ------------------------
Build.PL (initial script) Makefile.PL (initial script)
Build (a short perl script) Makefile (a long Makefile)
_build/ (saved state info) various config text in the Makefile

Any customization can be done simply by subclassing Module::Build and adding a method called (for example) ACTION_test, overriding the default test action. You could also add a method called ACTION_whatever, and then you could perform the action Build whatever.
For information on providing compatibility with ExtUtils::MakeMaker, see Module::Build::Compat and http://www.makemaker.org/wiki/index.cgi?ModuleBuildConversionGuide.

GNU/Fiwix is an operating system kernel based on the architecture of UNIX and Linux.
GNU/Fiwix operating system is designed exclusively for educational purposes, so the kernel code is kept as simple as possible for the benefit of students.
It runs on the 32-bit x86 hardware platform, and is compatible with existing GNU applications.
Main features:
- GRUB Multiboot Specification compliant.
- Fully 32bit protected mode non-preemptive kernel.
- For Intel 80386 processors or higher.
- Real multitask (kernel tasks at level 0).
- Protected task environment (independent memory address per process).
- Interrupt and exception handling.
- Semaphores.
- Signals.
- Virtual memory management up to 4GB.
- Demand paging with Copy-On-Write feature.
- Linux system calls compatibility.
- Linux ELF-386 executable format support (statically and dynamically linked).
- Round-Robin based scheduler algorithm (without priorities).
- VFS with Linux EXT2 filesystem support (read only).
- Keyboard driver with spanish/catalan and english keymaps (hard coded).
- Floppy disk device driver and DMA management.
- IDE/ATA hard disk device driver (read only).