Free introduction software for linux

AI::Prolog::Introduction Perl module contains the what and the why of logic programming.

You can skip this if you already know logic programming.

Note that most of this was pulled from my write-up about logic programming in Perl at http://www.perlmonks.org/?node_id=424075.

In Perl, generally you can append one list to another with this:

my @Z = (@X, @Y);

However, thats telling the language what to do. As sentient beings, we can look at that and infer more information. Given @Z and @X, we could infer @Y. Given just @Z, we could infer all combinations of @X and @Y that can be combined to form @Z.

Perl cannot do that. In logic programming, however, by defining what append() looks like, we get all of that other information.

In Prolog, it looks like this:

append([], X, X).
append([W|X],Y,[W|Z]) :- append(X,Y,Z).

(Theres actually often something called a "cut" after the first definition, but well keep this simple.)

What the above code says is "appending an empty list to a non-empty list yields the non-empty list." This is a boundary condition. Logic programs frequently require a careful analysis of boundary conditions to avoid infinite loops (similar to how recursive functions in Perl generally should have a terminating condition defined in them.)

The second line is where the bulk of the work gets done. In Prolog, to identify the head (first element) of a list and its tail (all elements except the first), we use the syntax [head|tail]. Since ":-" is read as "if" in Prolog, what this says if we want to concatenate (a,b,c) and (d,e,f):

Given a list with a head of W and a tail of X:

@list1 = qw/a b c/; (qw/a/ is W, the head, and qw/b c/ is X, the tail)

If its appended to list Y:

@Y = qw/d e f/;

We get a list with a head of W and a tail of Z:

@list2 = qw/a b c d e f/;

Only if X appended to Y forms Z:

X is qw/b c/. Y is qw/d e f/. Z is qw/b c d e f/.

IRCTree is a project which shows a tree representing the structure of an IRC network in ASCII.

Introduction

IRCTree shows a tree in ascii format representing the structure of an
IRC network.

You need netcat (nc) for it to work.

Example uses

$ irctree irc.swipnet.se

Compiling

No need to compile, but you can copy it into /usr/local/bin with make install.

Trustix Secure Linux is a Linux distribution for servers with focus on security and stability.
Trustix Secure Linux was specifically designed for the server market. With a focus on security and stability, the whole system benefits from a fully automatic update agent known as SWUP, eliminating the most critical issue of server security - Patch management.
Enhancements:
- The Comodo Trustix team is proud to announce the release of Trustix Secure Linux 3.0.5, an update to the previous Tikka Masala. The new release is named Mirch Masala to describe the new interesting changes associated. This release has its major change from the previous release of 3.0 with the re-introduction of Anaconda as the preferred choice of installer. In addition, most packages have been upgraded to their latest versions upon customer requests. The core updates available are: kernel 2.6.19.7, PostgreSQL 8.2.3, MySQL 5.0.27, CP+ 3.3, Samba 3.0.24.

Persistent::DBI is an Abstract Persistent Class implemented using a DBI Data Source.

SYNOPSIS

### we are a subclass of ... ###
use Persistent::DBI;
@ISA = qw(Persistent::DBI);

ABSTRACT

This is an abstract class used by the Persistent framework of classes to implement persistence using DBI data stores. This class provides the methods and interface for implementing Persistent DBI classes. Refer to the Persistent
documentation for a very thorough introduction to using the Persistent
framework of classes.

This class is part of the Persistent DBI package which is available from:

http://www.bigsnow.org/persistent
ftp://ftp.bigsnow.org/pub/persistent

Before we get started describing the methods in detail, it should be noted that all error handling in this class is done with exceptions. So you should wrap an eval block around all of your code. Please see the Persistent documentation for more information on exception handling in Perl.

XML::SAX::Intro is an Introduction to SAX Parsing with Perl.

XML::SAX is a new way to work with XML Parsers in Perl. In this article well discuss why you should be using SAX, why you should be using XML::SAX, and well see some of the finer implementation details. The text below assumes some familiarity with callback, or push based parsing, but if you are unfamiliar with these techniques then a good place to start is Kip Hamptons excellent series of articles on XML.com.

Replacing XML::Parser

The de-facto way of parsing XML under perl is to use Larry Wall and Clark Coopers XML::Parser. This module is a Perl and XS wrapper around the expat XML parser library by James Clark. It has been a hugely successful project, but suffers from a couple of rather major flaws. Firstly it is a proprietary API, designed before the SAX API was conceived, which means that it is not easily replaceable by other streaming parsers. Secondly its callbacks are subrefs. This doesnt sound like much of an issue, but unfortunately leads to code like:

sub handle_start {
my ($e, $el, %attrs) = @_;
if ($el eq foo) {
$e->{inside_foo}++; # BAD! $e is an XML::Parser::Expat object.
}
}

As you can see, were using the $e object to hold our state information, which is a bad idea because we dont own that object - we didnt create it. Its an internal object of XML::Parser, that happens to be a hashref. We could all too easily overwrite XML::Parser internal state variables by using this, or Clark could change it to an array ref (not that he would, because it would break so much code, but he could).

The only way currently with XML::Parser to safely maintain state is to use a closure:

my $state = MyState->new();
$parser->setHandlers(Start => sub { handle_start($state, @_) });

This closure traps the $state variable, which now gets passed as the first parameter to your callback. Unfortunately very few people use this technique, as it is not documented in the XML::Parser POD files.

Another reason you might not want to use XML::Parser is because you need some feature that it doesnt provide (such as validation), or you might need to use a library that doesnt use expat, due to it not being installed on your system, or due to having a restrictive ISP. Using SAX allows you to work around these restrictions.

libredblack is a library to provide the RedBlack balanced tree searching and sorting algorithm.

The algorithm was taken from the book "Introduction to Algorithms" by Cormen, Leiserson & Rivest. Frankly I never entirely understood it, but it most definately works!

What is the problem with normal binary trees?: A standard binary tree only works well if the original data is provided in a random order (random in terms of the key being sorted on). If however the data is provided in order, then the tree becomes very un-balanced and searches degrade into nothing more than a linked list.

How is the RedBlack tree different?: The RedBlack tree acts in a way to keep the overall tree fairly balanced as new data is loaded in.

How does it work?: The tree is always organised such that it has the following properties:

Every node is either Red or Black.

A leaf node (a dummy empty node at the end of the tree) is always Black.
If a node is Red then its children are Black.

Every path from the root to a leaf contains the same number of Black nodes.
So from 3 & 4 above, we can see that the longest path (alternating Red and Black nodes) is only twice as long as the shortest path (all Black nodes). Thus the tree remains fairly balanced.

Great! How does it maintain those properties?: Ah, well, thats where I get a bit hazy. I know that it does this by adding Red nodes and then rotating the tree elements and changing the colours to sort out times when two Red nodes become parent-child (breaking rule 3).

The friendly interactive shell is a user friendly shell intended mostly for interactive use.
- If you want to see screenshots of fish in action, click here.
- If you are familiar with the basics of shells,read this page for a short introduction to fish.
- If you are dont know how to use a shell, read this page for a longer presentation on how to use fish.

VirtualBox application is a family of powerful x86 virtualization products for enterprise as well as home use. Not only is VirtualBox an extremely feature rich, high performance product for enterprise customers, it is also the only professional solution that is freely available as Open Source Software under the terms of the GNU Public License (GPL). See "About VirtualBox" for an introduction; see "InnoTek" for more about our company.

Presently, VirtualBox runs on Windows and Linux 32-bit hosts and supports a large number of guest operating systems including but not limited to Windows (NT 4.0, 2000, XP, Server 2003, Vista), DOS/Windows 3.x, Linux (2.4 and 2.6), and OpenBSD.

VirtualBox is being actively developed with frequent releases and has an ever growing list of features, supported guest operating systems and platforms it runs on. VirtualBox is a community effort backed by a dedicated company: everyone is encouraged to contribute while InnoTek ensures the product always meets professional quality criteria.