Free building flexible applications software for linux

CGI::Application is a framework for building reusable web-applications.

SYNOPSIS

# In "WebApp.pm"...
package WebApp;
use base CGI::Application;

# ( setup() can even be skipped for common cases. See docs below. )
sub setup {
my $self = shift;
$self->start_mode(mode1);
$self->mode_param(rm);
$self->run_modes(
mode1 => do_stuff,
mode2 => do_more_stuff,
mode3 => do_something_else
);
}
sub do_stuff { ... }
sub do_more_stuff { ... }
sub do_something_else { ... }
1;


### In "webapp.cgi"...
use WebApp;
my $webapp = WebApp->new();
$webapp->run();

CGI::Application is intended to make it easier to create sophisticated, high-performance, reusable web-based applications. This module implements a methodology which, if followed, will make your web software easier to design, easier to document, easier to write, and easier to evolve.

CGI::Application judiciously avoids employing technologies and techniques which would bind a developer to any one set of tools, operating system or web server.

GRIA (Grid Resources for Industrial Applications) is Grid middleware that enables use of the Grid in a secure, interoperable and flexible manner.
Security
GRIA uses off-the-shelf Web Services technology and Public Key Infrastructure (PKI) security.
Trust
GRIA supports well established B2B processes & trust models.
Ease of use
GRIA is designed to support leading-edge and legacy application codes, and client-side applications can be easily written using the GRIA API.
Quality of Service
GRIA resource models allow service levels to be matched to clients needs.
Support
GRIA is supported through an open source community and on a commercial basis.
Enhancements:
- This release provides significant new features and usability enhancements to both the management packages and the client.
- The core infrastructure stack has been further aligned with key Web Service security and policy specifications.
- New services include a Membership Service, Registry Service, and an improved SLA service.

php.MVC implements the Model-View-Controller design pattern, and encourages application design based on the Model 2 paradigm. This design model allows the Web page or other contents (View) to be mostly separated from the internal application code (Controller/Model), making it easier for designers and programmers to focus on their respective areas of expertise.
The framework provides a single entry point Controller. The Controller is responsible for allocating HTTP requests to the appropriate Action handler (Model) based on configuration mappings.
The Model contains the business logic for the application. The Controller then forwards the request to the appropriate View component, which is usually implemented using a combination of HTML with PHP tags in the form of templates. The resulting contents are returned to the client browser, or via another protocol such as SMTP.
php.MVC is a PHP port of Jakarta Struts. It currently supports many features of Struts, including declarative application configuration via the XML digester. For example, mappings from the various Action business logic components to appropriate results pages can be specified declaratively in the XML configuration file.
Main features:
- Free OpenSource software: This gives users full control of the software, and the able to modify the source code to suit specific needs.
- Security: php.MVC applications have only one entry point (per application). This makes it easy to protect sensitive application code and data.
- Flexible Installation: Individual php.MVC applications can be installed outside of the main php.MVC library directory tree.
- Multi-applications: There is no limit to the number of applications per php.MVC installation.
- Object Oriented design (OOD). The php.MVC framework is based on OOD principles, making it more extendable and maintainable.
- Database integration: The php.MVC framework ships with the Pear::DB Database Abstraction Layer, and a driver for the MySQL relational database manager (RDBM) is provided.
- Action Chaining: php.MVC allows for passing control to other Actions. This makes it easy to process a sequence of Actions (business logic classes) and static resources (pages).
- XML configuration: php.MVC uses declarative application configurations using Extensible Markup Language (XML) files. Each application has its own XML configuration file.
- MVC Model 2 design: php.MVC implements the Model-View-Controller (MVC) Model 2 design pattern. The Model 2 paradigm allows the separation of the application presentation from the business logic, making it easier for designers and programmers to focus on their respective areas of expertise.
- Form button mapping: php.MVC implements the LookupDispatchAction class to enable HTML form buttons to be mapped to particular business logic methods. For example, a form submit button called "Add to Cart" could be mapped to an Action class method called MyCartAction->addToCart(...).
- Message Resources: php.MVC provides a PropertyMessageResources class that handles messages in text string properties files with parametric replacement. This can provide Locale-sensitive messages for internationalized applications.
- The php.MVC framework is based on Jakarta Struts application framework design. Struts has proven to be reliable, extendable and well supported.
Enhancements:
- This development release adds bugfixes and enhancements to the framework, a compressed performance version for use in more demanding hosting environments, and an example application to demonstrate the use of both versions.

Flexible Isometric Fallout-like Engine is a next-generation 2D engine that aims to be modern and have strong modding support. Fallout 2 graphic assets are supported.
Main features:
- is open source (GPL v2.0)
- can utilize the graphics from the original FallOut game (not distributed with FIFE!)
- supports different platforms: Linux (compiles and runs), Windows (compiles and runs) and MacOsX (compiles, cant be tested as a working .dat tool for Macintosh is missing)
- supports multiple resolutions (640x480 -> 1600x1200)
- supports fullscreen and windowed mode
- supports 16 & 32-bit colour depth
- supports OpenGL and software rendering (OpenGL is currently much faster)
- supports different alphablending modes: none, automatic, full
- is going to support weather effects (currently discussed!)
- is going to have a dynamic light system (currently discussed!)

CGI::Application::Plugin::PageBuilder is a Perl module that simplifies building pages with multiple templates.

SYNOPSIS

This module simplifies building complex web pages with many small piecemeal templates.
Instead of
sub run_mode {
my $self = shift;
my $header = $self->load_tmpl( header.tmpl )->output();
my $html;

my $start = $self->load_tmpl( view_start.tmpl );
$start->param( view_name => This View );
$html .= $start->output();

my $db = MyApp::DB::Views->retrieve_all(); # Class::DBI
while ( my $line = $db->next() ) {
my $template = $self->load_tmpl( view_element.tmpl );
$template->param( name => $line->name() );
$template->param( info => $line->info() );
$html .= $template->output();
}
$html .= $self->load_tmpl( view_end.tmpl )->output();
$html .= $self->load_tmpl( footer.tmpl )->output();
return $html;
}

You can do this:
CGI:App subclass:

sub run_mode {
my $self = shift;

$self->pb_template( header.tmpl );
$self->pb_template( view_start.tmpl );

my $db = MyApp::DB::Views->retrieve_all();
while( my $line = $db->next() ) {
$self->pb_template( view_row.tmpl );
$self->pb_param( name, $line->name() );
$self->pb_param( info, $line->info() );
}
$self->pb_template( view_end.tmpl );
$self->pb_template( footer.tmpl );
return $self->pb_build();
}

CGI::Application::Plugin::Authentication::Store is a base module for building storage classes for the CGI::Application::Plugin::Authentication plugin.

SYNOPSIS

package CGI::Application::Plugin::Authentication::Store::MyStore;
use base qw(CGI::Application::Plugin::Authentication::Store);

sub fetch {
my $self = shift;
my @params = @_;
...
}

sub save {
my $self = shift;
my %params = @_;
...
}

sub delete {
my $self = shift;
my @params = @_;
...
}

This module is a base class for all storage classes for the CGI::Application::Plugin::Authentication plugin. Each storage class is required to provide three methods that fetch, save and delete data from the store. The information that is saved will be text based, so there is no need to flatten any of the data that is to be stored.

MURIX Linux is a distribution based on LinuxFromScratch for building bootable CD-ROMs.

Since you build it from source, MURIX should function on almost any hardware.

Collaborative Portal Server (CPS) is the most complete Open Source platform available for building Enterprise Content Management (ECM) applications.
Collaborative Portal Server comes also as a user-friendly application ready to for entreprise-grade content management with many collaboration features. CPS is built on top of the powerful Zope application server.
This web portal aims at unifying and providing a common platform to the CPS community. You will find here news about CPS and its components, documentation, links, users and developers mailing-lists and information about the future of the platform.
CPS development is backed by Nuxeo and a community of contributors (Chalmers University, Infrae, etc.) and is released under the GPL.
Enhancements:
- This release contains mostly bugfixes and minor improvements.
- A couple of new packages, useful for application developers, have been also integrated: CPSDashboard (a tool to build flexible and easily configurable search results views) and CPSBayes (a tool to perform naive Bayesian inference).