Free for 15 software for linux

Gunroar is a 360-degree gunboat shooter. An abstract shooter; Shoot in any direction, as you race through the levels.
Keep near the top of the screen to increase your score. Destroy the enemy fleet. Comes with a soundtrack and effects.
Enhancements:
- Added -enableaxis5 option. (for xbox 360 wired controller)
- Added mouse mode.
- Changed a drawing method of a game field.
- Fixed a problem with a score reel size in a double play mode.
- Increased the number of smoke particles.

Tibco::Rv are Perl bindings and Object-Oriented library for TIBCOs TIB/Rendezvous.

SYNOPSIS

use Tibco::Rv;

my ( $rv ) = new Tibco::Rv;

my ( $listener ) =
$rv->createListener( subject => ABC, callback => sub
{
my ( $msg ) = @_;
print "Listener got a message: $msgn";
} );

my ( $timer ) = $rv->createTimer( timeout => 2, callback => sub
{
my ( $msg ) = $rv->createMsg;
$msg->addString( field1 => myvalue );
$msg->addString( field2 => myothervalue );
$msg->sendSubject( ABC );
print "Timer kicking out a message: $msgn";
$rv->send( $msg );
} );

my ( $killTimer ) =
$rv->createTimer( timeout => 7, callback => sub { $rv->stop } );

$rv->start;
print "finishedn"

Tibco::Rv provides bindings and Object-Oriented classes for TIBCOs TIB/Rendezvous message passing C API.

All methods die with a Tibco::Rv::Status message if there are any TIB/Rendezvous errors.

Oroborus basically is a really minimalistic window manager, which is about 75kb small on a PowerPC machine and about 63kb on an x86 machine. "Minimalistic" means that the Oroborus window manager doesnt provide some things other window managers provide.
So you will need some external tools also provided by this project.
The main improvement with this is that you gain much flexibility.
Main features:
- good default key bindings
- windows are moveable by keyboard
- highly configurable
- xpm-themable
- GNOME compatible
- NET_WM compatible
- sort of KDE compatible
- and many, many more...
Enhancements:
- New Release.
- Add some Themes (defold, bluecurve, mkultra, Elberg_Red, Elberg_Green, Elberg_Blue)
- Fix "oroborus -V".

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.

whohas is a command line tool that allows querying several package lists at once - currently supported are Arch, Debian, Fedora, Gentoo, Slackware (and linuxpackages.net), Source Mage, FreeBSD, NetBSD, OpenBSD, Fink and DarwinPorts.
whohas is written in Perl and was designed to help package maintainers find ebuilds, pkgbuilds and similar package definitions from other distributions to learn from. However, it can also be used by normal users who want to know:
- Which distribution provides packages on which the user depends.
- What version of a given package is in use in each distribution, or in each release of a distribution (implemented only for Debian).
It is suggested you use Unix command line tools to enhance your search results. whohas is optimised for fast execution. This is done by threading, and the order of results cannot be guaranteed. To nonetheless get a standardised output, alphabetically sorted by distribution, use the sort tool:
whohas gimp | sort
You can use grep to improve your search results. Depending on whether you want only packages whose names begin with your search term, end with your search term, or exactly match, you would use a space before, after or on both sides of your search term, respectively:
whohas gimp | sort | grep " gimp"
whohas vim | sort | grep "vim "
whohas gimp | sort | grep " gimp "
The spaces will ensure that only results for the package gimp are displayed, not for gimp-print etc.
If you want results for a particular distribution only, do
whohas arch | grep "^Arch"
Output for each module will still be ordered, so you dont need to sort results in this case, although you may wish to do so for some distributions. Distribution names are abbreviated as "Arch", "Debian", "Fedora", "Gentoo", "Slackware", "SMGL" (Source Mage Linux) and FreeBSD, NetBSD and OpenBSD.
Output in version 0.1 looked like this. The first column is the name of the distribution, the second the name of the package, the third the version number, then the date, repository name and a url linking to more information about the package. Future versions will have package size information, too. Column lengths are fixed, so you can use cut:
whohas vim | grep " vim " | cut -b 36-45
The first bytes of the data fields at the time of writing are 11, 37, 48, 53, 64 and 76.
Debian refers to the binary distribution. Slackware queries Current only. Binary sizes for Fedora are package sizes - space needed on disk will be greater by about factor 2. Binary sizes for Debian are unpacked sizes. All details (including availability, version numbers and binary sizes) are for the x86 architecture.
Debian version numbers in rare cases may not be for x86 (will be fixed). Gentoo version availability may not be for x86 (will be fixed). I recommend you consult the URLs provided in the output, which give detailed and accurate information about each package. You may want to use a terminal that recognises hyperlinks and allows easy access through the browser, such as gnome-terminal.
For Fedora, only release 4 is enabled by default, and only the most up to date package will be listed if different versions are available.
I would like to encourage distributors at this time to provide web query interfaces to package lists, and specifically provide the following information: package name, version, date, size and a url to further information (maintainer, build information etc.)

OpenGrade is software for teachers to keep track of grades. OpenGrade can put the students grade reports on a Web server and allow the students password-protected access to them.
Main features:
- A variety of reports can be created.
- Grades can be uploaded to a web server, where students can have password-protected access to them.
- If you use a set grading scale, you can have the software use it to compute letter grades automatically.
- Grades can be based on total points, or on a weighted average of scores in various categories such as exams and quizzes.
- You can drop the lowest grade (or the N lowest grades) from a given category.
- Students can be dropped and later reinstated without losing all their grades.
- There is support for extra-credit categories, and for categories that dont count towards the students grade.
- Gradebook files are password-protected with a digital watermark, so you can detect tampering.
- Gradebook files are in a plain-text format, which makes it easy to work with them using Unix utilities.
You might also want to check out Ggradebook and Grades, which are two other open-source programs along similar lines. There is a category for this kind of software on Open Directory.
OpenGrade is designed to cooperate with my software Spotter. By using the two pieces of software together, you can post grade reports on the web, keep track of your students e-mail addresses, and collect certain kinds of work from them online.
Enhancements:
- This version correctly recognizes Perl/Tk 804.027 as being compatible with itself, rather than insisting on 804.029 or higher.

whouses Perl module is an impact analysis in a clearmake build environment.

SYNOPSIS

Run this script with the -help option for usage details. Here are some additional sample usages with explanations:

whouses foobar.h

Shows all DOs that make use of any file matching /foobar.h/.

whouses -recurse foobar.h

Same as above but follows the chain of derived files recursively.

whouses -exact foobar.h

Shows all DOs that make use of the specified file. The -exact flag suppresses pattern matching and shows only DOs which reference the exact file.

Whouses provides a limited form of "impact analysis" in a clearmake build environment. This is different from traditional impact analysis (see TRUE CODE ANALYSIS COMPARED below for details). In particular, it operates at the granularity of files rather than language elements.

Whouses is best described by example. Imagine you have a VOB /vobs_sw in which you build the incredibly simple application foo from foo.c. You have a Makefile which compiles foo.c to foo.o and then links it to produce foo. And lets further assume youve just done a build using clearmake.

Thus, foo is a derived object (DO) which has a config record (CR) showing how it was made. Whouses analyzes that CR and prints the data in easy-to-read indented textual format. For instance:

% whouses -do foo foo.c
/vobs_sw/src/foo.c =>
/vobs_sw/src/foo.o

The -do foo points to the derived object from which to extract and analyze the CR; it will be implicit in the remaining examples. The output indicates that foo.o uses foo.c, or in other words that foo.c is a contributor to foo.o. If we add the -recurse flag:

% whouses -r foo.c
/vobs_sw/src/foo.c =>
/vobs_sw/src/foo.o
/vobs_sw/src/foo

We see all files to which foo.c contributes, indented according to how many generations removed they are. If we now add -terminals

% whouses -r -t foo.c
/vobs_sw/src/foo.c =>
/vobs_sw/src/foo

Intermediate targets such as foo.o are suppressed so we see only the "final" targets descended from foo.c.

We can also go in the other direction using -backward:

% whouses -b -e foo
/vobs_sw/src/foo<<less