Free foot software for linux

bwFXPbot is a Perl based IRC bot, designed for a spesific purpose to provide a solution for FTP based file sharing networks.
The idea is simple, the files are uploaded to a specific FTP server by the administrators who would like to spread them to their other FTP servers on the network, using bwFXPbot they can provide access for who ever they see feet to access the IRC and spread the files by a single command to the IRC bot.
bwFXPbots features are as followed:
- Using IRC bwFXPbot provides you with an easy global access to your file distributions.
- Easy distribution of files from a local host to multiple FTP servers.
- Easy distribution of files from one FTP server to many using FXP.

Filecentral is a filesystem browser and file manager. It uses the navigational model of the OSX finder, but tries to integrate into the GNOME Desktop. It uses gnome-vfs and is thus also able to manage remote files.

Filecentral is programmed in C, the best programming language to shoot yourself in the foot.

Geo::Distance is a Perl module that can calculate distances and closest locations.

SYNOPSIS

use Geo::Distance;
my $geo = new Geo::Distance;
$geo->formula(hsin);
$geo->reg_unit( toad_hop, 200120 );
$geo->reg_unit( frog_hop => 6 => toad_hop );
my $distance = $geo->distance( unit_type, $lon1,$lat1 => $lon2,$lat2 );
my $locations = $geo->closest(
dbh => $dbh,
table => $table,
lon => $lon,
lat => $lat,
unit => $unit_type,
distance => $dist_in_unit
);

This perl library aims to provide as many tools to make it as simple as possible to calculate distances between geographic points, and anything that can be derived from that. Currently there is support for finding the closest locations within a specified distance, to find the closest number of points to a specified point, and to do basic point-to-point distance calculations.

METHODS

new

my $geo = new Geo::Distance;
my $geo = new Geo::Distance( no_units=>1 );

Returns a blessed Geo::Distance object. The new constructor accepts one optional argument.

no_units - Whether or not to load the default units. Defaults to 0 (false).
kilometer, kilometre, meter, metre, centimeter, centimetre, millimeter,
millimetre, yard, foot, inch, light second, mile, nautical mile,
poppy seed, barleycorn, rod, pole, perch, chain, furlong, league,
fathom

formula

if($geo->formula eq hsin){ ... }
$geo->formula(cos);

Allows you to retrieve and set the formula that is currently being used to calculate distances. The availabel formulas are hsin, polar, cos, and mt. hsin is the default and mt/cos are depreciated in favor of hsin. polar should be used when calculating coordinates near the poles.

reg_unit
$geo->reg_unit( $radius, $key );
$geo->reg_unit( $key1 => $key2 );
$geo->reg_unit( $count1, $key1 => $key2 );
$geo->reg_unit( $key1 => $count2, $key2 );
$geo->reg_unit( $count1, $key1 => $count2, $key2 );

This method is used to create custom unit types. There are several ways of calling it, depending on if you are defining the unit from scratch, or if you are basing it off of an existing unit (such as saying 12 inches = 1 foot ). When defining a unit from scratch you pass the name and rho (radius of the earth in that unit) value.

So, if you wanted to do your calculations in human adult steps you would have to have an average human adult walk from the crust of the earth to the core (ignore the fact that this is impossible). So, assuming we did this and we came up with 43,200 steps, youd do something like the following.

# Define adult step unit.
$geo->reg_unit( 43200, adult step );
# This can be read as "It takes 43,200 adult_steps to walk the radius of the earth".

Now, if you also wanted to do distances in baby steps you might think "well, now I gotta get a baby to walk to the center of the earth". But, you dont have to! If you do some research youll find (no research was actually conducted) that there are, on average, 4.7 baby steps in each adult step.

# Define baby step unit.
$geo->reg_unit( 4.7, baby step => adult step );
# This can be read as "4.7 baby steps is the same as one adult step".

And if we were doing this in reverse and already had the baby step unit but not the adult step, you would still use the exact same syntax as above.
distance

my $distance = $geo->distance( unit_type, $lon1,$lat1 => $lon2,$lat2 );

Calculates the distance between two lon/lat points.
closest

my $locations = $geo->closest(
dbh => $dbh,
table => $table,
lon => $lon,
lat => $lat,
unit => $unit_type,
distance => $dist_in_unit
);

This method finds the closest locations within a certain distance and returns an array reference with a hash for each location matched.

The closest method requires the following arguments:

dbh - a DBI database handle
table - a table within dbh that contains the locations to search
lon - the longitude of the center point
lat - the latitude of the center point
unit - the unit of measurement to use, such as "meter"
distance - the distance, in units, from the center point to find locations

The following arguments are optional:

lon_field - the name of the field in the table that contains the longitude, defaults to "lon"
lat_field - the name of the field in the table that contains the latitude, defaults to "lat"
fields - an array reference of extra field names that you would like returned with each location
where - additional rules for the where clause of the sql
bind - an array reference of bind variables to go with the placeholders in where
sort - whether to sort the locations by their distance, making the closest location the first returned
count - return at most these number of locations (implies sort => 1)

This method uses some very simplistic calculations to SQL select out of the dbh. This means that the SQL should work fine on almost any database (only tested on MySQL and SQLite so far) and this also means that it is fast. Once this sub set of locations has been retrieved then more precise calculations are made to narrow down the result set. Remember, though, that the farther out your distance is, and the more locations in the table, the slower your searches will be.

Livestat project is a statistics management system for academic competition tournaments.
Livestat is a Perl-based statistics management system designed for academic competition tournaments, a.k.a "College Bowl" or "quiz bowl" events.
Livestat is used to automate the processing of statistics from individual matches, and to quickly publish statistics on teams and players to the Web.
Enhancements:
- Now sorts teams by name when printing list in game.pl.
- New files common.head and common.foot store the top and bottom of all HTML pages to be generated.
- No longer prints "N/A: " in round views when no player has a positive score.
- Restructured head2head hash in standings.pl; now has fields for wins, losses, ties, points-for, and points-against.
- Added style number in tables -- useful for right-aligning numeric fields

Funky is an embeddable interpreter and programming language.
When was Fnky created?
The very first version of Funky was created during my daughters nap on a snowy sunday afternoon. It was slightly refined one evening while my daughter and my wife were both sleeping and I was rocking the babys "cozy" with my foot (as I am doing now). The initial programming therefore took about 90 minutes, whereas a bit of fine-tuning and turning the original parser/interpreter into a parser/interpreter with two phases (parsing and interpreting) took another two hours or so.
Why was Funky created?
The original idea wasnt mine: at work, a colleague needed a functional, embeddable programming language and created one from scratch. It took him a few days to do so, but he wrote the parser and the scanner by hand. I heard about his little language and thought it might be a nice idea to have one of those in the free world.
Also, as a personal challenge, I decided I should be able to write one of those in much less time that a few days, but using the right tools. Hence, one sunday afternoon I took my laptop computer and started typing. I decided to use Boost.Spirit to write the parser: I had already read the documentation once while doing some research for the Jail programming language and found it a pretty good framework to build a parser one. 90 minutes later, I had the first working version of a Funky interpreter (but it wasnt embeddable yet and didnt split the parsing and interpreting phases).
So, what exactly is Funky?
As stated, Funky is a tiny, embeddable programming language with almost unlimited extending capabilities. It presents itself as a single class which contains the entire interpreter. Two versions of this class exist: Funky::Funky, which is a floating-point version, and Funky::Groovy, which is an integer version. You can install your own functions in the language as long as your functions take a vector of the built-in type of the interpreter as return an instance of that built-in type (or a vector of those).
Funky is a functional programming language. As such, it treats everything as functions and those functions handle only one type: double in the case of Funky::Funky or int in the case of Funky::Groovy.
Enhancements:
- This release adds support for GCC 4.x by fixing a small error in the declaration of a variable.
- It also comes with more documentation on how to build Funky.

Overslack is a slackline simulator/game. A configurable model world containing a slackline, a slacker and ground is visualized and its time evolution is calculated while the user controls the slacker using the mouse. Just like with real slacklining there is no predefined goal, but it keeps track of the time you stand on the line.

The simulated world has only two dimensions. Although the forward direction offers many possibilities on a real slackline, it has very little to do with balancing and is quite uninteresting to simulate. Slow speeds are assumed, so the air resistance is neglected. The time evolution is calculated by applying Newtonian physics numerically as many times per second as the machine can handle.

The speed of the simulated world is configurable, making it run five times as slow as the real world makes it slow enough to be manageable and fast enough to keep the attention up. Unlike normal grass ground, the ground in the simulation is bouncy and doesnt cause injuries. It is (unfortunately) a bit unrealistic, but makes it more fun.

The simulated line behaves according to a quite simple model. An ideal spring between the lines point of equilibrium and the slackers feet makes a good approximation, but an ideal spring gives back all energy it stores, which would cause you to bounce forever without helping with your legs. To simulate some friction, it has a somewhat different spring constant depending on whether its extending or compressing. It is of course fully configurable, so anything from an ideal spring to an old, tired and non-elastic line are possible to simulate.

The slacker is controlled with the mouse. Move the mouse down to extend the legs, and move it up to crouch. Move the mouse to the right to lower your right arm and raise your left, and to the left to do the opposite. This is pretty much all you can do on a real slackline too, except that you can move more than just your arms, but thats just a question of terminology.

The slacker is infinitely fast and strong, if you move the mouse the slacker will move instantly to the new position regardless of the force and energy required.
It is possible to jump off the line and land on it again, with or without bouncing on the ground in between, but to make it simpler the slacker is moved to a perfectly balanced position whenever you press the right mouse button.

In addition to the line, slacker and some on-screen numerical physical information, vectors visualizing location (white), speed (green) and acceleration (red), both translational and rotational, are shown.

Posy::Docs::ProgrammerGuide is a guide for programmers of Posy.

How Posy Works

Posy has two modules which drive the whole thing: Posy and Posy::Core. Posy has been set up so that, when you give it a list of plugin modules to use, it imports them as children of each other, so that each one overrides the methods of the previous one, and/or adds new methods of its own. (see "import" in Posy for more details).

What this boils down to is that, if you want to change Posys behaviour, you can (a) write methods which override existing methods, simply by writing a method with the same name, and (b) add additional functionality to Posy by writing new methods, especially new Action methods.
Action methods? Okay, back to how Posy works.

Posy first sets up all the Plugins with its "import" method, and then it calls its "run" method, which (a) creates a new Posy object, (b) calls "init" on the object, (c) calls "do_actions" on the object.

The "do_actions" method in turn calls all the actions in the passed-in "actions" array, which should include the "do_entry_actions" method, which in turn calls all the actions in the passed-in "entry_actions" array. The entry actions are called once per entry; the "flow" actions are called once per run.

Flow actions?

Well, I had to have a name for them. They flow on, one after another. Posy doesnt always manipulate the Posy object itself when building up the final web page -- it manipulates the "flow-state" hash, which is passed to every flow-action. Until finally the "render_page" action takes all the separate parts of the page which have been built up (head, page_body and foot) and pastes them together and outputs them (to either a file or STDOUT).

Entry actions?

Entry actions are applied to each entry. One of the early flow-actions, "select_entries", picks the list of entries which are going to be in the final page, either one (for an "entry" page) or many (for a "category" or "chrono" page). Entry actions not only deal with the "flow_state" hash, but they have two other hashes that they manipulate, the "current_entry" hash, and the "entry_state" hash. The current_entry hash contains (as one would expect) information about the current entry, such as the raw content of the entry ($current_entry->{raw}) and the processed content of the entry (such as $current_entry->{body}, $current_entry->{title}) and so on.

What the entry actions do is build up the "page_body" part of the page (the flow actions deal with the head and the foot). Though, actually, "head_render" and "foot_render" could be considered dual-purpose actions.

Dual-purpose actions?

There are some actions which can be called as either "flow" actions or "entry" actions, and change their behaviour according to whether they are called as one or the other. See "head_render" in Posy::Core for an example. They arent common, but can be useful in certain circumstances.