Free latest software for linux

Meteosat is a SuperKaramba theme that integrate latest meteosat image in the desktop.

The fetched image is processed by imagemagick (required), to obtain a "soft start border", through png opacity.

libtsmux is a C library for muxing files into the MPEG Transport Stream container format.
The project can be used to quickly add MPEG Transport Stream muxing capabilities to any application or framework. A GStreamer plugin using the library is available.
Enhancements:
- The muxer library was updated to conform to the latest version of Dirac in the MPEG-TS specification.
- Various minor bugs were fixed.

Gyahtzee project is a gnomified version of yahtzee.
It is based on a curses version released by Orest Zborowski in 1992.
All versions can be compiled for curses or Gnome support.
Enhancements:
- CVS version.
- Color curses support.
- Update for latest gtk.

jabberd2 is a Jabber/XMPP instant messaging server. It implements most of XMPP (RFC3920), XMPP-IM (RFC3921) and a range of protocol extensions (JEP-0011, JEP-0012, JEP-0022, JEP-0023, JEP-0030, JEP-0049, JEP-0054, JEP-0077, JEP-0078, JEP-0086, JEP-0090, JEP-0091, JEP-0092, JEP-0094, and JEP-0114)

jabberd 2 is the next generation of the jabberd server. jabberd2 project has been rewritten from the ground up to be scalable, architecturally sound, and to support the latest protocol extensions coming out of the JSF.

vNews provides a site news script used to relay the latest information regarding any topic to visitors.

vNews is a site news script used to relay the latest information regarding any topic to visitors. And being a part of vScripts, vNews comes with a powerful and flexible administration module where administrators/webmasters can easily change the look of the embedded news to conform with their existing site design.

Object::Realize::Later is a Perl module with delayed creation of objects.

SYNOPSIS

package MyLazyObject;

use Object::Realize::Later
becomes => MyRealObject,
realize => load;

The Object::Realize::Later class helps with implementing transparent on demand realization of object data. This is related to the tricks on autoloading of data, the lesser known cousin of autoloading of functionality.

On demand realization is all about performance gain. Why should you spent costly time on realizing an object, when the data on the object is never (or not yet) used? In interactive programs, postponed realization may boost start-up: the realization of objects is triggered by the use, so spread over time.

METHODS

Construction

use(Object::Realize::Later OPTIONS)

When you invoke (use) the Object::Realize::Later package, it will add a set of methods to your package (see section "Added to YOUR class").

Option --Default
becomes < required >
believe_caller < false >
realize < required >
source_module < becomes >
warn_realization < false >
warn_realize_again < false >
. becomes CLASS

Which type will this object become after realization.

. believe_caller BOOLEAN

When a method is called on the un-realized object, the AUTOLOAD checks whether this resolves the need. If not, the realization is not done. However, when realization may result in an object that extends the functionality of the class specified with becomes, this check must be disabled. In that case, specify true for this option.

. realize METHOD|CODE

How will transform. If you specify a CODE reference, then this will be called with the lazy-object as first argument, and the requested method as second.
After realization, you may still have your hands on the lazy object on various places. Be sure that your realization method is coping with that, for instance by using Memoize. See examples below.

. source_module CLASS

if the class (a package) is included in a file (module) with a different name, then use this argument to specify the file name. The name is expected to be the same as in the require call which would load it.

. warn_realization BOOLEAN

Print a warning message when the realization starts. This is for debugging purposes.

. warn_realize_again BOOLEAN

When an object is realized, the original object -which functioned as a stub- is reconstructed to work as proxy to the realized object. This option will issue a warning when that proxy is used, which means that somewhere in your program there is a variable still holding a reference to the stub. This latter is not problematic at all, although it slows-down each method call.

Added to YOUR class

$obj->AUTOLOAD

When a method is called which is not available for the lazy object, the AUTOLOAD is called.

$obj->can(METHOD)

Object::Realize::Later->can(METHOD)

Is the specified METHOD available for the lazy or the realized version of this object? It will return the reference to the code.

Example:

MyLazyObject->can(lazyWork) # true
MyLazyObject->can(realWork) # true

my $lazy = MyLazyObject->new;
$lazy->can(lazyWork); # true
$lazy->can(realWork); # true
$obj->forceRealize

You can force the load by calling this method on your object. It returns the realized object.

Object::Realize::Later->isa(CLASS)

Is this object a (sub-)class of the specified CLASS or can it become a (sub-)class of CLASS.

Example:

MyLazyObject->isa(MyRealObject) # true
MyLazyObject->isa(SuperClassOfLazy); # true
MyLazyObject->isa(SuperClassOfReal); # true

my $lazy = MyLazyObject->new;
$lazy->isa(MyRealObject); # true
$lazy->isa(SuperClassOfLazy); # true
$lazy->isa(SuperClassOfReal); # true
$obj->willRealize

Returns which class will be the realized to follow-up this class.

Object::Realize::Later internals

The next methods are not exported to the class where the `use took place. These methods implement the actual realization.

Object::Realize::Later->import(OPTIONS)

The OPTIONS used for import are the values after the class name with use. So this routine implements the actual option parsing. It generates code dynamically, which is then evaluated in the callers name-space.

Object::Realize::Later->realizationOf(OBJECT [,REALIZED])

Returns the REALIZED version of OBJECT, optionally after setting it first. When the method returns undef, the realization has not yet taken place or the realized object has already been removed again.

Object::Realize::Later->realize(OPTIONS)

This method is called when a $object-forceRealize()> takes place. It checks whether the realization has been done already (is which case the realized object is returned)

TwistedJava provides an implementation of the Perspective Broker protocol in Java.
TwistedJava is an LGPLed implementation of the Perspective Broker protocol for Java. PB is a remote object protocol, similar to RMI, supporting multiple programming languages.
Included is a policy (Straw) written by Brandon Wiley that lets you use remote Java objects transparently.
You can read the README for the latest version, or read the API javadocs.
Enhancements:
- Adds support for logging in to Twisted 1.1 PB servers.