Free mood software for linux

B::Graph is a Perl compiler backend to produce graphs of OP trees.

SYNOPSIS

perl -MO=Graph,-text prog.pl >graph.txt

perl -MO=Graph,-vcg prog.pl >graph.vcg
xvcg graph.vcg

perl -MO=Graph,-dot prog.pl | dot -Tps >graph.ps

This module is a backend to the perl compiler (B::*) which, instead of outputting bytecode or C based on perls compiled version of a program, writes descriptions in graph-description languages specifying graphs that show the programs structure. It currently generates descriptions for the VCG tool (http://www.cs.uni-sb.de/RW/users/sander/html/gsvcg1.html) and Dot (part of the graph visualization toolkit from AT&T: http://www.research.att.com/sw/tools/graphviz/). It also can produce plain text output (which is more useful for debugging the module itself than anything else, though you might be able to make cut the nodes out and make a mobile or something similar).

OPTIONS

Like any other compiler backend, this module needs to be invoked using the O module to run correctly:

perl -MO=Graph,-opt,-opt,-opt program.pl
OR
perl -MO=Graph,-opt,obj -e BEGIN {$obj = ["hi"]}; print $obj
OR EVEN
perl -e use O qw(Graph -opt obj obj); print "hi!n";

Obj is the name of a perl variable whose contents will be examined. It cant be a my() variable, and it shouldnt have a prefix symbol ($@^*), though you can specify a package -- the name will be used to look up a GV, whose various fields will lead to the scalar, array, and other values that correspond to the named variable. If no object is specified, the whole main program, including the CV that points to its pad, will be displayed.

Each of the the opts can come from one of the following (each set is mutually exclusive; case and underscores are insignificant):

-text, -vcg, -dot

Produce output of the appropriate type. The default is -text, which isnt useful for much of anything (it does draw some nice ASCII boxes, though).

-addrs, -no_addrs

Each of the nodes on the graph produced corresponds to a C structure that has an address and includes pointers to other structures. The module uses these addresses to decide how to draw edges, but it makes the graph more compact if they arent printed. The default is -no_addrs.

-compile_order, -run_order

The collection of OPs that perl compiles a script into has two different layers of structure. It has a tree structure which corresponds roughly to the synactic nesting of constructs in the source text, and a roughly linked-list representation, essentially a postorder traversal of this tree, which is used at runtime to decide what to do next. The graph can be drawn to emphasize one structure or the other. The former, compile_order, is the default, as it tends to lead to graphs with aspect ratios close to those of standard paper.

-SVs, -no_SVs

If OPs represent a programs compiled code, SVs represent its data. This includes literal numbers and strings (IVs, NVs, PVs, PVIVs, and PVNVs), regular arrays, hashes, and references (AVs, HVs, and RVs), but also the structures that correspond to individual variables (special HVs for symbol tables and GVs to represent values within them, and special AVs that hold my() variables (as well as compiler temporaries)), structures that keep track of code (CVs), and a variety of others. The default is to display all these too, to give a complete picture, but if you arent in a holistic mood, you can make them disappear.

-ellipses, -rhombs

The module tries to give the nodes representing SVs a different shape from those of OPs. OPs are usually rectangular, so two obvious shapes for SVs are ellipses and rhombuses (stretched diamonds). This option currently only makes a difference for VCG (ellipse is the default).

-stashes, -no_stashes

The hashes that perl uses to represent symbol tables are called stashes. Since every GV has a pointer back to its stash, its virtually inevitable for the links in a graph to lead to the main stash. Unfortunately stashes, especially the main one, can be quite big, and lead to forests of other structures -- theres one GV and another SV for each magic variable, plus all of @INC and %ENV, and so on. To prevent information overload, then, the display of stashes is disabled by default.

-fileGVs, -no_fileGVs

Another kind graph element that can be annoying are the pointers from every GV and COP (a kind of OP that occurs for every statement) to the GV that represents the file from which that code came (used for error messages). By default, these links arent shown, to keep them from cluttering the graph. Also, perls internal interfaces changed in a recent version, so in perl 5.005_63 or later you cant see the fileGVs at all.

-SEQs, -no_SEQs

As it is visited in the peephole optimization phase, each OP gets a sequence number, which is currently used by anything (except the peephole optimizer, to avoid visiting OPs twice). If you want to see these, ask for them. (COPs have their own sequence numbers too, but theyre more interesting to look at -- for instance, theyre used to bound the lifetimes of lexicals).

-types, -no_types

B::Graph always gives the type of each OP symbolically (entersub), but it can also print the numeric value of the type field, if you want. The default is no_types.

-float, -no_float

Almost every OP has an op_next and an op_sibling pointer, and B::Graph colors them distinctively (pink and light blue, respectively). Because of this, it isnt strictly necessary to anchor the arrow on a line in the OPs box saying op_next. The float option lets the graph layout engine start these arrows wherever it wants, which can sometimes lead to a more pleasing layout, at the expense of being less obvious. The default is not to float.

-targlinks, -no_targlinks

Lexical (my()) variables and temporary values used by individual OPs are stored in pads, per-code arrays linked to the CV. OPs store indexes into these arrays in the op_targ field, but B::Graph can often also draw links directly from the OP to the SV that stores the name of the variable. These links dont correspond to any real pointers, however, and they can make the graph more complicated, so they are disabled by default.

Spiffy is a Spiffy Perl Interface Framework For You.

SYNOPSIS

package Keen;
use Spiffy -Base;
field mirth;
const mood => :-);

sub happy {
if ($self->mood eq :-() {
$self->mirth(-1);
print "Cheer up!";
}
super;
}

"Spiffy" is a framework and methodology for doing object oriented (OO) programming in Perl. Spiffy combines the best parts of Exporter.pm, base.pm, mixin.pm and SUPER.pm into one magic foundation class. It attempts to fix all the nits and warts of traditional Perl OO, in a clean, straightforward and (perhaps someday) standard way.

Spiffy borrows ideas from other OO languages like Python, Ruby, Java and Perl 6. It also adds a few tricks of its own.

If you take a look on CPAN, there are a ton of OO related modules. When starting a new project, you need to pick the set of modules that makes most sense, and then you need to use those modules in each of your classes. Spiffy, on the other hand, has everything youll probably need in one module, and you only need to use it once in one of your classes. If you make Spiffy.pm the base class of the basest class in your project, Spiffy will automatically pass all of its magic to all of your subclasses. You may eventually forget that youre even using it!

The most striking difference between Spiffy and other Perl object oriented base classes, is that it has the ability to export things. If you create a subclass of Spiffy, all the things that Spiffy exports will automatically be exported by your subclass, in addition to any more things that you want to export. And if someone creates a subclass of your subclass, all of those things will be exported automatically, and so on. Think of it as "Inherited Exportation", and it uses the familiar Exporter.pm specification syntax.

To use Spiffy or any subclass of Spiffy as a base class of your class, you specify the -base argument to the use command.

use MySpiffyBaseModule -base;

You can also use the traditional use base MySpiffyBaseModule; syntax and everything will work exactly the same. The only caveat is that Spiffy.pm must already be loaded. Thats because Spiffy rewires base.pm on the fly to do all the Spiffy magics.

Spiffy has support for Ruby-like mixins with Perl6-like roles. Just like base you can use either of the following invocations:

use mixin MySpiffyBaseModule;
use MySpiffyBaseModule -mixin;

The second version will only work if the class being mixed in is a subclass of Spiffy. The first version will work in all cases, as long as Spiffy has already been loaded.

To limit the methods that get mixed in, use roles. (Hint: they work just like an Exporter list):

use MySpiffyBaseModule -mixin => qw(:basics x y !foo);

In object oriented Perl almost every subroutine is a method. Each method gets the object passed to it as its first argument. That means practically every subroutine starts with the line:

my $self = shift;

Spiffy provides a simple, optional filter mechanism to insert that line for you, resulting in cleaner code. If you figure an average method has 10 lines of code, thats 10% of your code! To turn this option on, you just use the -Base option instead of the -base option, or add the -selfless option. If source filtering makes you queazy, dont use the feature. I personally find it addictive in my quest for writing squeaky clean, maintainable code.

A useful feature of Spiffy is that it exports two functions: field and const that can be used to declare the attributes of your class, and automatically generate accessor methods for them. The only difference between the two functions is that const attributes can not be modified; thus the accessor is much faster.
One interesting aspect of OO programming is when a method calls the same method from a parent class. This is generally known as calling a super method. Perls facility for doing this is butt ugly:

sub cleanup {
my $self = shift;
$self->scrub;
$self->SUPER::cleanup(@_);
}

Spiffy makes it, er, super easy to call super methods. You just use the super function. You dont need to pass it any arguments because it automatically passes them on for you. Heres the same function with Spiffy:

sub cleanup {
$self->scrub;
super;
}

Spiffy has a special method for parsing arguments called parse_arguments, that it also uses for parsing its own arguments. You declare which arguments are boolean (singletons) and which ones are paired, with two special methods called boolean_arguments and paired_arguments. Parse arguments pulls out the booleans and pairs and returns them in an anonymous hash, followed by a list of the unmatched arguments.

Finally, Spiffy can export a few debugging functions WWW, XXX, YYY and ZZZ. Each of them produces a YAML dump of its arguments. WWW warns the output, XXX dies with the output, YYY prints the output, and ZZZ confesses the output. If YAML doesnt suit your needs, you can switch all the dumps to Data::Dumper format with the -dumper option.

SILC Plugin for Kopete is a protocol plugin for Kopete, the KDE Instant Messenger. If you ever cursed that you cannot join the SILC Network using Kopete this can help you. It will add SILC support to Kopete.
The plugin is based on libsilc which is part of the SILC Toolkit mentioned above. The library was initially written by Pekka Riikonen and is still maintained by him.
Main features:
- Channels can be joined or added to the contact list.
- One-to-one chats can be initiated by clicking members participating in group chats.
- Password protected channels are supported.
- User invitation is handy through drag-and-drop functionality.
- Signature verification and public key handling are fully supported.
- File transfesr to other buddies is possible, including graphical progress information and automatic detection of NATed workstations.
- guided channel configuration is partially available, this is, mainly topic setting and some boolean options
- MIME support is fully implemented. So it is possible to send files to channels.
- Attributes can distribute your mood, your location on earth or the medium you want to be contacted through.

KLuJe is a client for the popular online journal site LiveJournal. The latest release is version 0.7 and is available as an RPM, SRPM, or in a source tarball. Development code is available via anonymous CVS at cvs.kluje.sourceforge.net. Check out module kluje. If you want to acces CVS see the informations above.
Main features:
- Posting with optional subject or mood
- Posting to multiple journals or communities
- Editing events in the past
- Systray icon, with menu of quick links
- Auto polling for friends posts, w/animated systray icon alert
- Integrated spell checking
- Fast server support (for paid accounts)
- MD5 password storage/transmission
Enhancements:
- Fixed bug with incorrect server request encoding. Implemented correct LJ protocol encoding: http://www.livejournal.com/doc/server/ljp.csp.guide.intro.html
- Fixed bugs with non-english languages (UTF-8 everywhere).
- Get rid of deprecated KStdAction::showToolbar() call.
- Several major bugs with edit past events functionality.
- Removed support of faster LJ server because this functionality is completely outdated.
- LiveJournal URL changed to www.livejournal.com/interface/flat.
- Added editline in Preferences dialog with server URL line.
- Added new authors to about box.
- Fixed bug with LiveJournal menu corruption after GUI rebuild (i.e. toolbar changed)
- Fixed bug with KConfig object change notification (weve tried to read entries from incorrect configuration group).
- Re-wrote and expanded docs in doc/en/index.docbook

If you use a Windows, Mac or Linux PC to listen to your digital music - whether youre grooving at your computer, piping tracks to your home stereo, or loading your iPod or MP3 player - MusicIP makes music more accessible and more enjoyable.

MusicIP Mixer a multi-million dollar MUSIC development application---and it’s yours for FREE.

Rediscover your collection.
Do you have tons of digital music, but not much time? Are you in the mood for great tunes, but dont have the patience - or the interest - in thumbing through your tracks?

MusicIP makes it simple. Pick one song. Click one button. Get one amazing playlist that includes the perfect tracks from every corner of your collection - instantly.

Discover new music that suits YOU.
Finding new music is even harder than finding your old music. The best indicator of what you like is what you already have. So why not use your old music to find new music? MusicIP gives you access to search the worlds largest collection of related tracks so that you can find new artists or songs...right now.

Sysrinx is a semi-intelligent controller for mpg123 that features searching ID3 tags and random song selection.
Here is how to setup:
First youll have to add you mp3s to the database, if you have all your mp3s in /mp3 you do this:
syrinx -U /mp3
This adds all files with a .mp3 extension recursively starting from /mp3. If you have more in other directories just specify the base for those when its finished adding the first ones.
Note: this may take a while if you have a lot of mp3s or a lot of other files stored above the base directory, also only mp3s with id3 tags will be added to the database as they are needed for searching. When you need to add more mp3s just use -U to add them, tracks which are already in the database will not be overwritten.
Use:
syrinx "search string" will play songs whose title, album name, or artist match the string you entered
-t "search string" will restrict the search to title
-a to album
-p to artist, and
-g to genre (note -g uses the genre names i.e. Classical, Metal, not the number)
syrinx -f will play random songs, but will play songs you listen to all the way through more, and songs you skip less. You can also specify a search string after -f so it will only play song from a certain subset.
To skip a song press ctrl-c, to exit press ctrl-c twice in quick succesion, like the operation of mpg123 on its own.
Enhancements:
- Song can only be linked once in mood play now

eJourn is an application designed to help you track a journal or diary.
The general purpose of a journal, outside of a place to express frustrations, is to track events. Sometimes you keep a journal to track what you did today, maybe for your code, maybe for your general life: My great grandpa kept a very boring journal tel ling about things like "I went to town today."
Main features:
- Search functionality to help you find things based on keyword.
- Multiple Journals, to help you seperate things: Like keep a journal for a project, and a totally seperate personal one.
- Chronological ordering: Your paper does this, if you were careful; I promise to force you to
- Meta information, what was the weather like, how was your mood, when did you actually write the entry, does it relate to anything?
- Links/Relations to other journal entries, searches, or web URLs; and maybe more to come. These look like links in editable text.
Command line access:
- Ability to post data by piping into the running program
- Ability to pipe the current entry or selected text out of the program