Free chickens software for linux

CHICKEN is a compiler for the Scheme programming language. CHICKEN produces portable, efficient C, supports almost all of the current Scheme language standard, the Revised5 Report on the Algorithmic Language Scheme (R5RS ), and includes many enhancements and extensions. CHICKEN runs on MacOS X, Windows, and many Unix flavours.
Main features:
- Compiles Scheme to efficient and portable C
- Includes a full-featured interactive interpreter as well as an optimising batch compiler
- Full support for tail recursion, first-class continuations, high-level macros and dynamic-wind
- Highly portable and known to run on many platforms, including IA-32 (80x86), IA-64, PowerPC, SPARC and UltraSPARC, Alpha, MIPS, PA-RISC, ARM, AMD64 and S/390
- Distributed free for use and modification under the terms of the BSD License
- Transparent support for shared objects and linkage to C
- A sophisticated but easy-to-use Foreign Function Interface for linking C and C++ libraries and classes to Scheme
- Lightweight threads based on first-class continuations
- An object system with multiple dispatch, multiple inheritance and a meta-object protocol
- Common Lisp-style format
- Provides the syntax-case enhanced high-level macro system, R5RS syntax-rules , and define-macro
- Support for syntactic pattern-matching via Andrew Wrights match package
- Execution profiling, debugging and backtrace support
- A clean POSIX interface that covers environment and filesystem access, pipes, processes, signals, locks, sockets, and low-level and memory-mapped I/O
- Support for interpreted or compiled shell scripts under Unix and Windows
- Support for a large number of Scheme Requests For Implementation (SRFIs), some available separately as extensions:
SRFI 0 (cond-expand )
SRFI 1 (List library)
SRFI 2 (and-let* )
SRFI 4 (Homogeneous numeric vector datatypes)
SRFI 6 (Basic string ports)
SRFI 8 (receive )
SRFI 9 (Record types)
SRFI 10 (#, external form)
SRFI 13 (String library)
SRFI 14 (Character set library)
SRFI 16 (case-lambda )
SRFI 17 (Generalized set! )
SRFI 18 (Multithreading support)
SRFI 23 (error )
SRFI 25 (Multidimensional array primitives)
SRFI 26 (cut , cute )
SRFI 28 (format )
SRFI 30 (Block comments)
SRFI 37 (Program argument processor)
SRFI 38 (External representation for data with shared structure)
SRFI 39 (Parameters)
SRFI 40 (Stream library)
SRFI 42 (Eager comprehensions)
SRFI 43 (Vector library)
SRFI 55 (require-extension )
Version restrictions:
- No unlimited-precision integers (bignums), rationals or complex numbers
- Procedures are limited to 126 arguments
- No support for unicode
- Compilation of large files can be slow
Enhancements:
- chicken-setup: better handling when no remote repository file exists

Basic Local Alignment Search Tool is a set of similarity search programs designed to explore all of the available sequence databases regardless of whether the query is protein or DNA.
It uses a heuristic algorithm which seeks local as opposed to global alignments, and is therefore able to detect relationships among sequences which share only isolated regions of similarity.
It can be run locally as a full executable, and can be used to run BLAST searches against private, local databases, or downloaded copies of the NCBI databases. It runs on Mac OS, Win32, LINUX, Solaris, IBM AIX, SGI, Compaq OSF, and HP- UX systems.
Main features:
Nucleotide
- Quickly search for highly similar sequences (megablast)
- Quickly search for divergent sequences (discontiguous megablast)
- Nucleotide-nucleotide BLAST (blastn)
- Search for short, nearly exact matches
- Search trace archives with megablast or discontiguous megablast
Protein
- Protein-protein BLAST (blastp)
- Position-specific iterated and pattern-hit initiated BLAST (PSI- and PHI-BLAST)
- Search for short, nearly exact matches
- Search the conserved domain database (rpsblast)
- Protein homology by domain architecture (cdart)
Translated
- Translated query vs. protein database (blastx)
- Protein query vs. translated database (tblastn)
- Translated query vs. translated database (tblastx)
Genomes
- Human, mouse, rat, chimp cow, pig, dog, sheep, cat
- Chicken, puffer fish, zebrafish
- Environmental samples
- Protozoa
- Insects, nematodes, plants, fungi, microbial genomes, other eukaryotic genomes
Special
- Search for gene expression data (GEO BLAST)
- Align two sequences (bl2seq)
- Screen for vector contamination (VecScreen)
- Immunoglobin BLAST (IgBlast)
- SNP BLAST
Meta
- Retrieve results

VisiScript is a simple graphical frontend for scripting languages like minscript, Python,Ruby, Tcl, Perl, Lisp/Scheme or others.
VisiScript runs on the Qtopia desktop environment of the Zaurus and on all platforms supporting Qt 3.x.
With this program you can read, modify, save and execute script files and select different script languages. For the execution of the scripts the progam uses available script interpreters.
Since version 0.3.0 of VisiScript the QScintilla library is used as the editor-widget, this means that VisiScript is now a very comfortable programming editor with syntax highlighting and many other features.
To run a script VisiScript starts the actual selected script interpreter in an external process with the (temporary) script file. The output of this external process will be displayed in a text field below the script text field.
You have to install at least one additional script interpreter on the zaurus to use this program in an appropriate way. Here is a (not complete) list of available script languages for the Zaurus:
- minscript (a Java/C++ like script language)
- Python
- Ruby
- Perl
- Tcl
- Lush (a Lisp interpreter)/Scheme48
- Chicken

QWizard is a Perl module that can display a series of questions, get the answers, and act on the answers.

SYNOPSIS

#
# The following code works as a application *or* as a CGI script both:
#

use QWizard;

my %primaries =
(
starting_node =>
{ title => "starting here",
introduction => "foo bar",
questions =>
[{ type => text,
name => mytext,
text => enter something:,
default => "hello world" },
{ type => checkbox,
text => yes or no:,
values => [yes,no],
name => mycheck} ],
actions =>
[sub { return [
"msg: text = " . qwparam(mytext),
"msg: checkbox = " . qwparam(mycheck)
];}]
}
);

my $qw = new QWizard(primaries => %primaries,
title => "window title");

$qw->magic(starting_node);


#
# PLEASE see the examples in the examples directory.
#

QWizard displays a list of grouped questions, and retrieves and processes user-specified answers to the questions. Multiple question/answer sets may be displayed before the answers are dealt with. Once a "commit" action is taken (instigated by the user), a series of actions is performed to handle the answers. The actions are executed in the order required by the QWizard programmer.
QWizards real power lies in its inherent ability to keep track of all state information between one wizard screen and the next, even in normally stateless transaction environments like HTTP and HTML. This allows a QWizard programmer to collect a large body of data with a number of simple displays. After all the data has been gathered and verified, then it can be handled as appropriate (e.g., written to a database, used for system configuration, or used to generate a graph.)

Current user interfaces that exist are HTML, Gtk2, Tk, and (minimally) ReadLine. A single QWizard script implementation can make use of any of the output formats without code modification. Thus it is extremely easy to write portable wizard scripts that can be used without modification by both graphical window environments (Gtk2 and Tk) and HTML-based web environments (e.g., CGI scripts.), as well with intercative command line enviornments (ReadLine).
Back-end interfaces (child classes of the QWizard::Generator module) are responsible for displaying the information to the user. Currently HTML, Gtk2, Tk and ReadLine, are the output mechanisms that work the best (in that order). Some others are planned (namely a curses version), but are not far along in development. Developing new generator back-ends is fairly simple and doesnt take a lot of code (assuming the graphic interface is fairly powerful and contains a widget library.)

QWizard operates by displaying a series of "screens" to the user. Each screen is defined in a QWizard construct called a primary that describes the attributes of a given screen, including the list of questions to be presented to the user. Primaries can contain questions, things to do immediately after the questions are answered (post_answers), and things to do once the entire series of screens have been answered (actions). Other information, such as a title and an introduction, can also be attached to a primary.

An example very minimal primary definition containing one question:

my %primaries = (
myprimary =>
{
title => "my screen title",
introduction => "optional introduction to the screen",
questions =>
[
{
type => checkbox,
text => Should the chicken cross the road?,
}
],
}

After defining a set of primaries, a new QWizard object must be created. The QWizard new() constructor is given a set of options, such as window title and a reference to a hash table containing the primaries. (The complete set of options may be found in the "QWizard new() Options" section.) The question display and data collection is started by calling the magic() routine of the new QWizard object.

my $qw = new QWizard(primaries => %primaries,
title => my title);
$qw->magic(myprimary);

There are examples distributed with the QWizard module sources that may help to understand the whole system and what it is capable of. See the examples directory of the QWizard source code tree for details. Also, QWizard was written mostly due to requirements of the Net-Policy project. Net-Policy makes very extensive use of QWizard and is another good place to look for examples. In fact, the QWizard CVS code is located inside the Net-Policy CVS tree. See http://net-policy.sourceforge.net/ for details on the Net-Policy project. There are a number of screen shots showing all the interfaces as well on the main net-policy web site.

Wormux project is free software clone of this game concept. Though currently under heavy development, it is already very playable, with lots of weapons (Dynamite, Baseball Bat, Teleportation, etc.).

There are also lots of maps available for your battling pleasure! Wormux takes the genre to the next level, with great customisation options leading to great gameplay.

There is a wide selection of teams, from the Aliens to the Chickens. Also, new battlefields can be downloaded from the Internet, making strategy an important part of each battle.

Though two human players are currently needed to play (unless you have a split personality) the creation of artificial players and network play are future goals. So, start downloading today, and fight to become king of the garden!