Free tastefully simple software for linux

Sunergos Simple is a minimal Gnome Login Manager.

An experiment in minimalism.

There are no options, no buttons, just a hello and how are you and why dont you just log in already?

So, this theme may not be suited for all users.

However, it is _extremely_ easy to understand and quite useful if you are interested in creating your own theme.

Template::Simple is a simple and fast template module.

SYNOPSIS

use Template::Simple;

my $tmpl = Template::Simple->new();

my $template = Jan 1, 2008,
author => Me, myself and I,
},
row => [
{
first => row 1 value 1,
second => row 1 value 2,
},
{
first => row 2 value 1,
second => row 2 value 2,
},
],
footer_data => {
modified => Aug 31, 2006,
},
} ;

my $rendered = $tmpl->render( $template, $data ) ;

Template::Simple has these goals:

Support most common template operations

It can recursively include other templates, replace tokens (scalars), recursively render nested chunks of text and render lists. By using simple idioms you can get conditional renderings.
Complete isolation of template from program code

This is very important as template design can be done by different people than the program logic. It is rare that one person is well skilled in both template design and also programming.
Very simple template markup (only 4 markups)

The only markups are INCLUDE, START, END and token. See MARKUP for more.

Easy to follow rendering rules

Rendering of templates and chunks is driven from a data tree. The type of the data element used in an rendering controls how the rendering happens. The data element can be a scalar or scalar reference or an array, hash or code reference.

Efficient template rendering

Rendering is very simple and uses Perls regular expressions efficiently. Because the markup is so simple less processing is needed than many other templaters. Precompiling templates is not supported yet but that optimization is on the TODO list.

Easy user extensions

User code can be called during an rendering so you can do custom renderings and plugins. Closures can be used so the code can have its own private data for use in rendering its template chunk.

JOpt Simple is a simple, test-driven command line parser for Java programs. JOpt Simple supports POSIX getopt() and GNU getopt_long().
What command line switch syntax does JOpt Simple support?
As closely as possible, JOpt Simple attempts to adhere to the rules of POSIX getopt() and GNU getopt_long(). You can find a brief summary of these rules in the javadoc for class OptionParser.
Enhancements:
- Minor internal changes.

Timestamp::Simple is a Perl module with simple methods for timestamping.

SYNOPSIS

use Timestamp::Simple qw(stamp);
print stamp, "n";

This module provides a simple method for returning a stamp to mark when an event occurs.

METHODS

stamp()

This method returns a timestamp in the form yyyymmddHHMMSS.

Keep IT Simple is a simple, customizable, Conky-like theme for Superkaramba featuring a mail-checker and a temperatures monitor.
Enjoy!
It monitors:
- CPU usage
- HDD usage
- Network load
- Memory load
- e-mail inbox

MP3::Icecast::Simple is a simple MP3::Icecast wrapper.

SYNOPSIS

use MP3::Icecast::Simple;

$icy = MP3::Icecast::Simple->new(
description => "Station",
server => 127.0.0.1:8000,
password => password,
local_port => 1234,
bitrate => 96
);
$icy->play("/path/to/files");

ABSTRACT

MP3::Icecast::Simple is a simple MP3::Icecast wrapper, that can be used to create a SHOUTcast/Icecast broadcast source easy.

XML::Simple is a easy API to maintain XML (esp config files).

SYNOPSIS

use XML::Simple;

my $ref = XMLin([< xml file or string >] [, < options >]);

my $xml = XMLout($hashref [, < options >]);

Or the object oriented way:

require XML::Simple;

my $xs = new XML::Simple(options);

my $ref = $xs->XMLin([< xml file or string >] [, < options >]);

my $xml = $xs->XMLout($hashref [, < options >]);

(or see "SAX SUPPORT" for the SAX way).

To catch common errors:

use XML::Simple qw(:strict);

DFA::Simple is a Perl module to implement simple Discrete Finite Automata.

SYNOPSIS

my $Obj = new DFA::Simple
or
my $Obj = new DFA::Simple $Transitions;
or
my $Obj = new DFA::Simple $Actions, $StateRules;

$Obj->Actions = [...];
my $Trans = $LP->Actions;

$Obj->StateRules = [...];
my $StateRules = $LP->StateRules;

my $Obj = new DFA::Simple $Actions,[States];

This creates a simple automaton with a finite number of individual states. The short version is that state numbers are just indices into the array.

The state basically binds the rest of the machine together:

1. There might be something you want done whenever you enter a given state (Transition Table)
2. There might be something you want done whenever you leave a given state (Transition Table)
3. You can go to some states from the current state (Action table)
4. There are tests to decide whether you should go to that new state (Action table)
5. There are conditional tasks you can do while sitting in that new state (Action table)

This structure may remind you of the SysV run-level concepts. It is very similar.
At run time you dont typically feed any state numbers to the finite machine; you ignore them. Rather your program may read inputs or such. The tests for the state transition would examine this input, or some other variables to decide which new state to go to. Whenever your code has gotten enough input, it would call the Check_For_NextState() method. This method runs through the tests, and carries out the state transitions ("firing the rules").