Free para 0.05 software for linux

Convert::Wiki::Node::Para is a Perl module that represents a text paragraph node.

SYNOPSIS

use Convert::Wiki::Node::Para;

my $para = Convert::Wiki::Node->new( txt => Foo is a foobar., type => para );

print $para->as_wiki();

A Convert::Wiki::Node::Para represents a normal text paragraph.

Prelaunch is a utility for the Linux desktop which significantly decrease the time to launch programs.

Pre- launch start the respective program during login not visible to the user. With this trick the real launch needs no time. It is written in C and GTK.

*Prelaunch will work with every desktop environment but only Gnome is supported at the moment (Adding new apps...).

ulogipac is a powerful IP traffic accounting tool for Linux routers and hosts. You can use the power of iptables rules to specify which traffic you want to account and which *not*. The size of IP packets sent to ulogipac through iptables is counted and buffered. After a configurable timeperiod you can submit the traffic information to your database servers (currently only MySQL is supported). You can specify 1 to N servers to send traffic information to.

Once ulogipac is installed you can start using it in combination with iptables rules. Normally you want to account traffic, which is routed to a linux router from one network interface to another or others (for example ppp devices terminating PPTP/PPPOE/DIALIN sessions).

Aften project is a simple, open-source, A/52 (AC-3) audio encoder.
Main features:
- Implemented my own wav reader
- Converted the fixed-point algorithms to floating-point
- Rearranged the methods and structures
- Added stereo rematrixing (mid/side)
- Added short block MDCT and block switching
- Added VBR encoding mode
- Added variable bandwidth
- Added more complete WAV format support
- Added support for using the alternate bit stream syntax
- Created separate library and frontend
- Added input filters
Enhancements:
- Bit allocation speedups, a compile-time choice of using floats or doubles internally, an internal restructuring of MDCT functions, and bugfixes. quality=0 is now a valid setting.

Template::Recall is a "Reverse callback" templating system.



SYNOPSIS

use Template::Recall;

my $tr = Template::Recall->new( template_path => /path/to/template/sections );

my @prods = (
soda,sugary goodness,$.99,
energy drink,jittery goodness,$1.99,
green tea,wholesome goodness,$1.59
);

$tr->render(header);

# Load template into memory

$tr->preload(prodrow);

for (@prods)
{
my %h;
my @a = split(/,/, $_);

$h{product} = $a[0];
$h{description} = $a[1];
$h{price} = $a[2];

print $tr->render(prodrow, %h);
}

# Remove template from memory

$tr->unload(prodrows);

print $tr->render(footer);

Template::Recall works using what I call a "reverse callback" approach. A "callback" templating system (i.e. Mason, Apache::ASP) generally includes template markup and code in the same file. The template "calls" out to the code where needed. Template::Recall works in reverse. Rather than inserting code inside the template, the template remains separate, but broken into sections. The sections are called from within the code at the appropriate times.

Tie::Trace can easy print debugging with tie.

SYNOPSIS

use Tie::Trace;

my %hash;
tie %hash, "Tie::Trace";

$hash{hoge} = hogehoge; # warn Hash => Key: hoge, Value: hogehgoe at ...

my @array;
tie @aray, "Tie::Trace";
push @array, "array"; # warn Array => Point: 0, Value: array at ...

my $scalar;
tie $scalar, "Tie::Trace";
$scalar = "scalar"; # warn Scalar => Value: scalar at ...

This is usefull for print debugging. Using tie mechanism, you can see sotred value for the specified variable.

If the stored value is scalar/array/hash ref, this can check recursively.

for example;
tie %hash, "Tie::Trace";

$hash{foo} = {a => 1, b => 2}; # warn ...
$hash{foo}->{a} = 2 # warn ...

But This ignores blessed reference and tied value.

Para::Frame is a system to use for dynamic web sites. Para::Frame runs as a backend daemon taking page requests from a Apache mod_perl client and returns a HTTP response.
The URLs in the site corresponds to templates for displaying information. Operations on the data is put in perl modules separated from the templates.
Para::Frame handles multitasking within the process, enabeling you to keep your initialized objects in memory with no need to sync with the DB for each request.
The session data lives in memory. No need to save it in an external format.
Para::Frame uses "routes" for planning things to do in a session, taking care of which page to display next, depending on form actions. Integrated with exception handling.
One Para::Frame daemon can handle many sites on the same server. It uses the Apache configuration for handling URL to file translation.
You can have any number of Para::Frame daemons running in parallell on the same server. Maby using one for development, one for the stable version and one backup in case of failure. You can easily configure the site to use a backup daemon as a last resort.
A Watchdog makes sure that the system works. It pings the daemon in regular intervals and restarts it if locks up or if the memory limit is reached. The restart is done by forking.
There are tons of useful functions.
Enhancements:
- A lot of major changes and additions were made.
- 19 new classes were added, including classes for relational database access, internationalization, and file and directory handling.
- The server/client communication has changed and is now safer and faster.
- A load-page will display a progress report from the server before the new page is loaded.
- The html/pf directory now contains some default images, styles, JavaScript, and more.
- A demo has been included.

Java::Build is a family of modules which you can use instead of Ant.

SYNOPSIS

use Java::Build::JVM; # access to the javac compiler in one jvm
use Java::Build::Tasks; # some helpful methods similar to Ant tasks

my $source_files = build_file_list(
BASE_DIR => $some_path,
INCLUDE_PATTERNS => [ qr/.java$/ ],
);
my $dirty_sources = what_needs_compiling(
SOURCE_FILE_LIST => $source_files,
);
if (@$dirty_sources) {
my $compiler = Java::Ant::JVM->getCompiler();
$compiler->destination($base_dir);
$compiler->classpath($base_dir);
$compiler->compile($dirty_sources);

my $class_files = build_file_list(
BASE_DIR => $some_path,
INCLUDE_PATTERNS => [ qr/.class$/ ],
EXCLUDE_PATTERNS => [ qr/Test/ ],
EXCLUDE_DEFAULTS => 1,
STRIP_BASE_DIR => 1,
);
jar(
JAR_FILE => $jar_file_name,
FILE_LIST => $class_files,
BASE_DIR => $some_path,
);
}

ABSTRACT

This family of modules helped me move away from Ant to a proper scripting language, namely Perl. With it you can use a single JVM for compiling your java programs. It provides many useful methods to help you build lists of files, package them with jar, etc. Currently the modules are unix centric. If you make them work elsewhere, please send in patches.