Free 004 software for linux

Lucy is for power users already familiar with usenet. It wont hold your hand or nag you about proper etiquette. In fact, you are free to edit all the headers of your posts, if you want. (You can even violate the RFC protocols for usenet, and Lucy wont complain unless you ask it to) This may seem like a bug, but I dont consider it as such, its designed for people who are already familiar with usenet.

This newsreader is ideally suited to perl programmers. The examples include a skeleton outline for adding text-to-speech capabilities (for blind users, it works on a mac through the osascript command) as well as a built in regular expression calculator.

Lucy is a newsreader which incorporates all the features of a modern application of this kind, even if it works in command line. The keys are configurable and you can choose every key you want.

Some of the other things it supports are subject and newsgroup filtering, lets suppose you wanted to narrow down your list of newsgroups to those containing "perl" in their names, Lucy lets you do this.

One of the frustrating things about newsreaders (or any software programs for that matter) is remembering the keystroke to perform an action you seldom use. This is where a command interface comes in handy, commands are easier to remember than keystrokes.

When Term::ReadLine::Gnu is installed (highly recommended) command completion is available, so you only have to type a portion of the command to get a list of them. Lucy also has online help.

At first, one would be tempted to believe a perl newsreader would be slow, this is not the case with Lucy, its startup time is much faster than most other newsreaders because it will not contact the server until youve selected a group.

To minimize the startup time, it will load its perl modules dynamically. To improve loading time of your newsrc it uses its own variant of News::Newsrc (With dynamic creation of Set::IntSpan objects)

Currently, it requires the news server to support the XOVER command, most servers already do this (It was developed with the leafnode news server). You will find that using XOVER is much faster than downloading headers.

Whenever possible, it will use external programs. This was one of the things I didnt care for about other newsreaders, I wanted to use my favorite pager (less) to page articles, and I wanted to use my favorite mail program (mutt) for email. I dont like having different pagers for different programs. Furthermore, youve probably configured your email program to your settings, why should a news reader implement its own mail interface?

To make the pager work better within the newsreader, you can configure it to use the program exit code as a keystroke. This is very handy with the lesskey utility. With this approach, jumping from less straight into a followup is possible.

Lucy now has better support for usenet binaries, with background downloading. (Select files to download, it figures out which parts are needed and then downloads them)

It has several new commands to help in binary readings, such as a binary thread model.

To install, unpack it wherever you want, run perl install.pl and itll check for modules it thinks it needs, offering to run CPAN for you. Itll then create a simple shell script for running Lucy.

DBD::mysql is a Perl module with MySQL driver for the Perl5 Database Interface (DBI).

SYNOPSIS

use DBI;

$dsn = "DBI:mysql:database=$database;host=$hostname;port=$port";

$dbh = DBI->connect($dsn, $user, $password);


$drh = DBI->install_driver("mysql");
@databases = DBI->data_sources("mysql");
or
@databases = DBI->data_sources("mysql",
{"host" => $host, "port" => $port});

$sth = $dbh->prepare("SELECT * FROM foo WHERE bla");
or
$sth = $dbh->prepare("LISTFIELDS $table");
or
$sth = $dbh->prepare("LISTINDEX $table $index");
$sth->execute;
$numRows = $sth->rows;
$numFields = $sth->{NUM_OF_FIELDS};
$sth->finish;

$rc = $drh->func(createdb, $database, $host, $user, $password, admin);
$rc = $drh->func(dropdb, $database, $host, $user, $password, admin);
$rc = $drh->func(shutdown, $host, $user, $password, admin);
$rc = $drh->func(reload, $host, $user, $password, admin);

$rc = $dbh->func(createdb, $database, admin);
$rc = $dbh->func(dropdb, $database, admin);
$rc = $dbh->func(shutdown, admin);
$rc = $dbh->func(reload, admin);

EXAMPLE

#!/usr/bin/perl

use strict;
use DBI();

# Connect to the database.
my $dbh = DBI->connect("DBI:mysql:database=test;host=localhost",
"joe", "joes password",
{RaiseError => 1});

# Drop table foo. This may fail, if foo doesnt exist.
# Thus we put an eval around it.
eval { $dbh->do("DROP TABLE foo") };
print "Dropping foo failed: $@n" if $@;

# Create a new table foo. This must not fail, thus we dont
# catch errors.
$dbh->do("CREATE TABLE foo (id INTEGER, name VARCHAR(20))");

# INSERT some data into foo. We are using $dbh->quote() for
# quoting the name.
$dbh->do("INSERT INTO foo VALUES (1, " . $dbh->quote("Tim") . ")");

# Same thing, but using placeholders
$dbh->do("INSERT INTO foo VALUES (?, ?)", undef, 2, "Jochen");

# Now retrieve data from the table.
my $sth = $dbh->prepare("SELECT * FROM foo");
$sth->execute();
while (my $ref = $sth->fetchrow_hashref()) {
print "Found a row: id = $ref->{id}, name = $ref->{name}n";
}
$sth->finish();

# Disconnect from the database.
$dbh->disconnect();

DBD::mysql is the Perl5 Database Interface driver for the MySQL database. In other words: DBD::mysql is an interface between the Perl programming language and the MySQL programming API that comes with the MySQL relational database management system. Most functions provided by this programming API are supported. Some rarely used functions are missing, mainly because noone ever requested them.

V language is a tiny concatenative language implemented for experimentation.
The source is under Public Domain (un-copyrighted.)
The full featured language is on top of JVM, A native version (in alpha state) is also there in the codebase.
To run it, extract the distribution in any directory and do #gmake run.
gmake
gmake run
V
|
The language is a close relative of postscript, forth and joy. and is stack based. ie:
|2 3 *
=6
|2 3 * 5 +
=11
See status for a tutorial and more info.
The Functions available in V are available in this page: functions
(The releases are out of date and multiple fixes have gone in. Please check out and build rather than use them.)
Example functions in V. getting the roots (with out using the stack shuffling word view)
[quad-formula
[a b c] let
[minisub 0 b -].
[radical b b * 4 a * c * - sqrt].
[divisor 2 a *].
[root1 minisub radical + divisor /].
[root2 minisub radical - divisor /].
root1 root2
].
|2 4 -30 quad-formula ??
=(-5.0 3.0)
using view
[quad-root
[a b c : [0 b - b b * 4 a * c * - sqrt + 2 a * /]] view i
].
|2 4 -30 quad-root ??
=(3)
contrast this with the definition in scheme here
(define quadratic-formula
(lambda (a b c)
(let ([minusb (- 0 b)]
[radical (sqrt (- (* b b) (* 4 ( * a c))))]
[divisor (* 2 a)] )
let ([root1 (/ (+ minusb radical) divisor)]
[root2 (/ (- minusb radical) divisor)])
(cons root1 root2)))))
Definition of Qsort.
[qsort
#definitions
[joinparts [pivot [*list1] [*list2] : [*list1 pivot *list2]] view].
[split_on_first_element uncons [>] split&].
#args starts for binrec. notice that 2 arguments (termination condition
#and its result) are on first line.
[small?] []
[split_on_first_element]
#binrec recurses on the result of split_on_first_element before applying joinparts.
[joinparts]
binrec].
Some explanations.
The first and second lines (terminated by .) are internal function definitions
(Notice how qsort is also terminated by .) . is the definition syntax in V.
The first function joinparts
============================
The function joinpart contains just an application of the operator view.
view is list translator. It takes a list of the form [template : result]
then it tries to apply the template to the current stack. If it can be applied on the
stack, then the arguments named in the template are bound to values in stack. The result is then processed, and all the bound elements in result are replaced by their values.
[pivot [*list1] [*list2] : [*list1 pivot *list2]] view expects 3 arguments on the stack,
the first a single element pivot, then two lists list1 and list2.
It returns a list that is composed of elements of list1 followed by pivot
followed by elements of list2 (as defined in result - RHS of :).
ie:
44 [1 2 3] [5 6 7] [pivot [*list1] [*list2] : [*list1 pivot *list2]] view ??
=> [1 2 3 44 5 6 7]
(The function ?? is used to print out the elements in the stack now.)
The second function split_on_first_element
==========================================
The definition is [uncons [>] split&]
The uncons splits a list into the first element and the rest of the list.
ie:
[1 2 3 4 5] uncons ??
=1 [2 3 4 5]
split& takes two arguments, the first is the function F to split a list with,
and the second the list itself. All elements in the list that passes the function F
is put into the first list, and all that do not are put into the second list.
ie:
[1 2 3 4 5 6 7] [4 >] split& ??
=[5 6 7] [1 2 3 4]
The function F can also take an argument from the stack. so this also works.
4 [1 2 3 4 5 6 7] [>] split& ??
=[5 6 7] [1 2 3 4]
Thus the split_on_first_element takes the first element of a list, and split that
list based on that element as a filter.
binrec
=======
binrec expects 4 arguments,
Arg1 is the terminating condition,
Arg2 is the result if the terminating condition is met.
Arg3 is an executable statement that returns two entities.
The entire binrec statement is performed on each of the
two entities until the terminating condition is met.
Arg4 is what to do with the result of the previous statement.
Algorithm.
Here, the small? checks if the list is empty or contains just one element.
if it is, then the result is arg2 - []
ie:
[] small? ??
=true
[1] small? ??
=true
[1 2 3 4] small? ??
=false
split_on_first_element takes is executed on all lists that are larger than size 1
and as explained above, splits them into two based on the first element.
on the resultent lists, the entire qsort is performed again due to binrec.
The last joinparts takes these elements (pivot list1 list2) which are present now
on the stack, and combines them to produce a single sorted list.
A slightly friendlier function (with out the binrec.)
[qsort
[joinparts [pivot [*list1] [*list2] : [*list1 pivot *list2]] view].
[split_on_first_element uncons [>] split&].
[small?]
[]
[split_on_first_element [list1 list2 : [list1 qsort list2 qsort joinparts]] view i]
ifte].
The binrec and friends are more powerful than the explicit recursion done above, but for people new to concatenative languages, this kind of recursion may look more intuitive.
Enhancements:
- The language has become relatively stable.
- Lots of bugfixes were made in scope handling.
- Tree operations were added.
- Generic combinators were moved out into a separate library.

Conjury::C::GNU is a Perl Conjury with the GNU C/C++ tools.

SYNOPSIS

c_compiler Vendor => GNU,
Language => I ,
No_Scanner => 1,
Program => I ,
Options => [ I , I , ... ],
Journal => I ;

c_linker Vendor => GNU,
Language => I ,
Program => I ,
Options => [ I , I , ... ],
Journal => I ;

The optional Program, Options and Journal arguments to the GNU-specific specializations of the c_compiler and c_linker functions are simply passed through unmodified to the base class constructor.

The optional Language argument specifies the langauge for which the compiler or linker should be invoked. The C language is the default if not otherwise specified. The value is case-insensitive and may be any one of the following: c, c++ or objective-c.

The optional No_Scanner argument in the c_compiler specialization specifies that the processing overhead of scanning all the source files for their dependency trees is unnecessary. If you are only building from clean source file hierarchies (with no existing products from previous runs), then the construction time of large builds may be improved with this option.

Conjury::C::Sun is a Perl Conjury with the Sun Workshop C/C++ tools.

SYNOPSIS

c_compiler Vendor => Sun,
Language => I< language>,
No_Scanner => 1,
Program => I< program>,
Options => [ I< opt1>, I< opt2>, ... ],
Journal => I< journal>;

c_linker Vendor => Sun,
Language => I< language>,
Program => I< program>,
Options => [ I< opt1>, I< opt2>, ... ],
Journal => I< journal>;

c_archiver Vendor => Sun,
Language => I< language>,
Program => I< program>,
Options => [ I< opt1>, I< opt2>, ... ],
Journal => I< journal>;

The optional Program, Options and Journal arguments to the Sun-specific specializations of the c_compiler and c_linker functions are simply passed through unmodified to the base class constructor.

The optional Language argument specifies the langauge for which the compiler or linker should be invoked. The C language is the default if not otherwise specified. The value is case-insensitive and may be either cor c++.

The optional No_Scanner argument in the c_compiler specialization specifies that the processing overhead of scanning all the source files for their dependency trees is unnecessary. If you are only building from clean source file hierarchies (with no existing products from previous runs), then the construction time of large builds may be improved with this option.

NetAddr::IP::UtilPP is a Perl module with pure Perl functions for NetAddr::IP::Util.

SYNOPSIS

use NetAddr::IP::UtilPP qw(
hasbits
isIPv4
shiftleft
addconst
add128
sub128
notcontiguous
ipv4to6
mask4to6
ipanyto6
maskanyto6
ipv6to4
bin2bcd
bcd2bin
);

use NetAddr::IP::UtilPP qw(:all)

$rv = hasbits($bits128);
$rv = isIPv4($bits128);
$bitsX2 = shiftleft($bits128,$n);
$carry = addconst($ipv6naddr,$signed_32con);
($carry,$ipv6naddr)=addconst($ipv6naddr,$signed_32con);
$carry = add128($ipv6naddr1,$ipv6naddr2);
($carry,$ipv6naddr)=add128($ipv6naddr1,$ipv6naddr2);
$carry = sub128($ipv6naddr1,$ipv6naddr2);
($spurious,$cidr) = notcontiguous($mask128);
($carry,$ipv6naddr)=sub128($ipv6naddr1,$ipv6naddr2);
$ipv6naddr = ipv4to6($netaddr);
$ipv6naddr = mask4to6($netaddr);
$ipv6naddr = ipanyto6($netaddr);
$ipv6naddr = maskanyto6($netaddr);
$netaddr = ipv6to4($pv6naddr);
$bcdtext = bin2bcd($bits128);
$bits128 = bcd2bin($bcdtxt);

VcsTools::DataSpec::HpTnd is a Hp Tnd custom data for HMS logs.

SYNOPSIS

use VcsTools::DataSpec::HpTnd qw($description readHook);
use VcsTools::LogParser ;

my $ds = new VcsTools::LogParser
(
readHook => &readHook,
description => $description
) ;

This class contains all the custom information needed to retrieve our data from our database using the generic VcsTools::LogParser class.

The $description hash ref defines the informations that are contained in the log of each version of the HMS file.
Needless to say this file is tailored for HP Tnd needs and HMS keywords. Nevertheless, it can be used as a template for other VCS systems and other needs.

Razer DeathAdder mouse configuration is a configuration utility for the Razer DeathAdder on Linux systems.
You can control the LEDs, scanning resolution and frequency and profiles with this tool. In future things like firmware upload are also planned.
Enhancements:
- This adds support for the Razer Krait mouse.