Free possibilities software for linux

HOL-TestGen allows one to write test specifications in Higher-order logics (HOL). It can (semi-) automatically partition the input space, resulting in abstract test cases, and automatically select concrete test data.
Automatic generation of test harnesses (in SML) is supported, and using a foreign language interface, implementations in arbitrary languages (e.g. C) can be tested.
Main features:
- write test specifications in Higher-order logics (HOL)
- (semi-) automatically partition the input space, resulting in abstract test cases
- automatically select concrete test data
- automatically generate test scripts (in SML)
- using a foreign language interface, implementations in arbitrary languages (e.g. C) can be tested.
HOL-OCL is free software; you can redistribute it and/or modify it under the terms of the GPL. HOL-TestGen project is developed by Achim D. Brucker and Burkhart Wolff.
Enhancements:
- This release extends the configuration possibilities of the code generator, and includes an example demonstrating sequence testing.

silc improved is an SILC client without a user interface. silc improved does output via files and input throught FIFOs. Most features of SILC are implemented.
Commands:
/j < channel > join to a channel
/l [channel] leave the actual or named channel
/msg < nick > < message > send a private message
/set signed < on|off > Set signing of messages on/off
/set signal_detach < on|off > When SIGTERM or SIGINT is caught, si detaches the session
/query < nick > Start a query with the user, so all private messages are no longer written in the master channel. the query has his own directory under $silcidr/query/$username
/names prints the users of the actual channel
and all other silc commands ( unkown commands are directly send to the server )
Usage:
There are endless possibilities using si. i use in one window a multitail and in the other the python input shell, you can find in the CVS.
Installation;
first you had to install libsilc (http://silcnet.org)
cd $sourcedir
make
make install (as root)
When your SILC includes/libs are not in /usr/local/silc you had to specify them like this
make SILCINCLUDE=/path/to/silc/include SILCLIB=/path/to/silc/lib
Enhancements:
- This release has been ported to SILC toolkit 1.1.
- The code has been cleaned up.

Shizzle project is an X-session based daemon that runs in the background and monitors D-Bus activity. When a D-Bus capable application is started, Shizzle will activate the loaded plugins (which are Python modules or applications) which matche the application started.

The plugins are designed to enable various D-Bus aware applications to interact with each other, creating new functionalities and possibilities for enhanced desktop user experience. For example, a plugin could allow a media player to interact with chat and IM software.

Bio::LiveSeq::Translation is a translation class for LiveSeq.

This stores informations about aminoacids translations of transcripts. The implementation is that a Translation object is the translation of a Transcript object, with different possibilities of manipulation, different coordinate system and eventually its own ranges (protein domains).

APPENDIX

The rest of the documentation details each of the object methods. Internal methods are usually preceded with a _

new

Title : new
Usage : $protein = Bio::LiveSeq::Translation->new(-transcript => $transcr);

Function: generates a new Bio::LiveSeq::Translation
Returns : reference to a new object of class Translation
Errorcode -1
Args : reference to an object of class Transcript

get_Transcript

Title : valid
Usage : $transcript = $obj->get_Transcript()
Function: retrieves the reference to the object of class Transcript (if any)
attached to a LiveSeq object
Returns : object reference
Args : none

aa_ranges

Title : aa_ranges
Usage : @proteinfeatures = $translation->aa_ranges()
Function: to retrieve all the LiveSeq AARange objects attached to a
Translation, usually created out of a SwissProt database entry
crossreferenced from an EMBL CDS feature.
Returns : an array
Args : none

SlackFire is an iptables script written especially for Slackware, my favourite Linux distribution in this corner of the Galaxy.
SlackFires main purpose is to protect a stand-alone machine or a small network with a stateful firewall that can be configured easily but in big detail.
Why another iptables script? There are a lot in the Internet, many of them with pretty nice GUI!
First of all, I didnt want to have a firewall that I only could manage and configure via GUI.
Next, I needed to work with a LAN with machines having routable IP addresses. Quite a few scripts available in the Net supported this feature.
Even lesser number of scripts supported configuration of fine-tuned rules. The majority of them just allowed all outgoing connections permitting replies to go back. I wanted to restrict outgoing traffic, too.
I also wanted that configuration can be performed without touching the main script and that this could be done by a person with very little knowledge about iptables.
Thus, I found it easier to write a script of my own than to tune a script written by somebody else.
Version restrictions:
- Currently, SF protects at most two network devices. All other network devices are not affected by the firewall in case packets are sent directly to the box running SF. Forwarded packets are dropped though. (The latter behaviour can be easily fixed.)
- I havent tried SF at machines that use DHCP. I expect that some tuning may be needed, especially in case the script is installed on a DHCP server.
- SF has only been tested on machines running Slackware >=9.0 with C locale. Certain things can break if messages produced by ifconfig and iptables use other languages than English. (This can be easily fixed if needed.)
- There is no support for NFS through a protected network interface yet. This will be fixed.
- Support of FreeS/WAN is not implemented.
There are undoubtedly more, partially because netfilter provides an incredibly rich range of possibilities. Actually, I havent seen an iptables script in the Internet with all the iptables possibilities implemented.
Enhancements:
- A minor change was made in bash syntax when proceeding configuration files.
- Temporary files are now created using mktemp.

Slide & Stack is a brain challenging game. Looks like the 2D version of Rubix but is something different. Simple movements and infinite possibilities makes you train your logic thinking in order to solve this puzzle.

The game starts with a four colored bar and a four by four square with all colors in their place. Suddenly the bar starts to move, rotating around the square and stacking itself into the square. When it stops moving, all colors are out of place and is your turn to organize them.

Unlock the logic behind this game. Stop and restart playing selecting the difficulty level at will. On-game animated instructions will help you understand the dynamics.

Play Slide & Stack, discover how to solve it and share your method with other players. Look at the solving hints page for ideas.

Lightfeather is a 3D engine for Linux, Mac OS X and Windows. Lightfeather project is designed to be easy to use but still take advantage of the features of modern graphics hardware.
The zlib/libpng license under which it is distributed allows you to use it for any purpose whatsoever including commercial projects without the need to redistribute your changes in any form or even mentioning that you use it (although that would be nice, of course).
To use Lightfeather you need to be proficient in c++ programming (a python binding is in the works at the moment so you might be able to use Lightfeather with python in the future). It is geared towards intermediate to professional programmers and not towards beginners.
Before you start working with Lightfeather you should AT LEAST read the Modelconverter and the Renderpasses information in the documentation submenu.
If you want to help with Lightfeathers development, there are lots of possibilities to do so. You could, for example, submit patches, contribute models for the test and example applications or write tutorials. If you want to work on the engine but dont know where to start look into the todo/request list. Help in any form is always very welcome.
Enhancements:
- It is now possible to render the same scene through different cameras into multiple windows.
- A filesystem handler interface has been added, which allows the use of a database or an FTP server like a normal filesystem.
- Resources can be grouped for easier handling.
- Users can integrate their own data into the engines lfm file format.
- Many more changes were made and lots of bugs were fixed.