Free for 15 software for linux

jac is a Cd-Player which runs under Linux (but I hope to port it to other Unix-like platform). Its birth is due to my need of a command line cd player, and now it offers many features (including the "exclusive" crazy-playing mode) and also a small text-console from which you can set any option, play the cd in the way you want etc.
jac has support for many languages but at this time only Italian and English languages are available for use (Im looking for someone who want to write some translations). jac can also download Cd and track information from CDDB and from CdIndex A FAQ PAGE is available (but is obsolete).
Enhancements:
- Readline and history support in console
- Short and long option support
- Configuration file update for CD default option
- Cdrom and mixer device can be set from command line overriding configuration file
- Error description for CDDB and CDIndex
- MAN page
- Command implementation in console
- Bug fixing

XV Jumbo Patches package contains a pair of aggregate patches against XV 3.10a, which was last released in December 1994. The first jumbo patch incorporates roughly two dozen bugfixes.

The second patch encompasses almost as many enhancements, including support for additional image formats like PNG, PhotoCD, and PDF; performance improvements; and new features such as mouse-wheel support, alpha blending against a background color, and improved dithering for 15/16-bit displays.

All patches available from the official XV site are included, as well as numerous other patches from around the world.

Statistics::SPC is a Perl module with calculations for Stastical Process Control (SPC).

Creates thresholds based on the variability of all data, # of samples not meeting spec, and variablity within sample sets, all from training data.
Note: this is only accurate for data which is normally distributed when the process is under control

Recommended usage: at least 15 sample sets, w/ sample size >=2 (5 is good) This module is fudged to work for sample size 1, but its a better idea to use >= 2

Important: the closer the process your are monitoring to how you would like it to be running (steady state), the better the calculated control limits will be.
Example: we take 5 recordings of the CPU utilization at random intervals over the course of a minute. We do this for 15 minutes, keeping all fifteen samples. Using this will be able to tell whether or not CPU use is in steady state.

SYNOPSIS

my $spc = new Statistics::SPC;
$spc->n(5) # set the number of samples per set
$spc->Uspec(.50); # CPU should not be above 50% utilization
$spc->Lspec(.05); # CPU should not be below 5%
# (0 is boring in an example)

# Now feed training data into our object
$return = $spc->history($history); # "train the system";
# $history is ref to 2d array;
# $return > 1 means process not likely to
# meet the constraints of your specified
# upper and lower bounds

# now check to see if the the latest sample of CPU util indicates
# CPU utilization was under control during the time of the sample

$return = $spc->test($data); # check one sample of size n
# $return < 0 there is something wrong with your data
# $return == 0 the sample is "in control"
# $return > 0 there are $return problems with the sample set

Kobo Deluxe is a port of XKobo to SDL, with considerable enhancements.
Kobo Deluxe is a port of XKobo to SDL. XKobo itself is a descendant of Namcos old Bosconian, which can be seen as part of the Galaxian/Galaga family of space shooters.
In both XKobo and Kobo Deluxe, you fly a ship around in 2D space, destroying other ships, dodging bullets, and destroying massive space platforms by shooting their cores.
There are literally hundreds of levels, and each level is different every time you play--the platforms are randomly generated. Kobo Deluxe adds sound, better graphics, and much more to the original game.
Main features:
- Fast paced retro arcade style game play
- Smooth, high speed 8-way scrolling
- Very simple controls - the game is about speed and strategy
- 17 different enemies; fighters, kamikaze attackers, proxy bombs and more
- 50 maps, each with its own feel and strategies to figure out
- Maps are built as you enter them - each game is unique!
- Beat the 50 maps - and get a new wave of even more aggressive enemies
- Music and sound effects with real time reverberation
- Structured audio technology - hi-fi sound in a tiny download
- OpenGL support for extremely fast and smooth animation
- High resolution support up to 2048x1536 - five types of scaling
- Supports any display color depth - dithering for 15 and 16 bpp
- Supports control by keyboard, mouse or joystick
- Runs on pretty much any hardware and operating system
- All code and data is Free! Source code available. (GPL or LGPL)

ExtUtils::F77 is a simple Perl interface to F77 libs.

This module tries to figure out how to link C programs with Fortran subroutines on your system. Basically one must add a list of Fortran runtime libraries. The problem is their location and name varies with each OS/compiler combination!
This module tries to implement a simple rule-of-thumb database for various flavours of UNIX systems.

A simple self-documenting Perl database of knowledge/code for figuring out how to link for various combinations of OS and compiler is embedded in the modules Perl code. Please help save the world by sending database entries for your system to kgb@aaoepp.aao.gov.au

The library list which the module returns can be explicitly overridden by setting the environment variable F77LIBS, e.g.

% setenv F77LIBS "-lfoo -lbar"
% perl Makefile.PL
...

SYNOPSIS

use ExtUtils::F77; # Automatic guess
use ExtUtils::F77 qw(sunos); # Specify system
use ExtUtils::F77 qw(linux g77); # Specify system and compiler
$fortranlibs = ExtUtils::F77->runtime;

METHODS

The following methods are provided:

runtime

Returns a list of F77 runtime libraries.

$fortranlibs = ExtUtils::F77->runtime;

runtimeok

Returns TRUE only if runtime libraries have been found successfully.

trail_

Returns true if F77 names have trailing underscores.

compiler

Returns command to execute the compiler (e.g. f77).

cflags

Returns compiler flags.

testcompiler

Test to see if compiler actually works.

More methods will probably be added in the future.

WWW::Babelfish is a Perl extension for translation via Babelfish or Google.

SYNOPSIS

use WWW::Babelfish;
$obj = new WWW::Babelfish( service => Babelfish, agent => Mozilla/8.0, proxy => myproxy );
die( "Babelfish server unavailablen" ) unless defined($obj);

$french_text = $obj->translate( source => English,
destination => French,
text => My hovercraft is full of eels,
delimiter => "nt",
ofh => *STDOUT );
die("Could not translate: " . $obj->error) unless defined($french_text);

@languages = $obj->languages;

Perl interface to the WWW babelfish translation server.

Curses is a terminal screen handling and optimization.

SYNOPSIS

use Curses;

initscr;
...
endwin;


Curses::supports_function($function);
Curses::supports_contsant($constant);

Curses is the interface between Perl and your systems curses(3) library. For descriptions on the usage of a given function, variable, or constant, consult your systems documentation, as such information invariably varies (:-) between different curses(3) libraries and operating systems. This document describes the interface itself, and assumes that you already know how your systems curses(3) library works.
Unified Functions
Many curses(3) functions have variants starting with the prefixes w-, mv-, and/or wmv-. These variants differ only in the explicit addition of a window, or by the addition of two coordinates that are used to move the cursor first. For example, addch() has three other variants: waddch(), mvaddch(), and mvwaddch(). The variants arent very interesting; in fact, we could roll all of the variants into original function by allowing a variable number of arguments and analyzing the argument list for which variant the user wanted to call.
Unfortunately, curses(3) predates varargs(3), so in C we were stuck with all the variants. However, Curses is a Perl interface, so we are free to "unify" these variants into one function. The section "Supported Functions" below lists all curses(3) function supported by Curses, along with a column listing if it is unified. If so, it takes a varying number of arguments as follows:
function( [win], [y, x], args );
win is an optional window argument, defaulting to stdscr if not specified.
y, x is an optional coordinate pair used to move the cursor, defaulting to no move if not specified.
args are the required arguments of the function. These are the arguments you would specify if you were just calling the base function and not any of the variants.
This makes the variants obsolete, since their functionality has been merged into a single function, so Curses does not define them by default. You can still get them if you want, by setting the variable $Curses::OldCurses to a non-zero value before using the Curses package. See "Perl 4.X cursperl Compatibility" for an example of this.

Objects

Objects are supported. Example:
$win = new Curses;
$win->addstr(10, 10, foo);
$win->refresh;
...

Any function that has been marked as unified (see "Supported Functions" below and "Unified Functions" above) can be called as a method for a Curses object.
Do not use initscr() if using objects, as the first call to get a new Curses will do it for you.

Security Concerns

It has always been the case with the curses functions, but please note that the following functions:

getstr() (and optional wgetstr(), mvgetstr(), and mvwgetstr())
inchstr() (and optional winchstr(), mvinchstr(), and mvwinchstr())
instr() (and optional winstr(), mvinstr(), and mvwinstr())

are subject to buffer overflow attack. This is because you pass in the buffer to be filled in, which has to be of finite length, but there is no way to stop a bad guy from typing.

In order to avoid this problem, use the alternate functions:

getnstr()
inchnstr()
innstr()

which take an extra "size of buffer" argument.