Free introspection software for linux

XMMS InfoPipe is a plugin that reports XMMS status via named pipe. XMMS InfoPipe is handy if you want to add interesting real-time information for a personal web page, or a web cam page.

While theres a possibility of setting up programs to be executed by XMMS when changing songs, XMMS InfoPipe provides better introspection: You can get information on song position, song length, playlist position, status (stopped/playing/paused), song title as displayed by XMMS, and file name. The information is reported in easily parseable textual format.

The possibilities for information use are limitless. So far, here are some of the things people have been using InfoPipe for:

Showing information of XMMS on home page, webcam page, or something related (script included)
Showing player information on IRC (spotted one script for Irssi)
Using any speech synthetizer to say the song information, reducing the need for external displays, and helping listening to unfamiliar music in bed when all you have is a remote control =) (script included).

Yeah, LIRC plugin seems to support this already, but it only supports ViaVoice - this allows you to use any speech synth... or any other types of output. Just an example of flexibility - I created the script to do that at 4 oclock in the morning, and even got 99% of Perl recommendations of good coding right, even when I wasnt fully awake.

XSpyDer is XSD introspection in python.

The project is meant to create a dom representation of a XSD document with included types and create an intermediate representation that can create classes in other languages such as PHP, but also python, C, java, English.

Moose::Cookbook::FAQ is a frequenty asked questions about Moose.

Is Moose "production ready"?

Yes and No. Currently I have one web application in production using Moose, and at $work we are re-writing our core offering to use Moose. Several other people on #moose either have sites in production which use Moose, or are in the process of deploying sites which use Moose.

The biggest barrier to widespread use of Moose in production right now is speed of development and speed of execution.

Since development is still happening, regular upgrades are a fact of life. This can be hairy in production, so if this makes you quake with fear, you might want to wait a few months.

Then comes speed of execution. Moose is actually pretty fast, and makes great effort to stay out of your way when you dont want it there. However, certain parts of Moose are slow, such as compile time setup, introspection and object construction (only because it uses introspection). See "Is Moose slow?" below for a deeper discussion on the subject.

Is Mooses API stable?

Yes and No. The external API, the one 90% of users will interact with, is very stable and any changes will be 100% backwards compatible. The introspection API is mostly stable, I still reserve the right to tweak that if needed, but I will do my absolute best to maintain backwards comptability here as well.

Is Moose slow?

Again, this one is tricky, so Yes and No.

First let me say that nothing in life is free, and that some Moose features do cost more than others. It is also the policy of Moose to only charge you for the features you use, and to do our absolute best to not place any extra burdens on the execution of your code for features you are not using.

Next, I will point out again that we are still in the "early adopter" phase, so speed it not that important yet. We are actually optimizing for "theoretical correctness" first, and we will optimize for speed later. It has been our experience that taking this approach allows for greater optimization capacity.

And lastly, I want to reassure the speed junkies out there that we are working on it.
We have the immutable classes in Class::MOP, but which are not yet integrated with Moose. These allow you to "close" a class and then for many of its more expensive methods to me memoized. Our tests indicated a performance comparable (and in some instances exceeding) that of hand-coded Perl.

We are also discussing and experimenting with Module::Compile, and the idea of compiling highly optimized .pmc files. And we have also mapped out some core methods as canidates for conversion to XS.

Texplore is a type explorer for GObject based libraries. You can see what signals, properties, and other things are present in each type, its parents, and its children.

Its similar to System.Reflection.Emit from Mono, only it uses the GObject librarys API and introspection capabilites.

Installation:

./autogen.sh
./configure --prefix=/tmp
make
make install
$/tmp/bin/texplore & #yove done it

dbscript is an open source web development framework, it saves time and effort by handling complex-but-common tasks with objects based on proven design patterns.
The Mapper and Route classes are a good example, they map actions and records to distinct urls, and the meta-information allows a programmer to type url_for( resource ) to build a dynamic url.
Restful urls, http-style controllers, atompub/html introspection documents and content-negotiation are among the sophisticated features of this programmer-centric development tool.
dbscript framework is a database abstraction layer, with built-in adapters for PostgreSQL and MySQL.
Enhancements:
- Qooxdoo Ajax templates OpenID login accounts Users & Groups permissions

Dylan is an advanced, object-oriented, dynamic language which supports the rapid development of programs.
When needed, the programmer can later optimize [his or her] programs for more efficient execution by supplying type information to the compiler. Nearly all entities in Dylan (including functions, classes, and basic data types such as integers) are first class objects.
Additionally Dylan supports multiple inheritance, polymorphism, multiple dispatch, keyword arguments, object introspection, and many other advanced features...
Main features:
- An advanced object model. Dylans object model is more powerful than those of most mainstream languages, but more familiar than what youd find in an academic language.
- Efficiency and flexibility. Dylan can be used as a dynamic prototyping language (like Smalltalk) or an efficient compiled language. Functional Developer, Functional Objects Dylan compiler, generates code as good as that of most C compilers. Still, it provides an interactive prototyping environment like those found in Smalltalk or Common Lisp.
- Support for advanced IDEs. The original implementation of Dylan stored code in a database and provided multiple views of how definitions were related. Cross-referencing, hypercode and online documentation were all popular research topics among the languages designers.
- Infix syntax. (Most languages, including C, are infix. LISP is prefix and Forth is postfix.)

Sub::DeferredPartial is a deferred evaluation / partial application.

SYNOPSIS

use Sub::DeferredPartial def;

$S = def sub : P1 P2 P3 { %_=@_; join , @_{qw(P1 P2 P3)} };

print $S->( P1 => 1, P2 => 2, P3 => 3 )->(); # 123

$A = $S->( P3 => 1 ); # partial application
$B = $S->( P3 => 2 );

$C = $A + $B; # deferred evaluation

$D = $C->( P2 => 3 );
$E = $D->( P1 => 4 );

print $E->(); # force evaluation: 863

$F = $E - $D;

$G = $F->( P1 => 0 ) / 2;

print $G->(); # 400
print $G; # ( ( CODE(0x15e3818): P1 => 4, P2 => 3, P3 => 1 + CODE ...

$F->(); # Error: Free parameter : P1
$A->( P3 => 7 ); # Error: Bound parameter: P3
$A->( P4 => 7 ); # Error: Wrong parameter: P4

An instance of this class behaves like a sub (or, more precisely: subroutine reference), but it supports partial application and the evaluation of operators applied to such function objects is deferred too.

That means, evaluation has to be forced explicitly (which makes it easier to add introspection capabilities).

Objects that represent deferred (delayed, suspended) expressions are known as suspensions or thunks in various programming circles. Dont confuse with the same terms in the context of threads!