Free introductory software for linux

Stratego/XT is a development environment for creating stand-alone transformation systems.
It combines Stratego, a language for implementing transformations based on the paradigm of programmable rewriting strategies, with XT, a collection of reusable components and tools for the development of transformation systems.
In general, Stratego/XT is intended for the analysis, manipulation, and generation of programs, though its features make it useful for transforming any structured documents.
In practice, it has been used to build many types of transformation systems including compilers, interpreters, static analyzers, domain-specific optimizers, code generators, source code refactorers, documentation generators, and document transformers.
Enhancements:
- The compiler was restructured.
- Some old language features were removed.
- Man pages for all tools were completed.
- A new introductory tutorial with examples was co-released, and more.

Bioperl project is a collection of perl modules that facilitate the development of perl scripts for bioinformatics applications. As such, it does not include ready to use programs in the sense that many commercial packages and free web-based interfaces do (e.g. Entrez, SRS).
On the other hand, bioperl does provide reusable perl modules that facilitate writing perl scripts for sequence manipulation, accessing of databases using a range of data formats and execution and parsing of the results of various molecular biology programs including Blast, clustalw, TCoffee, genscan, ESTscan and HMMER. Consequently, bioperl enables developing scripts that can analyze large quantities of sequence data in ways that are typically difficult or impossible with web based systems.
In order to take advantage of bioperl, the user needs a basic understanding of the perl programming language including an understanding of how to use perl references, modules, objects and methods. If these concepts are unfamiliar the user is referred to any of the various introductory or intermediate books on perl.
Weve liked S. Holzmers Perl Core Language, Coriolis Technology Press, for example. This tutorial is not intended to teach the fundamentals of perl to those with little or no experience in the perl language. On the other hand, advanced knowledge of perl - such as how to write a object-oriented perl module - is not required for successfully using bioperl.
Bioperl is open source software that is still under active development. The advantages of open source software are well known. They include the ability to freely examine and modify source code and exemption from software licensing fees.
However, since open source software is typically developed by a large number of volunteer programmers, the resulting code is often not as clearly organized and its user interface not as standardized as in a mature commercial product.
In addition, in any project under active development, documentation may not keep up with the development of new features. Consequently the learning curve for actively developed, open source source software is sometimes steep.
Enhancements:
- Many bugfixes and enhancements were made, including support for parsing the latest NCBI BLAST text format changes, PAML 3.15 support, a Taxonomy (Bio::Species) overhaul, a Bio::Map overhaul, a Bio::SearchIO speedup, the introduction of a Build.PL installation system, and fixes for some memory leaks in Bio::Tree.
- This version requires Perl 5.6.1 or later.

PDL::Indexing Perl module contains a tutorial on how to index piddles.

This manpage should serve as a first tutorial on the indexing and threading features of PDL.

This manpage is still in alpha development and not yet complete. "Meta" comments that point out deficiencies/omissions of this document will be surrounded by square brackets ([]), e.g. [ Hopefully I will be able to remove this paragraph at some time in the future ]. Furthermore, it is possible that there are errors in the code examples. Please report any errors to Christian Soeller (c.soeller@auckland.ac.nz).

Still to be done are (please bear with us and/or ask on the mailing list, see PDL::FAQ):

document perl level threading
threadids
update and correct description of slice
new functions in slice.pd (affine, lag, splitdim)
reworking of paragraph on explicit threading

Indexing and threading with PDL

A lot of the flexibility and power of PDL relies on the indexing and looping features of the perl extension. Indexing allows access to the data of a pdl object in a very flexible way. Threading provides efficient implicit looping functionality (since the loops are implemented as optimized C code).

Pdl objects (later often called "pdls") are perl objects that represent multidimensional arrays and operations on those. In contrast to simple perl @x style lists the array data is compactly stored in a single block of memory thus taking up a lot less memory and enabling use of fast C code to implement operations (e.g. addition, etc) on pdls.

pdls can have children

Central to many of the indexing capabilities of PDL are the relation of "parent" and "child" between pdls. Many of the indexing commands create a new pdl from an existing pdl. The new pdl is the "child" and the old one is the "parent". The data of the new pdl is defined by a transformation that specifies how to generate (compute) its data from the parents data. The relation between the child pdl and its parent are often bidirectional, meaning that changes in the childs data are propagated back to the parent. (Note: You see, we are aiming in our terminology already towards the new dataflow features. The kind of dataflow that is used by the indexing commands (about which you will learn in a minute) is always in operation, not only when you have explicitly switched on dataflow in your pdl by saying $a->doflow. For further information about data flow check the dataflow manpage.)

Another way to interpret the pdls created by our indexing commands is to view them as a kind of intelligent pointer that points back to some portion or all of its parents data. Therefore, it is not surprising that the parents data (or a portion of it) changes when manipulated through this "pointer". After these introductory remarks that hopefully prepared you for what is coming (rather than confuse you too much) we are going to dive right in and start with a description of the indexing commands and some typical examples how they might be used in PDL programs. We will further illustrate the pointer/dataflow analogies in the context of some of the examples later on.

There are two different implementations of this ``smart pointer relationship: the first one, which is a little slower but works for any transformation is simply to do the transformation forwards and backwards as necessary. The other is to consider the child piddle a ``virtual piddle, which only stores a pointer to the parent and access information so that routines which use the child piddle actually directly access the data in the parent. If the virtual piddle is given to a routine which cannot use it, PDL transparently physicalizes the virtual piddle before letting the routine use it.

Currently (1.94_01) all transformations which are ``affine, i.e. the indices of the data item in the parent piddle are determined by a linear transformation (+ constant) from the indices of the child piddle result in virtual piddles. All other indexing routines (e.g. ->index(...)) result in physical piddles. All routines compiled by PP can accept affine piddles (except those routines that pass pointers to external library functions).

Note that whether something is affine or not does not affect the semantics of what you do in any way: both

$a->index(...) .= 5;
$a->slice(...) .= 5;

change the data in $a. The affinity does, however, have a significant impact on memory usage and performance.

The interface itself is vaguely similar but not identical to the Event module. On the first call of any method, the module tries to detect the currently loaded event loop by probing for an already-loaded event loop, such as Glib or Event. The first one found is used. If none is found, the module tries to load an event module.

Enhancements:

• This release adds an introductory tutorial.
• Also, many workarounds for Windows and Tk bugs have been implemented, to make AnyEvent behavior identical to Unix behavior.
• IPv6 support is only enabled when the OS actually supports it.
• BSD platforms implementing the socket structures incorrectly are now worked around. Unix domain sockets are now supported transparently.
• NAPTR and SRV handling has been improved. Lastly, a great many bugs and performance improvements have been applied, especially to AnyEvent:Handle and TLS support.

Requirements: Perl

allcookies is an extension which dumps ALL cookies (including session cookies) to Firefox standard cookies.txt file.

The mandatory companion tool for downloading sites with WGET
A very minimum extension : no psychedelic design. Just the needed feature.

Why you need it : Many web sites are protected by either
- authentification forms
- vicious access rules like "you must first see some introductory or advertisement pages"

Such sites cant be downloaded with the well known WGET tool

AllCookies is the answer to this kind of restrictions.

How it works

Web sites generally use temporary "session cookies" to manage access rules. Such cookies are not saved to the firefox "cookies.txt" file, and are destroyed once your session closes.

AllCookies will turn those cookies to permanent cookies and force saving in cookies.txt

A typicall scenario to download a web site with WGET becomes:
- using Firefox, connect to the web sites, go through all the authentification forms or preliminary pages that are required
- execute AllCookies (just a simple item added in Firefox menu ) to update cookies.txt file
- launch wget : wget --load-cookies=z:cookies.txt http://foo.com

Quantian distribution is a remastering of Knoppix, the self-configuring and directly bootable dvd/cdrom that turns any pc or laptop (provided it can boot from cdrom/dvd) into a full-featured Linux workstation.
Recent versions of Quantian are based on clusterKnoppix and add support for openMosix, including remote booting of light clients in an openMosix terminal server context. Earlier releases are still available; see below for URLs for downloads as well as ordering information.
Brief introductory information is available in a paper (from June 2004) submitted to The Political Methodologist, slides from the presentation at Usenix 2004 (July 2004), and in the earlier (revised) paper about Quantian that has appeared in the DSC 2003 Proceedings.
Quantian is an extension of Knoppix and clusterKnoppix from which it takes its base system of around two gigabytes of software, along with fully automatic hardware detection and configuration.
Enhancements:
- Kernel 2.6.12, KDE 3.5 / 3.4, OpenOffice 2.0, ... and more from Knoppix 4.0.2
- a backport of the openMosix-enabled 2.4.27 kernel and openMosix tools from the last clusterKnoppix release,
- very comprehensive support for GNU R with over 870 packages from CRAN and BioConductor, plus ESS, Ggobi, Rpad, RKward, RSPerl, JGR, ...
- addition of the Java 1.5.0 SDK enabling us to add ImageJ, Weka, JGR, Mondrian;
- plus a number of other new packages (inkscape, orsa, praat, wxmaxima, some more Debian documentation...)
- and still loads more of math, bio, engineering, LaTeX, ... software

BlueJ project is an integrated Java environment (Java IDE) specifically designed for introductory teaching.
The BlueJ environment was developed as part of a university research project about teaching object-orientation to beginners. The system is being developed and maintained by a joint research group at Deakin University, Melbourne, Australia, and the University of Kent in Canterbury, UK. The project is supported by Sun Microsystems.
The aim of BlueJ is to provide an easy-to-use teaching environment for the Java language that facilitates the teaching of Java to first year students. Special emphasis has been placed on visualisation and interaction techniques to create a highly interactive environment that encourages experimentation and exploration.
BlueJ is based on the Blue system. Blue is an integrated teaching environment and language, developed at the University of Sydney and Monash University, Australia. BlueJ provides a Blue-like environment for the Java language.
The BlueJ project started at Monash University in Melbourne, and later split and migrated to its current locations.
BlueJ is implemented in Java, and regularly being tested on Solaris, Linux, Macintosh, and various Windows versions. It should run on all platforms supporting a recent Java virtual machine.
Main features:
- fully integrated environment
- graphical class structure display
- graphical and textual editing
- built-in editor, compiler, virtual machine, debugger, etc.
- easy-to-use interface, ideal for beginners
- interactive object creation
- interactive object calls
- interactive testing
- incremental application development