Free methods of execution software for linux

Method::Declarative is a Perl module to create methods with declarative syntax.

SYNOPSIS

use Method::Declarative
(
--defaults =>
{
precheck =>
[
[ qw(precheck1 arg1 arg2) ],
# ...
],
postcheck =>
[
[ qw(postcheck1 arg3 arg4) ],
# ...
],
init =>
[
[ initcheck1 ],
# ...
],
end =>
[
[ endcheck1 ],
# ...
],
once =>
[
[ oncecheck1 ],
] ,
package => __CALLER__::internal,
},
method1 =>
{
ignoredefaults => [ qw(precheck end once) ],
code => __method1,
},
) ;

The Method::Declarative module creates methods in a using class namespace. The methods are created using a declarative syntax and building blocks provided by the using class. This class does not create the objects themselves.

The using class invokes Method::Declarative, passing it list of key-value pairs, where each key is the name of a method to declare (or the special key --default) and a hash reference of construction directives. The valid keys in the construction hash refs are:

code

The value corresponding to code key is a method name or code reference to be executed as the method. It is called like this:

$obj->$codeval(@args)

where $obj is the object or class name being used, $codeval is the coresponding reference or method name, and @args are the current arguments for the invocation. If $codeval is a method name, it needs to be reachable from $obj.

A code key in a method declaration will override any code key set in the --defaults section.

end

The value corresponding to the end key is an array reference, where each entry of the referenced array is another array ref. Each of the internally referenced arrays starts with a code reference or method name. The remaining elements of the array are used as arguments.
Each method declared by the arrays referenced from end are called on the class where the declared method resides in an END block when Method::Declarative unloads.

Each method is called like this:

$pkg->$codeval($name[, @args]);

where $pkg is the package or class name for the method, $name is the method name, and @args is the optional arguments that can be listed in each referenced list.

end blocks are run in the reverse order of method declaration (for example, if method1 is declared before method2, method2s end declaration will be run before method1s), and for each method they are run in the order in which they are declared.

Note that this is not an object destructor, and no objects of a particular class may still exist when these methods are run.

ignoredefaults

The value corresponding to the ignoredefaults key is an array reference pointing to a list of strings. Each string must corespond to a valid key, and indicates that any in-force defaults for that key are to be ignored. See the section on the special --defaults method for details.

init

The value corresponding to the init key is identical in structure to that corresponding to the end key. The only difference is that the declared methods/code refs are executed as soon as the method is available, rather than during an END block.

once

The value corresponding to the once key is identical in structure to that corresponding to the end key. The values are used when the method is invoked, however.

If the method is invoked on an object based on a hash ref, or on the class itself, and it has not been invoked before on that object or hash ref, the methods and code refs declared by this key are executed one at a time, like this:

$obj->$codeval($name, $isscalar, $argsref[, @args ]);

where $obj is the object or class on which the method is being invoked, $codeval is the method name or code reference supplied, $name is the name of the method, $isscalar is a flag to specify if the declared method itself is being executed in a scalar context, $argsref is a reference to the method arguments (@_, in other words), and @args are any optional arguments in the declaration.

The return value of each method or code reference call is used as the new arguments array for successive iterations or the declared method itself (including the object or class name). Yes, that means that these functions can change the the object or class out from under successive operations.

Any method or code ref returning an empty list will cause further processing for the method to abort, and an empty list or undefined value (as appropriate for the context) will be returned as the declared methods return value.

package

The value coresponding to the package key is a string that determines where the declared method is created (which is the callers package by default, unless modified with a --defaults section). The string __CALLER__ can be used to specify the callers namespace, so constructions like the one in the synopsis can be used to create methods in a namespace based on the calling package namespace.

postcheck

The value coresponding to the postcheck key is identical in structure to that coresponding to the end key. The postcheck operations are run like this:

$obj->$codeval($name, $isscalar, $vref[, @args ]);

where $obj is the underlying object or class, $codeval is the method or code ref from the list, $name is the name of the declared method, $isscalar is the flag specifying if the declared method was called in a scalar context, $vref is an array reference of the currently to-be-returned values, and @args is the optional arguments from the list.

Each method or code reference is expected to return the value(s) it wishes to have returned from the method. Returning a null list does NOT stop processing of later postcheck declarations.

precheck

The precheck phase operates similarly to the once phase, except that its triggered on all method calls (even if the underlying object is not a hash reference or a class name).
Any illegal or unrecognized key will cause a warning, and processing of the affected hashref will stop. This means a --defaults section will be ineffective, or a declared method wont be created.

Devel::TraceMethods is a Perl module for tracing module calls.

SYNOPSIS

use Devel::TraceMethods qw( PackageOne PackageTwo );

Devel::TraceMethods allows you to attach a logging subroutine of your choosing to all of the methods and functions within multiple packages or classes. You can use this to trace execution. It even respects inheritance.
To enable logging, pass the name of the packages you wish to trace on the line where you use Devel::TraceMethods. It will automatically install logging for all functions in the named packages.

You can also call import() after you have use()d the module if you want to log functions and methods in another package.

You can specify per-package (or per-class) logging subroutines. For example:

Devel::TraceMethods( SomePackage => &log_one, OtherPackage => &log_two );
callback( $subroutine_reference )

By default, Devel::TraceMethods uses Carp::carp() to log a method call. You can change this with the set_logger() function. Pass a subroutine reference as the only argument, and all subsequent calls to logged methods will use the new subroutine reference instead of carp().

The first argument to the logging subroutine is the full name of the logged method. The rest of the arguments are copies of those being passed to the logged method. You can modify them in the logging subroutine without disturbing your call.

Apache mod_suid allows per-vhost execution of scripts under their own UIDs. It functions in a way similar to Apaches perchild MPM, but differs in a number of ways.

Apache mod_suid does per child user/group switching; the Apache MPM makes switches based on vhosts. All processing is done under a specific UID/GID, including PHP and mod_perl scripts.

Yahoo::Marketing::AdResponse is an object to represent a Yahoo Marketing AdResponse.

SYNOPSIS

See http://ysm.techportal.searchmarketing.yahoo.com/docs/reference/dataObjects.asp for documentation of the various data objects.

METHODS

new

Creates a new instance

get/set methods

ad
editorialReasons
errors
operationSucceeded

get (read only) methods

Sleep is a perl inspired embed-able scripting language for Java applications.
Sleep source and binaries are released under the GNU Lesser General Public License.
Main features:
- Perl inspired language syntax
- Fast execution / small runtime size (170 KB)
- Parsed scripts can be serialized
- Easy API for making application data structures / functionality available to scripters
- Access, create, and query Java objects from Sleep scripts
- Full documentation for application developers and end-user scripters
Enhancements:
- Scalar reference sugar was added for moving scalars between scopes
- The backtick operator was added to spawn an external program (a la Perl).
- Java method resolution was updated to handle byte and char arrays better.
- Set functions now rely on scalar identity for union, intersect, and difference.
- Class/package importing is now more verbose about errors.

FlameRobin project is a database administration tool for Firebird DBMS.
Main features:
- lightweight (small footprint, fast execution)
- cross-platform (Linux, Windows for start, others planned too)
- dependant only on other open source software

Yahoo::Marketing::ErrorType is an object to represent a Yahoo Marketing ErrorType.

SYNOPSIS

See http://ysm.techportal.searchmarketing.yahoo.com/docs/reference/dataObjects.asp for documentation of the various data objects.

new

Creates a new instance

METHODS

get/set methods

key
param

get (read only) methods

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.