Free introduction to 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/.

MapGeneration Project is a project featuring a server and helper programs to collect GPS information from various sources and to then automatically generate a continuously improved, time annotated road map.
Nowadays gps-receivers are quite cheap and many people use them for route planning in their cars. On the other hand updated maps for the route planing systems are relativly expansive, if available at all.
The idea is to collect the data that people have recorded with their gps-receivers and combine it into one freely available road map. Besides being cheap and always current this map would also contain actual driving time information: Route planning on such a map would not have to use road type based approximations to calculate the fasted route.
In the MapGeneration Project we implement such a program and the end user tools needed to access the data. At the moment we concentrate on two programs: The MapGenerator itself and the MapGeneratorGUI used to administer the generator.
The MapGenerator is a server that accepts incoming data via network and combines the received road information into one big map. As the map might become quite big a database is used as storage. The MapGeneratorGUI connects to this database and displays the map.
As the best way to understand a program is to use it we will now give a short introduction to using the program.
Enhancements:
New features
- (Server) New filter to detect gaps in the input traces.
- (Server) Calculates and outputs total length and time of processed traces.
- (Server) Added full support for more than one processing thread, 2 is default now.
Changes
- (Server) Rewrote TraceServer and TraceConnection to support commoncpp2 1.0.x.
- (Server) Server tries to bind to 127.0.0.1 if no interfaces are found.
- (Server) Added curvature as a criterion for merging -> much better merging!
- (Server) Improved avoidance of double processing of nodes.
- (Server) Moved parsing of traces into TraceFilter.
- (General) Added lots of new methods to handle distances, bearings and interpolation.
- (General) Configuration system supports boolean values.
- (Buildsys) Changed parameters to specify config files to --with-wx-config and --with-ccgnu2-config
Bugfixes
- (Server) Protected data handling between thread with mutexs.
- (GUI) Fixed some string literals for full unicode support.
- (General) Cache: Fixed all size calculations and the size handling system.
- (General) Raised requirements for wxWidgets to 2.6 (beta versions since 2.5.3 should work).
- (General) Some small fixes to build with commoncpp2 1.0.x.

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.

SVK::Help::Intro is a introduction to svk.

svk is an open source distributed version control system which is designed to interoperate with Subversion. Like other version control systems, it keeps track of each change you make to a project and allows you to maintain multiple parallel tracks of development. svk also has a number of powerful features which are rarely found in other version control systems.

svk has been designed from the ground up to support development models that are simple and intuitive for software developers. It has advanced smart branching and merging semantics that make it easy to maintain multiple parallel lines of development and painless to merge changes across branches. svks built in patch manager makes it easy for non-committers to share changes among themselves and with project maintainers.

svk provides powerful support for distributed development. Every svk client is capable of fully mirroring remote Subversion repositories so that you have full access to a projects history at any time, even when they are off the network or on the wrong side of a firewall. You can branch a remote project at any point in that projects history, whether or not you have write access to that projects repository. Later, you can integrate changes from the projects master server (usually with a single command) or push your branch up to another Subversion repository.

CTF project is a multi-agent capture-the-flag framework for education.
This project was started by Jason Rohrer during the fall of 2000 and was initially used to teach CS 472, Introduction to AI, at Cornell University.
A homework assignment was given that asked students to design a CTF agent for the framework.
Students in the class responded to the assignment with great enthusiasm, and many of their final agents far exceeded our expectations (one student group went so far as to design a genetic algorithm to evolve a team of agents).
CTF forces students to explore the issues surrounding agents that operate in a limited information environments.
The framework is flexible enough to allow almost any possible implementation of agent control, from the simplest reactive agents, to agents that query powerful knowledge bases, to neural network agents that are trained by back propagation or reinforcement methods.
When using this framework at Cornell, we left the assignment open-ended. However, you can use this framework in your own class to teach a specific agent control concept (by forcing every student to implement a reinforcement learning system, for example).
Main features:
- Runtime loading of agent classes-- plugging new agents into the framework is incredibly easy
- Runtime loading of obstacle maps
- Automatic round-robin tournament system
- Automatic grading-- an email-ready message is generated for each student team at the end of the tournament (a script for sending out the email messages is included); the point system can be completely configured
- Assignment handout-- click here to see an example of the instructions we handed out to students for CS 472 at Cornell
- Licensed under GPL-- if the framework doesnt work for you as is, you can improve it yourself

CAELinux is a live DVD Linux distribution dedicated to computer aided engineering and finite element analysis. Based on PcLinuxOs, it features a full software solution for professional 3D FE analysis from CAD geometry.
It includes the Salome 3D pre/post processor, Code_Aster non-linear/multi- physics FE solver, GMSH 3D pre/post processor, GNU Octave, Scilab, and more.
Enhancements:
- This version is principaly an OS update of the previous 3a version.
- The system was upgraded to the latest PCLinuxOs 0.93.
- The kernel was updated 2.6.16 Kernels for SMP and 4Gb were added.
- 3D drivers for Nvidia and ATI were added.
- Salome was updated to 3.2.2.
- Code-Aster was updated to STA9.0.
- Calculix was updated to 1.6.
- GMSH was updated to 2.0.
- Tutorials and an introduction video were added.
- The Code-Aster documentation has been translated to English.

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.