Free dynamic objects software for linux

Dynamic MP3 Lister was a project I started a long time ago to create dynamic lists of MP3s quickly and easily.

Features MP3 Information extraction for things like bitrate, channels, playtime and more.

Please note that this script is discontinued, and is only shown here now as an example of my work.

Dynamic Probe Class Library (DPCL) is an object-based C++ class library that provides the necessary infrastructure to allow tool developers and sophisticated tool users to build parallel and serial tools through technology called dynamic instrumentation.
Dynamic Probe Class Library takes the basic components needed by tool developers and encapsulates them into C++ classes. Each of these classes provide the member functions necessary to interact and dynamically instrument a running application with software patches called probes.
Dynamic instrumentation provides the flexibility for tools to insert probes into applications as the application is running and only where it is needed.
Enhancements:
- This version is a minor update to DPCL that fixes a couple problems that have been reported since the v3.4.2 release

Dynamic Imager provides a small product with which you can generate dynamic images given a text.
This enables you to rotate text in browsers that do not support that.
The DynamicImager product is a small utility product that uses PIL to generate images on the fly, given a few parameters, like the font to use, a text, a background color, etc.
This enables you to rotate texts in browsers that normally do not support that option, but you can do much more.
The product currently supports:
- font
- text
- fill color
- background color
- width
- height
- rotation in degrees
- x offset for text
- y offset for text
Enhancements:
- includes a demo with all features of the product

Dynamic Copyright it! is an easy-to-install, easy-to-use PHP script that adds copyright notices to your images dynamically, meaning that the copyright notices are generated on the fly.
If you get tired of changing the copyright on your images from year to year, this tools makes it so you never have to. You can use the Dynamic Copyright It! script for your own benefit, or add it to your web site for additional functionality.
Main features:
- Dynamic Copyright It! is easy to install. Just unzip and upload, or if youre using it on a local server, just unzip!
- Choose your copyright text, the font size, even the color!
- Dynamic Copyright It! integrates the copyright notice right in the image, so its difficult to remove.
- Copyright notices are added to images on-the-fly, making it so you can easily integrate other scripts to alter the copyright text site-wide without having to edit all of your images manually.

Games::Object is a Perl module to provide a base class for game objects.

SYNOPSIS

package MyGameObject;
use Games::Object;
use vars qw(@ISA);
@ISA = qw(Games::Object);

sub new {
# Create object
my $proto = shift;
my $class = ref($proto) || $proto;
my $self = $class->SUPER::new(@_);
bless $self, $class;

# Add attributes
$self->new_attr(-name => "hit_points",
-type => int,
-value => 20,
-tend_to_rate => 1);
$self->new_attr(-name => "strength",
-type => int,
-value => 12,
-minimum => 3,
-maximum => 18);
...

return $self;
}

package MyObjectManager;
use Games::Object::Manager;
use vars qw(@ISA);
@ISA = qw(Games::Object::Manager);

sub new {
my $proto = shift;
my $class = ref($proto) || $proto;
my $self = $class->SUPER::new( , @_);
bless $self, $class;
...
return $self;
}


my $world = new MyObjectManager;
my $object = new MyGameObject;
$world->add($object);

ABSTRACT

The purpose of this module is to allow a programmer to write a game in Perl easily by providing a basic framework in the form of a module that can be either subclassed to a module of your own or used directly as its own object class. The most important items in this framework are:

Attributes

You can define arbitrary attributes on objects with rules on how they may be updated, as well as set up automatic update of attributes whenever the objects process() method is invoked. For example, you could set an attribute on an object such that:

It ranges from 0 to 100.

Internally it tracks fractional changes to the value but accessing the attribute will always round the result to an integer.

It will automatically tend towards the maximum by 1 every time process() is called on the object.

A method in your subclass will be invoked automatically if the value falls to 0.
This is just one example of what you can do with attributes.

Flags

You can define any number of arbitrarily-named flags on an object. A flag is a little like a boolean attribute, in that it can have a value of either true or false. Like attributes, flags can be created independently on different objects. No "global" flag list is imposed.

Load/Save functionality

Basic functionality is provided for saving data from an object to a file, and for loading data back into an object. This handles the bulk of load game / save game processing, freeing the programmer to worry about the mechanics of the game itself.

The load functionality can also be used to create objects from object templates. An object template would be a save file that contains a single object.

Object Managers

New to version 0.10 of this module is object managers. An object manager is a Perl object that allows you to manage groups of related game objects. The object manager allows you to relate objects together (for example, you could define a relationship that allows certain objects to act as containers for other objects). In effect, the object manager acts as your world or universe.
Like the game object class, the manager class can be subclassed, allowing you augment its functionality. An object manager can be loaded and saved, which in turn performs a load or save of the objects being managed by it.

mockpp is a platform independent generic unit testing framework for C++. Mock Objects for C++ goal is to facilitate developing unit tests in the spirit of Mock Objects for Java, EasyMock and jMock.
Mock objects allow you to set up predictible behaviour to help you test your production code by emulating some functionality your code depends on. This might for example be a huge database which is too difficult and time consuming to maintain just for testing purposes.
Originally I started with a port of MockObjects to C++ and wanted to keep the same interfaces. But in the meanwhile I found out more about Java and its differencens to C++ (its funny reflection api for example ) and so I had to change a bunch of details.
Additionally I included the working method of EasyMock. From my limited understanding of Java there seems to be something similar in MockObjects but I guess EasyMock is easier to use and certainly was easier to port to C++.
Enhancements:
- This release fixes a compilation issue on Mac OS platforms and a parsing problem with mockpp2xml.

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.)