Free biological fail software for linux

Biogenesis project is a unicellular organism evolution simulator.
Biogenesis simulates in a visual fashion the processes involved in the evolution of unicellular organisms in nature.
It tries to be a didactic approximation to the ideas of mutation or evolution, and can be enjoyed also as an entertainment.
Its intended to serve as a support to show students some basic biological facts. The idea of Biogenesis is taken from Primordial Life, but its an independent project.
Main features:
- The application should be multiplatform.
- There should exist translations in many languages. At the moment, there are only Catalan, English and Spanish translations.
- The representation should be abstract and simplified, but still scientifically accurate.
- It should be actively maintained.
- A good documentation should be enclosed with the application.
- It should be amusing.

LOSSA project is a home automation system.
LOSSA is a home automation system that aims at distributed network of devices with simple interconnect system, personal computer intercommunication, simple wiring, and very low cost.
The project is still in architectural development state and the files avalivle as download (including this readme) are there to collect as much feedback as possible from those people who have experience in similar projects.
Dew to the contained price, easy requisition, wide veriaty of opensource developement tools and very little external components requirements I think that Microchips pic16f84 will be a mandatory choice in any case.
Enhancements:
- Added application showing internal pic eeprom usage and TIL311 interfacing
- Added simple pic application showing interrupts (tools/beginner_pic_app)
- Defined EEPROM Memory Assignments for config amd power fail retention
- Review of: transmission type, collision detection, physical medium
- Added a tools directory with PicMicro developing and programming tools
- Reorganization of the documentation
- Review of the transmission protocol
- Made Makefile (just for packaging for now)

tbibtools project provides a simple regexp-based bibtex parser. Please be aware that this script makes a few assumptions on how a bib file should look like and that it may fail on files formatted in unusual ways.
Failure may lead to loss of bib entries and malformed or incomplete output. Comments and other text will be stripped when reformatting entries. Any feature of bibtex I dont know and/or dont use myself is most likely not supported by this script/class.
Please take care when using this script. Make backups and check the output, especially when using the -f command-line option. Dont blame me if you lose information or end up with corrupted bib files.
Enhancements:
- sortCrossref puts cross-referenced entries to the back.
- A new format, (un)selectCrossref, allows you to view only entries that are (not) cross-referenced.
- The syntax of the query command has changed: query FIELD1 => RX1, FIELD2 => RX2, etc.
- Duplicate entries and certain conflicting fields are merged.
- A problem with --ls has been fixed.

Bio::PrimarySeqI is a Perl Interface definition for a Bio::PrimarySeq.

SYNOPSIS

# Bio::PrimarySeqI is the interface class for sequences.

# If you are a newcomer to bioperl, you should
# start with Bio::Seq documentation. This
# documentation is mainly for developers using
# Bioperl.

# to test this is a seq object

$obj->isa("Bio::PrimarySeqI") ||
$obj->throw("$obj does not implement the Bio::PrimarySeqI interface");

# accessors

$string = $obj->seq();
$substring = $obj->subseq(12,50);
$display = $obj->display_id(); # for human display
$id = $obj->primary_id(); # unique id for this object,
# implementation defined
$unique_key= $obj->accession_number();
# unique biological id

# object manipulation

eval {
$rev = $obj->revcom();
};
if( $@ ) {
$obj->throw(-class => Bio::Root::Exception,
-text => "Could not reverse complement. ".
"Probably not DNA. Actual exceptionn$@n",
-value => $@);
}

$trunc = $obj->trunc(12,50);

# $rev and $trunc are Bio::PrimarySeqI compliant objects

This object defines an abstract interface to basic sequence information - for most users of the package the documentation (and methods) in this class are not useful - this is a developers only class which defines what methods have to be implmented by other Perl objects to comply to the Bio::PrimarySeqI interface. Go "perldoc Bio::Seq" or "man Bio::Seq" for more information on the main class for sequences.

PrimarySeq is an object just for the sequence and its name(s), nothing more. Seq is the larger object complete with features. There is a pure perl implementation of this in Bio::PrimarySeq. If you just want to use Bio::PrimarySeq objects, then please read that module first. This module defines the interface, and is of more interest to people who want to wrap their own Perl Objects/RDBs/FileSystems etc in way that they "are" bioperl sequence objects, even though it is not using Perl to store the sequence etc.

This interface defines what bioperl consideres necessary to "be" a sequence, without providing an implementation of this. (An implementation is provided in Bio::PrimarySeq). If you want to provide a Bio::PrimarySeq compliant object which in fact wraps another object/database/out-of-perl experience, then this is the correct thing to wrap, generally by providing a wrapper class which would inheriet from your object and this Bio::PrimarySeqI interface. The wrapper class then would have methods lists in the "Implementation Specific Functions" which would provide these methods for your object.

Xholon runtime framework executes applications that are event-driven or that have highly dynamic structure or behavior. Specify your models using XML and Java, or using third-party UML2 tools and MDA transformations.
To get started, read or actively work through the basic HelloWorld tutorial. Its a very simple application, but it demonstrates many of the main concepts.
For more detail on the concepts behind Xholon, you might want to read one of the papers thats been published. These describe how to model cells and other complex biological entities using tools designed for developing real-time and embedded systems.
This earlier work used Rational Rose RealTime and C++, rather than the current Java. Xholon is intended to be a runtime framework that can execute the same types of systems described in those papers, plus many more traditional non-biological event-driven systems.
The goal of the Cellontro sister project is to develop complex biological simulations using the Xholon framework. Most of the features described in the published papers have been re-implemented as Cellontro applications using Xholon.
Also have a look at the sample applications that are included with the Xholon software. These give an idea of the range of applications that can be supported by the Xholon runtime framework.
These have been employed as use cases to determine what functionality is most important in Xholon. The digital watch simulation is a good example of a Xholon application with a hierarchical state machine, developed using a UML modeling tool.
A Xholon is essentially a holon. A holon is an entity that lives within a hierarchical structure, and is both a whole and a part at the same time.
In mainstream computer science terms, a Xholon is a node in a tree. The node has a single parent, possibly one or more children, and possibly one or more siblings. A Xholon may also be an active agent able to interact in real-time with other Xholons in the tree.
In UML2 terminology, a Xholon is a structured classifier that may exist as a part within other structured classifiers, and that may in turn contain other structured classifiers as parts of itself. The result is a hierarchical containment structure, nested to an arbitrary number of levels.
As a part, a Xholon plays a specific role within another structured classifier. Xholons are UML classes that are subsequently refined using UML2 composite structure diagrams. Structured classifiers interact with each other through ports, by passing messages or by making function calls.
Using the more philosophical terminology used to describe holons, a Xholon is something that is simultaneously both a whole and a part. Since everything in the universe is a holon, then everything running within a computer application should be a Xholon. The term holon was invented by Arthur Koestler in 1967.
The Xholon Project is inspired by biological concepts. A major incentive behind the project is to build a run-time environment that is equally adapted to running simulations of biological systems, and to running more traditional real-time, embedded and other event-driven reactive systems.
Xholon applications may contain structures that are highly mutable. A Xholon is an active agent that can modify the tree structure in which it lives. It can navigate the tree to interact with any other node, it can add, delete or modify other nodes, it can exchange messages with other nodes, and it can move itself to another position within the tree.
The Xholon Project incorporates many concepts of the Real-time Object-Oriented Modeling (ROOM) methodology, much of which has been incorporated into UML2. At the same time, Xholon removes some of the limitations of ROOM to allow for greater flexibility, mutability and mobility of active objects.
The Xholon run-time can serve as a target for a Model Driven Architecture (MDA) transformation pipeline. MDA stresses the importance of models, and the ability to transform those models, through a series of steps, into an executing target system.
You can create your model using a UML tool such as Gentlewares Poseidon or NoMagics MagicDraw, save the model as an XMI file, transform it using XSLT (or by some other MDA means) into a Xholon model and application, and then execute the model.
Enhancements:
- UML state machine simulation capabilities have been extended, including animation, and fork, join, junction.
- Additional Agent-Based Modeling functionality is available.
- The NetLogo-like syntax has been enhanced.
- The architecture is more flexible and is ready to more fully support integration of multiple domains.
- Histograms and probability distributions are now available. Line charts update in real-time.
- Numerous other modeling, simulation, transformation, and execution features have been added.

Biomolecule Toolkit project is an Open Source library for the structural modeling of biological macromolecules. The toolkit provides a C++ interface for common tasks in computational structural biology, to facilitate the development of molecular modeling, design, and analysis tools.
Enhancements:
Documentation updates
- Addition of an extensive discussion of the leastsquares_superposition and RMSD-calculation methods, including a description of the mathematical theory behind their operation.
- Fully documented the rotation/translation methods
- Addition of a documented example program ("gyration_radius.cpp")
Bug fixes
- Fixed copy construction bug in PDBAtomDecorator that caused compilation errors in rare situations.
- Fixed a bug in PDBFileParser that caused a compilation error in the PDBSystem copy constructor.
- Fixed a const-conversion bug in GroupedElementIterator which prevented proper interoperation of const and non-const iterator types.
- Fixed a crash-producing bug in stream output for the TypeID class.
- Fixed a math error in RMSD and superposition methods that would corrupt molecule coordinates.
- Fixed a bug that caused all default-constructed PDBAtom objects to be treated as HETATMs.
Feature additions
- Added operator[] to AtomicStructure and PolymerStructure-derived classes.
- Added protected increment() and decrement() operators to TypeID class.
- PDBFileParser can now handle PDB files with ill-formed residue numbering (i.e. Files where residue numbers are repeated in successive chains).

libMAGE is a Multi-Agent Grid Engine library. libMAGE library an experiment aimed to make a programming tool for creation of autonomic systems. We define autonomic system as the system that has the following features:

- The system is composed from a set of intellectual agents. All decision-making in the system is distributed and has a form of self-organization.
- The system is able to adapt to the surrounding environment. This includes adaptation to CPU, memory and disk load, and node failure (self-healing). The system is allowed to allocate additional nodes or redistribute current resources.

In libMAGE every agent of the system can be viewed as a living cell in a biological organism. Every agent contains enough information for construction of the whole organism, however after going through the process of growth, which mimics morphogenesis, the agent gets specialized. Specialized agents form groups and function cooperatively.

Bio::GMOD::Admin::Monitor::blat is a Perl module that can monitor a BLAT server.

SYNOPSIS

Check the installed version of a MOD
use Bio::GMOD::Util::CheckVersions.pm
my $gmod = Bio::GMOD::Util::CheckVersions->new(-mod=>WormBase);
my $version = $gmod->live_version;
Update a MOD installation
use Bio::GMOD::Update;
my $gmod = Bio::GMOD::Update->new(-mod=>WormBase);
$gmod->update();
Build archives of MOD releases (coming soon...)
Do some common datamining tasks (coming soon...)

Bio::GMOD is a unified API for accessing various Model Organism Databases. It is a part of the Generic Model Organism Database project, as well as distributed on CPAN.

MODs are highly curated resources of biological knowledge. MODs typically incorporate the typical information found at common community sites such as NCBI. However, they greatly extend this information, placing it within a framework of experimental and published observations of biological function gleaned from experiments in model organisms.

Given the great proliferation of MODs, cross-site data mining strategies have been difficult to implement. Furthermore, the quickly-evolving nature of these projects have made installing a MOD locally and keeping it up-to-date a delicate and time-consuming experience.

Bio::GMOD aims to solve these problems by:

1. Making MODs easy to install
2. Making MODs easy to upgrade
3. Enabling cross-MOD data mining through a unified API
4. Insulating programmatic end users from model changes

NOTES FOR DEVELOPERS

Bio::GMOD.pm uses a generically subclass-able architecture that lets MOD developers support various features as needed or desired. For example, a developer may wish to override the default methods for Update.pm by building a Bio::GMOD::Update::FlyBase package that provides an update() method, as well as various supporting methods.

Currently, the only participating MOD is WormBase. The authors hope that this will change in the future!