Free keep it simple software for linux

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

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.

Getopt::Simple is a Perl module that provides a simple wrapper around Getopt::Long.

SYNOPSIS

use Getopt::Simple;

# Or ...
# use Getopt::Simple qw($switch);

my($options) =
{
help =>
{
type => ,
env => -,
default => ,
# verbose => , # Not needed on every key.
order => 1,
},
username =>
{
type => =s, # As per Getopt::Long.
env => $USER, # Help text.
default => $ENV{USER} || RonSavage, # In case $USER is undef.
verbose => Specify the username on the remote machine,
order => 3, # Help text sort order.
},
password =>
{
type => =s,
env => -,
default => password,
verbose => Specify the password on the remote machine,
order => 4,
},
};

my($option) = Getopt::Simple -> new();

if (! $option -> getOptions($options, "Usage: testSimple.pl [options]") )
{
exit(-1); # Failure.
}

print "username: $$option{switch}{username}. n";
print "password: $$option{switch}{password}. n";

# Or, after use Getopt::Simple qw($switch); ...
# print "username: $$switch{username}. n";
# print "password: $$switch{password}. n";

Getopt::Simple is a pure Perl module.

The Getopt::Simple module provides a simple way of specifying:

Command line switches

Type information for switch values

Default values for the switches

Help text per switch

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.

Test::Simple is a Perl module with basic utilities for writing tests.

SYNOPSIS

use Test::Simple tests => 1;

ok( $foo eq $bar, foo is bar );

** If you are unfamiliar with testing read Test::Tutorial first! **

This is an extremely simple, extremely basic module for writing tests suitable for CPAN modules and other pursuits. If you wish to do more complicated testing, use the Test::More module (a drop-in replacement for this one).
The basic unit of Perl testing is the ok. For each thing you want to test your program will print out an "ok" or "not ok" to indicate pass or fail. You do this with the ok() function (see below).

The only other constraint is you must pre-declare how many tests you plan to run. This is in case something goes horribly wrong during the test and your test program aborts, or skips a test or whatever. You do this like so:

use Test::Simple tests => 23;

You must have a plan.

ok
ok( $foo eq $bar, $name );
ok( $foo eq $bar );

ok() is given an expression (in this case $foo eq $bar). If its true, the test passed. If its false, it didnt. Thats about it.

ok() prints out either "ok" or "not ok" along with a test number (it keeps track of that for you).

# This produces "ok 1 - Hell not yet frozen over" (or not ok)
ok( get_temperature($hell) > 0, Hell not yet frozen over );

If you provide a $name, that will be printed along with the "ok/not ok" to make it easier to find your test when if fails (just search for the name). It also makes it easier for the next guy to understand what your test is for. Its highly recommended you use test names.

All tests are run in scalar context. So this:

ok( @stuff, I have some stuff );
will do what you mean (fail if stuff is empty)

Test::Simple will start by printing number of tests run in the form "1..M" (so "1..5" means youre going to run 5 tests). This strange format lets Test::Harness know how many tests you plan on running in case something goes horribly wrong.
If all your tests passed, Test::Simple will exit with zero (which is normal). If anything failed it will exit with how many failed. If you run less (or more) tests than you planned, the missing (or extras) will be considered failures. If no tests were ever run Test::Simple will throw a warning and exit with 255. If the test died, even after having successfully completed all its tests, it will still be considered a failure and will exit with 255.

So the exit codes are...
0 all tests successful
255 test died or all passed but wrong # of tests run
any other number how many failed (including missing or extras)

If you fail more than 254 tests, it will be reported as 254.

This module is by no means trying to be a complete testing system. Its just to get you started. Once youre off the ground its recommended you look at Test::More.

The aim of CMS Made Simple is to supply a simple and effective way of managing content of primarily static sites. Before you can ask why you need a content management system for a site that doesnt change its content, let me tell you.
There are tons of content management systems out there but they are basically all the same. Other CMS systems are great if you have a lot of news or articles on your site, but what if your site content doesnt change a lot, or only small parts of it change? Doesnt make a lot of sense to create a new entry in your blog style site just for a simple update, and whats the point of having time stamped blog entries if you are constantly updating them? Voila, in comes CMS Made Simple.
CMS lets you update your pages and keep the content on a static page that will not become stale regardless of how much other content gets placed on your site, unlike a blog style site where entries get pushed off the page and your users have to check the archives or know an obscure link to get to the original story.
Main features:
- Easy user and group management
- Group-based permission system
- Intelligent caching mechanism to only get what is necessary from the database
- Full template support, for unlimted looks without changing a line of content
- Easy wizard based install and upgrade procedures
- Minimal requirements
- Admin panel with multiple language support
- Integrated, Optional WYSIWYG
- Content hierarchy with unlimited depth and size
- Optional self-generating menus
- Integrated file manager w/ upload capabilities
- Module API for unlimited expandability
- Integrated audit log
- Included News module
- Included RSS module
- Ability to program simple PHP coded plugins right inside the admin
- Friendly support in forums and irc

PHP Simple Informer is a very simple network services monitoring application written in PHP. PHP Simple Informer can be run as a command line application (PHP compiled as cgi is required) or as a web php file.
Although is very simple, it does its function very well. Is very easy to configure with a single file and a couple of simple lines.
I dont know if this is going to be useful for anybody, but its for me. I have been testing several applications, and all of them are more complex that what I need or they dont perform so simple tasks.
Main features:
- Very simple installation and configuration: one single config file and done.
- Multiple hosts configuration
- Support for special features for services: mysql, http, https.
- Multiple contacts configuration
- Alerts are sent by email or with an executed external command.
- Logs issues to log file.
- Report / status web page.

LJ::Simple is a Perl module to provide a simple OOP-based API for accessing the LiveJournal system.
Main features:
- Log into LiveJournal
- Post a journal entry
- Edit a journal entry
- Delete a journal entry
Example
The following example posts a simple message into the test LiveJournal using the LJ::Simple::QuickPost method.
use LJ::Simple;
LJ::Simple::QuickPost(
user => "test",
pass => "test",
entry => "Just a simple entry",
) || die "$0: Failed to post entry: $LJ::Simple::errorn";
The next example shows how to post an entry into the test LiveJournal using the complete, object-based, interface:
use LJ::Simple;
my $lj = new LJ::Simple ({
user => "test",
pass => "test",
});
(defined $lj)
|| die "$0: Failed to log into LiveJournal: $LJ::Simple::errorn";
my %Event=();
$lj->NewEntry(%Event) ||
die "$0: Failed to create new entry: $LJ::Simple::errorn";
my $entry=SetMood(%Event,"happy")
|| die "$0: Failed to set mood: $LJ::Simple::errorn";
$lj->Setprop_nocomments(%Event,1);
my ($item_id,$anum,$html_id)=$lj->PostEntry(%Event);
(defined $item_id)
|| die "$0: Failed to post journal entry: $LJ::Simple::errorn";