Free summer fashion software for linux

Sub::ArgShortcut is a Perl module with writing functions that use default arguments.

SYNOPSIS

use Sub::ArgShortcut::Attr;

sub mychomp :ArgShortcut { chomp @_ }

while ( ) {
# make a chomped copy of $_ without modifying it
my $chomped_line = mychomp;

# or, modify $_ in place
mychomp;

# ...
}

This module encapsulates the logic required for functions that assume $_ as their argument when called with an empty argument list, and which modify their arguments in void context but return modified copies in any other context. You only need to write code which modifies the elements of @_ in-place.
argshortcut(&)

This function takes a code reference as input, wraps a function around it and returns a reference to that function. The code that is passed in should modify the values in @_ in whatever fashion desired. The function from the synopsis could therefore also be written like this:

use Sub::ArgShortcut;
my $mychomp = argshortcut { chomp @_ };

This function is exported by default.

Sub::ArgShortcut::Attr and :ArgShortcut - The attribute interface
Instead of using argshortcut to wrap a code reference, you can use an Attribute::Handler-based interface to add Sub::ArgShortcut functionality to regular subs. Simply use Sub::Shortcut::Attr instead of Sub::Shortcut, then request its behaviour using the :ArgShortcut attribute on functions:
sub mychomp :ArgShortcut { chomp @_ }

my $mychomp = sub :ArgShortcut { chomp @_ };

tthsum generates and checks TTH checksums (root of the THEX hash tree). The Merkle Hash Tree is a hash construct that exhibits desirable properties for verifying the integrity of files and file subranges in an incremental or out-of-order fashion.
The tool uses the Tiger hash algorithm for both the internal and the leaf nodes, and has an interface identical to md5sum.
Enhancements:
- Converted tthsum to C (it was C++).
- Updated makefiles, added NMakefile for Windows, run nmake /f NMakefile on windows.
- Added BIG_ENDIAN support (tested on a SPARC).
- Removed -b functionality. The asterisk that did nothing didnt make sense.
- Made this Changelog a bit more readable.
- Fixed a bug where incorrect hashes were generated when using the console as input file. (The reads did not generate a multiple of 1024 bytes.)
- Added mmap(2) support (-m) (mapping 1.6MB at a time), default is read(2). YMMV.
- Added -p, -w, -V options (show progress, warn about improper digest lines, show version).
- Writing escaped and utf8-ified filenames to digest.

The amaroK bindings for Python is a fairly complete amaroK remote control class. It is extremely useful for amaroK scripts and other applications. Basically, you can remote control amaroK by calling methods from an amaroKProxy instance.

In addition, it implements the Observer/Observable pattern so you can deal with events in an object-oriented, loosely coupled fashion. Even better, you can call an amaroKProxy instances collection.getSong(filename) method to get a Song object, with track, artist, album name, and elegant "Artist - Track name" strings.

Nearly all DCOP functions for communication with amaroK are implemented.

It will use KDE bindings DCOP module if available, otherwise it will default to the command-line DCOP dcop command, through python-commandsplus. If using KDE bindings, a slave process is spawned, and IPC is used to marshal and unmarshal function calls, so as to not contaminate your applications sys.modules with KDEs Python modules. This all happens automatically in the background.

To use it, you import the module in your script and instantiate an amaroKProxy instance, then call your instances startMonitoring() method, which will start reading from standard input, monitoring for amaroKs events. You can then sleep(1) until your instances .isAlive() method returns False (which means amaroK is now gone.

amaroKProxy is an Observable class, and so are its members:

- player
- contextBrowser

This means that you can implement Observer objects or Threads in your amaroK script, and have them be notified of amaroK events, instead of having to read standard input and act accordingly (plus error-prone exceptional condition handling).

Quarters Board Game project is a strategy game for two players.

Although its rules are relatively simple, it still offers some of the same opportunities for skill as in chess.

This program was originally conceived in the summer of 1986 during a study of the mini-max algorithm for chess playing computers, and was thus designed to offer some of the same type of strategies.

The game was originally written in BASIC, then ported to Turbo Pascal, then to C, and finally to Java.

The Java version is not necessarily object oriented, since it is a crude port from the C version.

pcapsipdump project is a tool for dumping (recording) SIP sessions (and RTP traffic, if available) to disk in a fashion similar to "tcpdump -w" (the format is exactly the same).

The difference is that the data is saved with one file per SIP session. Even if there are thousands of concurrect SIP sessions, each goes to separate file.

IrNET is a protocol allowing to carry TCP/IP traffic between two IrDA peers in an efficient fashion. It is a thin layer, passing PPP packets to IrTTP and vice versa. It uses PPP in synchronous mode, because IrTTP offer a reliable sequenced packet service (as opposed to a byte stream). In fact, you could see IrNET as carrying TCP/IP in a IrDA socket, using PPP to provide the glue.

The main difference with traditional PPP over IrCOMM is that we avoid the framing and serial emulation which are a performance bottleneck. It also allows multipoint communications in a sensible fashion.We can automatically handle incomming connections through irnetd.


The main difference with IrLAN is that we use PPP for the link management, which is more standard, interoperable and flexible than the IrLAN protocol. For example, PPP adds authentication, encryption, compression, header compression and automated routing setup. And, as IrNET let PPP do the hard work, the implementation is much simpler than IrLAN.

IrNET was first introduced by Microsoft in the IrDA stack of Windows 2000, and they decided to remove both IrCOMM and IrLAN in favor of IrNET in their new IrDA stack. IrNET is a great idea (removing IrLAN and IrCOMM, on the other hand...), however IrNET is not an IrDA specification (at least, not yet, but there are rumors of something called IrDial...).

IrNET has been included in Linux kernel 2.4.0-test11, so all subsequent version of the kernel should support it out of the box (provided everything is set up properly). The latest version is in Linux kernel 2.4.15.

KBasic is made up of the following programs: + a development environment with visual form designer and menubar designer + a compiler + an interpreter + an archiver + a graphical user interface component.
It is possible to develop Qt applications with well known BASIC syntax in a modern fashion. It comes with truly Java-like object orientation and backward support for VB6 and QBasic, as it is 100% syntax compatible.
KBasic combines the expressive power of object-oriented languages like C++ with the familiarity and ease of use of VB6.
It allows developers with an installed base of VB6 applications to start developing for a mixed Windows and Linux environment without having to face a steep learning curve: KBasic uses the familiar visual design paradigm and has a full implementation of the BASIC language.
Main features:
- Object orientated
- Modern BASIC language
- Full featured IDE
- Complete documentation
- More than 200 classes
- Get the power of C++
- Extend them
- Control the events

CORBA::omniORB::mapping is a CORBA mapping for Perl.

This document describes a mapping of the CORBA system into Perl. It sticks most closely to the mapping in the CORBA::MICO, L:< CORBA:omniORB >, and CORBA::ORBit modules; however, some reference is also made to the mappings implemented in COPE and ILU/Perl.

These systems exhibit a wide diversity in the details of their object adaptors. CORBA::MICO and CORBA::omniORB implement most of the POA specification fashion, including all activation modes. COPE implements a version of the BOA, and ILU has its own object native adaptor different from the BOA, though it implements some of the BOA specificatoin through compatibility classes.

For this reason, this document largely avoids specifying object adaptor details, except for a few specific notes. Details about the manner in which the ORB is initialized and interface definitions are loaded are also not specified here. Conformant implementations may either use conventional stubs or access interface definitions in a dynamic manner. (For instance, by loading them from an Interface Repository.)
The design goal for this mapping was to allow applications to access the complete CORBA specification from Perl in a convenient and concise manner, even when this requires sacrificing some amount of speed or convenience for the ORB implementor.