Free stuff software for linux

Text::Template::Inline allows easy formatting of hierarchical data.

SYNOPSIS

# you can import any name you want instead of "render"
use Text::Template::Inline render;

# yields "Replace things and stuff."
render {
foo => things,
bar => stuff,
}, q ;

# yields "Three Two One Zero"
render [qw/ Zero One Two Three /], {3} {2} {1} {0};

# for a blessed $obj that has id and name accessors:
render $obj, {id} {name};

# a "fat comma" can be used as syntactic sugar:
render $obj => {id} {name};

# its also possible to traverse heirarchies of data,
# even of different types.
# the following yields "one two three"
render {
a => { d => one },
b => { e => two },
c => { f => [qw/ zero one two three /], },
} => {a.d} {b.e} {c.f.3};

# theres also an automatic unindent feature that
# lines up to the least-indented line in the template:
render {
a => { d => one },
b => { e => two },
c => { f => [qw/ zero one two three /], },
} => q{
{a.d}
{b.e}
{c.f.3}
};
# the above results in this:
one
two
three

unionfs-fuse filesystem is an effort to create a userland unionfs implementation that is probably slower but way more flexible than the current kernel-only based unionfs solution.
Main features:
Why choose this stuff
- The filesystem has to be mounted after the roots are mounted when using the standard module. With unionfs-fuse, you can mount the roots later and their contents will appear seamlesly
- You get caching which speeds things up a lot for free
- You get nice stats (optional)
Why NOT choose it
- Compared to kernel-space solution we need lots of useless context switches which makes kernel-only solution clear speed-winner
Available parameters
- --roots=/root1,/root2
- --stats
Enhancements:
- This version feaatures read-only branches, copy-on-write, bugfixes, and more.

Open Blue Lab is an enterprise resource planning system.
Whatever your goal is, the objective of this tool is to provide you the ready-to use stuff to create, update, search and view data you need for your application.
Moreover, this stuff is provided with the latest UI goodies like AJAX support that will ensure you the best feeling you never had in browsing.
Like OpenBlueLab.org project is portal aware, that means you have aggregation and personalization too.
That way, you can focus on your added value : the business logic and requirements your customer needs.
Enhancements:
- Attributes are now private instead of public.
- All entities (classes, attributes, and methods) are documented, allowing HTML documentation generation.
- iReport reporting has been integrated for journal, ledger, balance, and statistics.

Public Fox cleans stuff after downloading.

Tired of cleaning stuff people download? Use this to limit file downloading.
Prevent browser changes.

Public Fox blocks users from downloading unwanted files.
Locks down Add-ons.
Locks down Preferences.
Locks down about:config
All with a central password.

Class::Classless is a Perl framework for classless OOP.

SYNOPSIS

use strict;
use Class::Classless;
my $ob1 = $Class::Classless::ROOT->clone;
$ob1->{NAME} = Ob1;
$ob1->{stuff} = 123;
$ob1->{Thing} = 789;

my $ob2 = $ob1->clone;
$ob2->{NAME} = Ob2;

printf "ob1 stuff: n", $ob1->{stuff};
printf "ob2 stuff: n", $ob2->{stuff};
printf "ob1 Thing: n", $ob1->{Thing};
printf "ob2 Thing: n", $ob2->{Thing};

$ob1->{METHODS}{zaz} = sub {
print "Zaz! on ", $_[0]{NAME}, "n";
};

$ob1->zaz;
$ob2->zaz;
$ob1->EXAMINE;
$ob2->EXAMINE;
This prints the following:
ob1 stuff: < 123 >
ob2 stuff: < 123 >
ob1 Thing: < 789 >
ob2 Thing: < >
Zaz! on Ob1
Zaz! on Ob2
< Class::Classless::X=HASH(0x200236f4) >
stuff, 123,
NAME, Ob1,
Thing, 789,
METHODS, { zaz, CODE(0x20068360) },
PARENTS, [ ROOT ],
< Class::Classless::X=HASH(0x2002cb48) >
stuff, 123,
NAME, Ob2,
METHODS, { },
PARENTS, [ Ob1 ],

In class-based OOP frameworks, methods are applicable to objects by virtue of objects belonging to classes that either provide those methods, or inherit them from classes that do.

In classless OOP frameworks (AKA delegation-and-prototypes frameworks), what methods an object is capable of is basically an attribute of that object. That is, in Perl terms: instead of methods being entries in the symbol table of the package/class the object belongs to, they are entries in a hash table inside the object. Inheritance is implemented not by having classes inheriting from other classes (via ISA lists), but by having objects inherit from other objects (via PARENTS lists).

In class-based OOP frameworks, you get new objects by calling constructors. In a classless framework, you get new objects by copying ("cloning") an existing object -- and the new clone becomes a child (inheritor) of the original object. (Where do you get the one original object? The language provides one, which has no parents, and which contains some general purpose methods like "clone".)

Lemuria is an OpenGL visualization for xmms and gmerlin-visualizer. Lemuria features animated textures, several backgrounds, and a lot of fun stuff.

It integrates the Xaos fractal engine for making background textures, and can open the goom DLL.