Free parallels workstation software for linux

Remind is a sophisticated calendar and alarm program.
Remind also includes scripts for making a nice WWW calendar server.
Main features:
- A sophisticated scripting language and intelligent handling of exceptions and holidays.
- Plain-text, PostScript and HTML output.
- Timed reminders and pop-up alarms.
- A friendly graphical front-end for people who dont want to learn the scripting language.
- Facilities for both the Gregorian and Hebrew calendars.
- Support for 12 different languages.
Enhancements:
- A FROM clause has been added to the Remind scripting language; this is the counterpart to UNTIL.
- A new DATETIME datatype lets you manipulate a date and time as a single unified object.
- The SPECIAL COLOR and SPECIAL HTML reminders sort with normal reminders.
- TkRemind can email you reminders if you leave your workstation unattended.
- There are several other minor enhancements and bugfixes.

Java Parallel Processing Framework is a set of tools and APIs to facilitate the parallelization of CPU intensive applications, and distribute their execution over a network of heterogenous nodes.
Java Parallel Processing Framework is intended to run in clusters and grids.
Main features:
- an API to delegate the processing of parallelized tasks to local and remote execution services
- a set of APIs and user interface tools to administrate and monitor execution services
- real-time adaptive load balancing capabilities
- scalability up to an arbitrary number of processing nodes
- support for failover and recovery
- limited intrusiveness for existing or legacy code
- a dynamic deployment mechanism, that enables the execution of new, or updated, code without having to deploy onto the grid
- fully documented APIs, administration guide and developer guide
- runs on any platform supporting Java 2 Platform Standard Edition 5.0 (J2SE 1.5)
Enhancements:
- JPPF is now licensed under the terms of the Apache License, Version 2.0. Starting from JPPF 1.0 beta1, all releases will be licensed under these terms.
- Prior versions will remain under the terms of the LGPL.
- For the first time, JPPF integrates seamlessly with J2EE. The JPPF Resource Adapter provides J2EE application servers with an access to native grid services.
- Numerous bug fixes, especially with regards to the distributed class loading mechanism.

Parallel BZIP2 project is a parallel implementation of the bzip2 block- sorting file compressor that uses pthreads and achieves near-linear speedup on SMP machines. The output of this version is fully compatible with bzip2 1.0.2 (ie: anything compressed with PBZIP2 can be decompressed with bzip2).

PBZIP2 should work on any system that has a pthreads compatible C++ compiler (such as gcc). It has been tested on: Linux, Windows (cygwin & MinGW), Solaris, Tru64/OSF1, HP-UX, and Irix.

Parallel MPI BZIP2 is a parallel implementation of the bzip2 block-sorting file compressor that uses MPI and achieves significant speedup on cluster machines.

The output of this version is fully compatible with bzip2 v1.0.2 or newer (ie: anything compressed with mpibzip2 can be decompressed with bzip2). MPIBZIP2 should work on any system that has a pthreads compatible C++ compiler (such as gcc). It has been tested on: Linux and Solaris.

NOTE: If you are looking for a parallel BZIP2 that works on multi-processor/muti-core/SMP machines, you should check out PBZIP2 which was designed for a multi-threaded shared-memory architecture.

Usage:

Run mpibzip2 for the help listing.
==================================================================
Usage: mpibzip2 [-1 .. -9] [-b#cdfktvV] < filename > < filename2 > < filenameN >

-b#: where # is the file block size in 100k (default 9 = 900k)
-c : output to standard out (stdout)
-d : decompress file
-f : force, overwrite existing output file
-k : keep input file, dont delete
-t : test compressed file integrity
-v : verbose mode
-V : display version info for mpibzip2 then exit
-1 .. -9 : set BWT block size to 100k .. 900k (default 900k)

Example: mpibzip2 -b15k myfile.tar
Example: mpibzip2 -v -5 myfile.tar second*.txt
Example: mpibzip2 -d myfile.tar.bz2

Wordpress project is the leading open source blogging platform that has rocketed to popularity thanks to its open design and powerful features. This JumpBox includes Wordpress version 2.1.2.

WHY USE A JUMPBOX

Its Simple

Open Source applications are great. The applications are powerful, inexpensive and get the job done. But installing and configuring those applications can be a pain. A JumpBox delivers Open Source applications in a way that makes them simple to try, run and operate.

Its Quick

Actually downloading a JumpBox will take the most time. Once thats done, youre just a few minutes from having a working application that can serve multiple users.

Its Portable

A JumpBox collects the application, application dependencies and all application data into a single bundle that can easily be moved from one computer to another. This allows you to start running the application on your desktop and then as usage grows move it to a server without needing to reinstall or reconfigure. Plus with support for Mac OS X, Windows and Linux you can even move the application between platforms with little effort.

Its Safe

Manually installing Open Source applications not only takes a lot of time and effort, but when youre done its still left to you to figure out how to protect the data the application manages. With a JumpBox its easy to add automatic backups of the entire state of the application.

Its Virtual

A JumpBox application is a virtual appliance that bundles the open source application and all its runtime dependencies into a single package that runs on top of virtualization software from VMWare, Parallels or Xen. This means all JumpBox applications automatically gain the benefits of traditional server virtualization and can be dropped into existing virtualization infrastructure when available.

Its Comfortable

JumpBox provides a consistent runtime environment for all applications that we bundle. The applications may differ considerably, but their installation and operation will be familiar no matter which JumpBox you choose.

ARAnyM comes from Atari Running on Any Machine and is virtual machine software for running the Atari ST/TT/Falcon OS.
It is a virtual machine software for running the Atari ST/TT/Falcon operating systems (TOS, FreeMiNT, MagiC and others) and TOS/GEM applications on any kind of hardware - be it an IBM clone (read it as "PC", an Apple, an Unix server, a graphics workstation or even a portable computer.
We started this project to fill the demand of modern applications, games, demos and multimedia for higher CPU/graphics power. Quite frankly, you cant expect that 9-17 years old Atari hardware will replay fullscreen DivX movies, encode sound to Ogg Vorbis in real time or just compile a new FreeMiNT kernel or SDL game in a reasonable amount of time. Is that a reason to give up on Atari TOS/GEM altogether and switch to another platform/OS? No! ARAnyM is here to give you the much asked CPU speed, large amount of RAM, huge colourful graphics and anything else you need to keep running your favorite TOS/GEM applications.
We would like you to think about ARAnyM as about yet another TOS clone, similar to Medusa, Hades or Milan, but actually much cheaper and way more powerful. Our goal is to create a distribution installable from a floppy/CD that would turn any PC machine into full featured Atari power machine. If we were a hardware vendor we could even sell computers that would boot directly to TOS desktop! That could help all the remaining Atari users that wish to upgrade their aging machines.
Main features:
- MC68040 compatible CPU (including optional MMU!)
- MC68881 compatible FPU
- JIT Compiler for CPU and FPU (speeds up CPU+FPU up to 10x!)
- ST-RAM 14 MB
- Fast-RAM configurable 0-3824 MB
- Host accelerated fVDI graphics (large highcolor/truecolor resolutions)
- Access to Host OS filesystems using BetaDOS or MiNT native XFS driver
- Ethernet networking via host using MiNT-Net XIF driver
- TOS 4.x XBIOS compatible sound (16-bit 48 kHz stereo sound)
- Parallel port (bidirectional)
- MFP, IKBD, ACIA, VIDEL, BLITTER, FDC, IDE, DSP MC56001
Please note that most hardware emulation is there just to make TOS booting possible. It is not our goal to create an emulator of existing Atari machine. Dont expect that ill-designed applications will work as they would on original Atari machine. Still, our compatibility ratio is much much higher than any of the TOS clones achieved so far.
ARAnyM has been intended to run primarily on Linux/x86 but thanks to libSDL and effort of some ARAnyM team members it currently runs on the following platforms and operating systems:
- All 11 Debian GNU/Linux platforms
- MS Windows/x86 (Cygwin)
- NetBSD/x86
- OpenBSD/x86
- MacOS X/PPC
- Irix/SGI
- Solaris/Sun Sparc
- FreeMiNT/m68k (in progress)
- FreeBSD/x86 (in progress)
Please note that ARAnyM is tested and fully working on the Linux-ia32 only. Some of the other platforms/systems might not have all features enabled or might suffer from some bugs that are caused by limitations of the particular host operating system.
Enhancements:
- New release brings major speed up of the MMU version. FreeMiNT with MMU or Linux-m68k can be run on an average ARAnyM machine faster than on any real MC680x0 now. Mac OS X target has been improved and many smaller bugs have been fixed.

File::Find::Parallel allows you to traverse a number of similar directories in parallel.

SYNOPSIS

use File::Find::Parallel;

my $ffp = File::Find::Parallel->new( qw( /foo /bar ) );

print "Union:n";
my $union = $ffp->any_iterator
print " $_n" while $_ = $union->();

print "Intersection:n";
my $inter = $ffp->all_iterator
print " $_n" while $_ = $inter->();

File::Find is the ideal tool for quickly scanning a single directory. But sometimes its nice to be able to perform operations on multiple similar directories in parallel. Perhaps you need to compare the contents of two directories or convert files that are shared in more than one directory into hard links.

This module manufactures iterators that visit each file and directory in either the union or the intersection of a number of directories. Hmm. What does that mean?

Given two directory trees like this

foo
foo/a
foo/b/c
foo/d

bar
bar/a
bar/b
bar/e

you can choose to work with the intersection of the two directory structures:
.
./a
./b

That is the subdirectories and files that the foo and bar share.
Alternately you can work with the union of the two directory structures:
.
./a
./b
./b/c
./d
./e

Still not clear? Well, if you wanted to do a recursive diff on the two directories youd iterate their union so you could report files that were present in foo but missing from bar and vice-versa.

If, on the other hand you wanted to scan the directories and find all the files that are common to all of them youd iterate their intersection and receive only files and directories that were present in all the directories being scanned.

The any_iterator and all_iterator are built on a more general purpose method: want_iterator. If, for example, you want to make links between files that are found in more than one directory you might get your iterator like this:

my $iter = $ffp->want_iterator( 2 );

The apparently magic 2 reflects the fact that if youre going to be making links you need at least two files. No matter how many directories you are iterating over in parallel you will only see files and directories that appear in at least two of those directories.

File::Find::Parallel can scan any number of directories at the same time. Heres an example (on Unix systems) that returns the list of all files and directories that are contained in all home directories.

use File::Glob :glob;
use File::Find::Parallel;

my $find = File::Find::Parallel->new( bsd_glob( /home/* ) );

my @common = ( );
my $iter = $find->all_iterator;
while ( defined my $obj = $iter->() ) {
push @common, $obj;
}

print "The following files are common to ",
"all directories below /home :n";

print " $_n" for @common;

For a complete concrete example of its use see lncopies in the bin subdirectory of this distribution.

Iterators

The iterator returned by any_iterator, all_iterator or want_iterator is a code reference. Call it to get the next file or directory. When all files and directories have been returned the iterator will return undef.

Once created an iterator is independent of the File::Find::Parallel object that created it. If the object goes out of scope and is destroyed during the life of the iterator it will still function normally.

You may have many active iterators for a single File::Find::Parallel object at any time.

Dolda Connect is a modular P2P filesharing client built around the Direct Connect model. It supports most of the latest features of the DC protocol.
It runs in client/server mode with a well defined protocol, allowing extensibility, flexibility, and multiple detachable user interfaces. Dolda Connect also has an optional multi-user mode.
For the average user, this yields two primary advantages:
- The daemon can be made to run on another computer, which can be on all the time (a server, if you will), while the user interface can run on the users workstation. That way, the user can turn off his workstation at night, while the server will continue all transfers in progress during that time.
- A user can control his daemon from another location, such as from work, school, a friend, etc.
This architecture also has many other advantages in store for the more advanced users; since the user interface communicates with the daemon using a well-defined protocol, other user interfaces can be written, such as an automatic downloader, a chatbot, etc. It is also designed for secure multiuser operation.
Enhancements:
- A GUI configurator tool was added.
- Portability issues were fixed so that it works on AMD64 now.
- The documentation was improved.
- The usual slew of minor bugs were fixed.