Free jukes family software for linux

MyNukeGenealogy for PHPNuke or PostNuke is a plugin-module which helps building up a family or surname Web site.

It allows for displaying and editing genealogical data (individuals, families, events, notes, sources, etc.) and importing gedcom files (export functionalities will follow).

It has a flexible template system to customise the layout and design.

TheCurves is an application that plots a parameterized family of curves based on algebraic formulas specified by the user. This project is meant as an educational tool for mathematics, physics, and engineering.
When the program is run as an applet in a Web page, the plot parameters and formulas are configurable by HTML and dynamically scriptable, so that the applet can be initialized to present a specific plot when the page is opened or to change plots when the user clicks on a control in the Web page.
Enhancements:
- This version now uses the ant build system.

AsmFile is a small and fast file manager written in assembler.

AsmFile project uses a two pane interface like "mc" and other file managers. AsmFile runs in a console or a terminal window.

Assembly has been ignored by much of the Unix/Linux community and is almost never found in desktop applications. Some of the reasons for this are historical and related to portability. Other reasons include negative images of assembly and lack of tools. Today a small niche exists for assembly on the desktop. This will be explored here along with the supporting tools.

The resources section provides links to more information and places to discuss assembler topics. Of special interest to the author is a section of predictions and history. A email list for programmers interested in Desktop assembly is described in the resources section.

The AsmIDE family of programs are currently underdevelopment and some have reached a useful state.

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.

Socket6 is a Perl module for IPv6 related part of the C socket.h defines and structure manipulators.

SYNOPSIS

use Socket;
use Socket6;

@res = getaddrinfo(hishost.com, daytime, AF_UNSPEC, SOCK_STREAM);
$family = -1;
while (scalar(@res) >= 5) {
($family, $socktype, $proto, $saddr, $canonname, @res) = @res;

($host, $port) = getnameinfo($saddr, NI_NUMERICHOST | NI_NUMERICSERV);
print STDERR "Trying to connect to $host port port $port...n";

socket(Socket_Handle, $family, $socktype, $proto) || next;
connect(Socket_Handle, $saddr) && last;

close(Socket_Handle);
$family = -1;
}

if ($family != -1) {
print STDERR "connected to $host port port $portn";
} else {
die "connect attempt failedn";
}

This module provides glue routines to the various IPv6 functions.
If you use the Socket6 module, be sure to specify "use Socket" as well as "use Socket6".

Functions supplied are:

inet_pton FAMILY, TEXT_ADDRESS
This function takes an IP address in presentation (or string) format
and converts it into numeric (or binary) format.
The type of IP address conversion (IPv4 versus IPv6) is controlled
by the FAMILY argument.
inet_ntop FAMILY, BINARY_ADDRESS
This function takes an IP address in numeric (or binary) format
and converts it into presentation (or string) format
The type of IP address conversion (IPv4 versus IPv6) is controlled
by the FAMILY argument.
pack_sockaddr_in6 PORT, ADDR
This function takes two arguments: a port number, and a 16-octet
IPv6 address structure (as returned by inet_pton()).
It returns the sockaddr_in6 structure with these arguments packed
into their correct fields, as well as the AF_INET6 family.
The other fields are not set and their values should not be relied upon.
pack_sockaddr_in6_all PORT, FLOWINFO, ADDR, SCOPEID
This function takes four arguments: a port number, a 16-octet
IPv6 address structure (as returned by inet_pton), any
special flow information, and any specific scope information.
It returns a complete sockaddr_in6 structure with these arguments packed
into their correct fields, as well as the AF_INET6 family.
unpack_sockaddr_in6 NAME
This function takes a sockaddr_in6 structure (as returned by
pack_sockaddr_in6()) and returns a list of of two elements:
the port number and the 16-octet IP address.
This function will croak if it determines it has not been
passed an IPv6 structure.
unpack_sockaddr_in6_all NAME
This function takes a sockaddr_in6 structure (as returned by
pack_sockaddr_in6()) and returns a list of of four elements:
the port number, the flow information, the 16-octet IP address,
and the scope information.
This function will croak if it determines it has not been
passed an IPv6 structure.
gethostbyname2 HOSTNAME, FAMILY
getaddrinfo NODENAME, SERVICENAME, [FAMILY, SOCKTYPE, PROTOCOL, FLAGS]
This function converts node names to addresses and service names
to port numbers.
If the NODENAME argument is not a false value,
then a nodename to address lookup is performed;
otherwise a service name to port number lookup is performed.
At least one of NODENAME and SERVICENAME must have a true value.

If the lookup is successful, a list consisting of multiples of
five elements is returned.
Each group of five elements consists of the address family,
socket type, protocol, 16-octet IP address, and the canonical
name (undef if the node name passed is already the canonical name).

The arguments FAMILY, SOCKTYPE, PROTOCOL, and FLAGS are all optional.

This function will croak if it determines it has not been
passed an IPv6 structure.
If the function returns an error value,
the string version of that error will be returned as a single scalar.
getnameinfo NAME, [FLAGS]
This function takes a socket address structure and returns either
a node or service name.
The optional FLAGS argument controls what kind of lookup is performed.
getipnodebyname HOST, [FAMILY, FLAGS]
This function takes either a node name or an IP address string
and performs a lookup on that name (or conversion of the string).
It returns a list of five elements: the canonical host name,
the address family, the length in octets of the IP addresses
returned, a reference to a list of IP address structures, and
a reference to a list of aliases for the host name.

The arguments FAMILY and FLAGS are optional.
Note: This function does not handle IPv6 scope identifiers,
and should be used with care.
And, this function was deprecated in RFC3493.
The getnameinfo function should be used instead.
getipnodebyaddr FAMILY, ADDRESS
This function takes an IP address family and an IP address structure
and performs a reverse lookup on that address.
It returns a list of five elements: the canonical host name,
the address family, the length in octets of the IP addresses
returned, a reference to a list of IP address structures, and
a reference to a list of aliases for the host name.

Note: This function does not handle IPv6 scope identifiers,
and should be used with care.
And, this function was deprecated in RFC3493.
The getaddrinfo function should be used instead.
gai_strerror ERROR_NUMBER
This function returns a string corresponding to the error number
passed in as an argument.
in6addr_any
This function returns the 16-octet wildcard address.
in6add_loopback
This function returns the 16-octet loopback address.

In Angry, Drunken Dwarves, you are an angry, drunken dwarf. Why are you so angry? Who knows. But youve decided to take your aggression out on other dwarves, by dropping gems on their heads.

Lots of gems. Angry, Drunken Dwarves is a member of the classic "falling blocks" puzzle game family, similar to the Capcom game Puzzle Fighter.

The goal of the game is to build large gems by matching up colors, then break them, raining more gems down onto your opponent. The first person whose field fills up, loses.

Angry, Drunken Dwarves runs on all major operating systems. It has seven playable characters, six levels of AI, secret game modes and characters, and an original soundtrack.