N:aRC is comes from Necs Amarok Remote Control and is a shell script, which allows the (remote) controlling of amarok per ssh.

It is mainly a wrapper for the amarok DCOP functions, but also simplifies the ssh process.

It is possible to run it with keyboard shortcuts.

Usage: $0 [Options] < Command >

--help, -h Prints this help message
--version, -v Prints the version information

Options could be one or more of the following:

--host, -H Sets the host to connect to
--user, -u Sets the user as which to connect
< user >@< host > Same as "-H < host > -u < user >"
--remove, -r Removes the authorization file afterwards
--append, -a Append the authorization file to the existing one and do not replace it

Command could be one of the following:

add < DIR > Adds DIR to current playlist
create < DIR > Creates new playlist from DIR
play, p (Re)starts playing
pause, p Pauses playing
stop, s Stops playing
stopafter, f Stops after current song
next, n Goes to next item in playlist
prev, e Goes to previous item in playlist
current, c Prints currently playing song
random, r < on/off > Sets random mode on/off
volume, v < X > Sets volume to X %
volumeup, vu [n] Increases volume by n reasonable steps. (n defaults to 1)
volumedown, vd [n] Decreases volume by n reasonable steps. (n defaults to 1)

Whats New in This Release:

· This release adds a new command line option that is useful with keyboard shortcuts.

n-genes is a powerful Genetic Algorithms and Programming toolkit written for Java 5.

Using advanced object oriented techniques, like generics and introspection, it is one the simplest system to learn and use. N-geness design allows fast coding and a total flexibility.

n-genes is an open-source project released under GPL. It is free of charges.

Here are some key features of "N genes":

Stack-based Genetic Programming

The Genetic Programming implemented in n-genes relies on a linear postfix programs, close to Forth or Postscript programming languages. They allow the following advantages:

· High-level and turing-complete language (through flow-control instructions);
· Extendable and customisable instruction set;
· Possibility of using faster and simpler GA operators;
· Efficient bloat removing/controlling algorithms.

Modularity and Dynamic Config Files

All parts of evolutionary computing have been made components, through " Design Patterns" methodology. The benefits are:

· Separation of the behaviour from the representation, i.e. we can use the same operators for a GA doubles individual or for a GP problem;
· Short and readable code, since each object represents only a single operation and therfore has few and shorts methods.
· The possibility to change the components or their behaviour during evolution, for example changing dynamically the size of a population or using self-adaptating mutation operators.

The n-genes platform is coupled with a dynamic config file system. This system is able to instanciate whatever class, passing arbitrary parameters of whaterver types, whithout needing to extend the parser. Object introspection is used at initialisation.

Performances Optimisations

n-genes was written with high performance computing in mind. Here are the optimisations you get for free, using our platform:

· Object-recycling memory management, eliminating the time spent on objects allocation and garbage-collections;
· Efficient individual-level fitness cache, the fitness is lazy-computed and cached until the individual is mutated;
· Population-level individual cache, saving computation time when the population diversity dimish.

N-View is a network monitor for small and medium-sized networks. It features automatic scanning of subnets for host addresses, monitoring of ICMP responses from all hosts, signalling of timeouts and delays in the GUI and by mail, a portscanner, an SNMP client (MIB browser and trap receiver), a graphical display of network traffic for network interfaces, connectivity to hosts by telnet, HTTP browser, or an arbitrary external program (such as ssh), printing of network diagrams, automatic generation of HTML pages, and more.

Here are some key features of "N View":

Simple configuration:

· automatic scan for hosts, based on ICMP ("ping"),
· configurable limits for response delay, timeout and port scan interval,
· individual configuration can be stored in a configuration file;

Graphic display:

· automatic arranging of icons for hosts and subnets (optional),
· arbitrary background pictures for each screen,
· signalling delay and timeout of hosts and subnets with coloured icons,
· graphic display of traffic load for selected network interfaces,
· arbitrary labelling for all icons and windows;

Signalling of status changes on display, acoustic and per e-mail (optional):

· on timeout or delayed reply of a host,
· on changes of the open port status,
· on receiving of SNMP traps;

Management interface, connections to hosts:

· via external browser,
· via internal telnet client,
· via internal SNMP client/browser;

Flexible display:

· showing Subnets as tabbed or cascaded windows,
· coloured printer output of network diagrams,
· network diagrams can be accessed from HTML browsers from inside the network (external HTML server required);

N:PyTpl comes from Necs Python Template System and is a template script written in Python.

It parses template files and creates e.g. HTML as output. Therefore, it is ideal to use for HTML pages, because it reduces redundancy to an absolute minimum.

Templates

Files

- file extension: .tpl

Comments

- comments start with a hash # - only a full line can be commented out

Tags

- tags are written in-between square brackets and have to take a whole line: [Tag]
- whitespaces in front of a tag are allowed
- everything following a tag is called "the arguments"; every single line is one argument
- TAG(arg1,arg2) shows the definition above
- Names of tags:
+ can held every char - umlauts should be avoided
+ should not start with a dollar sign $ - these are handled by the system (differently)
+ should not consist of special characters
- in generally, newlines (n) are deleted from the arguments - these can be prevented by an exclamation mark ! at the end of the tag: [Tag!]
- if an option-tag should be disabled (e.g. $PARENTS_LINK), a question mark ? is used at the end of name: [Tag?] - alternatively you can state "NOT" as the argument
- should a tag be stated as a constant (ie. it isnt looked up during loops), append an equation sign = to the name of the tag: [Tag=]
- it is not possible to set multiple flags in one tag
- if arguments are given w/o a tag, they are said to belong to the tag $MAIN (q.v.)

Taggys

- taggys are these expressions, which are replaced by the arguments of the tag later on
- they are written in double curly braces: {{Taggy}}
- names of taggys:
+ _must_ have the same name as the corresponding tag
+ ==> same restrictions
- if a taggy cannnot be replaced, the whole argument is removed - this can be avoided by a terminating excl. mark: {{Taggy!}} - in this case the output will show {{Taggy}}
- if a taggy should not be processed during a loop, add an equation sign to the end: {{Taggy=}}

Whats New in This Release:

· Increased loop performance, a new loop type, and standard templates directly in the source.

This is a Gnome 2.X Icon-Theme of the Tux n Tosh iconset. Tux n Tosh also uses some Crystal icons to be more or less complete.

Tilt-n-Roll is a puzzle game where you must roll your marble through the 3d maze to the exit.

This game is an entry into Intels Game Demo 2007 contest. Please take the time to rate my game and help me win a prize!

Tilt the 3d maze and roll your marble to the exit. The final version will fully support laptop SMS / HDAPS sensors to allow players to tilt the laptop to play! (Support is partially there now - Linux users get an SDL patch and Mac users can wrangle with Unimotion).

Here are some key features of "Tilt n Roll":

· Multiple powerups, monsters, switches, puzzles, traps...
· Built-in level editor: design and share your mazes with friends!
· Keyboard or mouse control for unsupported laptops
· Plenty of sound effects and catchy music
· Physics calculations are run in a second thread: multicore users should see an increase in both framerate and simulation accuracy
· Runs on Windows, Mac OS or Linux.
· Completely open-source software under the GNU GPL!

MUNGE Uid N Gid Emporium is an authentication service for creating and validating credentials. It is designed to be highly scalable for use in an HPC cluster environment.

It allows a process to authenticate the UID and GID of another local or remote process within a group of hosts having common users and groups. These hosts form a security realm that is defined by a shared cryptographic key.

Clients within this security realm can create and validate credentials without the use of root privileges, reserved ports, or platform-specific methods.

Rationale

The need for MUNGE arose out of the HPC cluster environment. Consider the scenario in which a local daemon running on a login node receives a client request and forwards it on to remote daemons running on compute nodes within the cluster. Since the user has already logged on to the login node, the local daemon just needs a reliable means of ascertaining the UID and GID of the client process. Furthermore, the remote daemons need a mechanism to ensure the forwarded authentication data has not been subsequently altered.

A common solution to this problem is to use Unix domain sockets to determine the identity of the local client, and then forward this information on to remote hosts via trusted rsh connections. But this presents several new problems. First, there is no portable API for determining the identity of a client over a Unix domain socket. Second, rsh connections must originate from a reserved port; the limited number of reserved ports available on a given host directly limits scalability. Third, root privileges are required in order to bind to a reserved port. Finally, the remote daemons have no means of determining whether the client identity is authentic.

Overview

A process creates a credential by requesting one from the local MUNGE service. The encoded credential contains the UID and GID of the originating process. This process sends the credential to another process within the security realm as a means of proving its identity. The receiving process validates the credential with the use of its local MUNGE service. The decoded credential provides the receiving process with a reliable means of ascertaining the UID and GID of the originating process. This information can be used for accounting or access control decisions.

The contents of the credential (including any optional payload data) are encrypted with a key shared by all munged daemons within the security realm. The integrity of the credential is ensured by a message authentication code (MAC). The credential is valid for a limited time defined by its time-to-live (TTL). The daemon ensures unexpired credentials are not replayed on a particular host. Decoding of a credential can be restricted to a particular user and/or group ID. The payload data can be used for purposes such as embedding the destinations address to ensure the credential is only valid on a specific host. The internal format of the credential is encoded in a platform-independent manner. And the credential itself is base64 encoded to allow it to be transmitted over virtually any transport.

Whats New in This Release:

· A bug was fixed that caused stack corruption on AMD-64 when using Libgcrypt.

Rose::DateTime is a Perl module with DateTime helper functions and objects.

SYNOPSIS

use Rose::DateTime::Util qw(:all);

$now = parse_date(now);
$then = parse_date(12/25/2001 6pm);

$date_text = format_date($then, "%D at %T %p");

...

use Rose::DateTime::Parser;

$parser = Rose::DateTime::Parser->new(time_zone => UTC);

$date = $parser->parse_date(12/25/1999);

The Rose::DateTime::* modules provide a few convenience functions and objects for use with DateTime dates.

Rose::DateTime::Util contains a simple date parser and a slightly customized date formatter.

Rose::DateTime::Parser encapsulates a date parser with an associated default time zone.

This module (Rose::DateTime) exists mostly to provide a version number for CPAN. See the individual modules for some actual documentation.

Métamorphose File -n- Folder Renamer is a mass file renaming program that combines great flexability with an intuitive interface.

Métamorphose File -n- Folder Renamer allows many command line renaming operations in a single utility, well-suited for those who need to rename large numbers of files and/or folders on a regular basis.

However, the ease of the interface ensures that a first-time user will not find it too frustrating to use

Here are some key features of "Metamorphose File n Folder Renamer":

· Renames files and folders at the same time.
· Preview every item to be renamed before comiting changes.
· Load all files in directory and in subdirectories (recursive renaming).
· Undo renaming operation in case of mistakes.
· Rename MP3 files according to their ID3 tags.
· Use of all allowed characters under Windows and OSX, all except : in Linux.
· Save all program settings to file for later use!
· Renaming operations:
· Prefix
· Suffix
· Set file extension.
· Replacement, modification, or move by: Character, position, or regular expression.
· Insertion by: Position or every (number) characters.
· Length modifications (padding, truncating, or both).
· Renaming styles: combination of: user text, numbering, id3 tags, date, time.
· Modifications: UPPERCASE, lowercase, Capitalize first, Title Style, sWAP cASE, DoRkIfY
· Move by position, text, or regular expression.
· Sequential numbering (enumerating) options:
· Use integers, alphabetical, or roman numerals
· Pad with any valid character to any width.(integers only)
· Control step size, starting number, reset count.
· Set date and time manually or get from system.
· Use supplied defaults or specify your own date and time formats.
· Modular design allows great flexability and control, while keeping the easy stuff simple.

Rose::URI is a standalone URI class allowing easy and efficient manipulation of query parameters and other URI components.

SYNOPSIS

use Rose::URI;

$uri = Rose::URI->new(http://un:pw@foo.com/bar/baz?a=1&b=two+3);

$scheme = $uri->scheme;
$user = $uri->username;
$pass = $uri->password;
$host = $uri->host;
$path = $uri->path;
...

$b = $uri->query_param(b); # $b = "two 3"
$a = $uri->query_param(a); # $a = 1

$uri->query_param_delete(b);
$uri->query_param(c => blah blah);
...

print $uri;

Rose::URI is an alternative to URI. The important differences are as follows.

Rose::URI provides a rich set of query string manipulation methods. Query parameters can be added, removed, and checked for their existence. URI allows the entire query to be set or returned as a whole via the query_form or query methods, and the URI::QueryParam module provides a few more methods for query string manipulation.

Rose::URI supports query parameters with multiple values (e.g. "a=1&a=2"). URI has limited support for this (through query_forms list return value. Better methods are available in URI::QueryParam.

Rose::URI uses Apaches C-based URI parsing and HTML escaping functions when running in a mod_perl 1.x web server environment.

Rose::URI stores each URI "in pieces" (scheme, host, path, etc.) and then assembles those pieces when the entire URI is needed as a string. This technique is based on the assumption that the URI will be manipulated many more times than it is stringified. If this is not the case in your usage scenario, then URI may be a better alternative.

Now some similarities: both classes use the overload module to allow "magic" stringification. Both URI and Rose::URI objects can be printed and compared as if they were strings.
Rose::URI actually uses the URI class to do the heavy lifting of parsing URIs when not running in a mod_perl 1.x environment.

Finally, a caveat: Rose::URI supports only "http"-like URIs. This includes ftp, http, https, and other similar looking URIs. URI supports many more esoteric URI types (gopher, mailto, etc.) If you need to support these formats, use URI instead.

Rose::Object is a simple object base class.

SYNOPSIS

package MyObject;

use Rose::Object;
our @ISA = qw(Rose::Object);

sub foo { ... }
sub bar { ... }
...

my $o = MyObject->new(foo => abc, bar => 5);
...

Rose::Object is a generic object base class. It provides very little functionality, but a healthy dose of convention.

METHODS

new PARAMS

Constructs a new, empty, hash-based object based on PARAMS, where PARAMS are name/value pairs, and then calls init (see below), passing PARAMS to it unmodified.

init PARAMS

Given a list of name/value pairs in PARAMS, calls the object method of each name, passing the corresponding value as an argument. The methods are called in the order that they appear in PARAMS. For example:

$o->init(foo => 1, bar => 2);

is equivalent to the sequence:

$o->foo(1);
$o->bar(2);

Rose::DB::Object::Helpers is a mix-in class containing convenience methods for Rose::DB::Object.

SYNOPSIS

package MyDBObject;

use Rose::DB::Object;
our @ISA = qw(Rose::DB::Object);

use Rose::DB::Object::Helpers clone,
{ load_or_insert => find_or_create };
...

$obj = MyDBObject->new(id => 123);
$obj->find_or_create();

$obj2 = $obj->clone;

Rose::DB::Object::Helpers provides convenience methods from use with Rose::DB::Object-derived classes. These methods do not exist in Rose::DB::Object in order to keep the method namespace clean. (Each method added to Rose::DB::Object is another potential naming conflict with a column accessor.)

This class inherits from Rose::DB::Object::MixIn. See the Rose::DB::Object::MixIn documentation for a full explanation of how to import methods from this class. The helper methods themselves are described below.

Rose::DateTime::Util Perl module contains some simple DateTime wrapper functions.

SYNOPSIS

use Rose::DateTime::Util qw(:all);

$now = parse_date(now);
$then = parse_date(12/25/2001 11pm);

print $now->day_of_week; # e.g., "Monday"

# "December 25th 2001 at 11:00:00 PM"
$date_text = format_date($then, "%B %E %Y at %t");

EXPORTS

Rose::DateTime::Util does not export any function names by default.

The all tag:

use Rose::DateTime::Util qw(:all);

will cause the following function names to be imported:

format_date()
parse_date()
parse_epoch()
parse_european_date()

CLASS METHODS

error

Returns a message describing the last error that occurred.

european_dates [BOOL]

Get or set a boolean flag that determines how "xx/xx/xxxx" dates are parsed by the parse_date function. If set to a false-but-defined value, then such dates are parsed as "mm/dd/yyyy". If set to true, then theyre parsed as "dd/mm/yyyy". If set to undef, then the attribute resets to its initial value, which is determined as described below.

The initial value of this attribute is chosen based on the current locale as stored in DateTimes DefaultLocale setting. This initial value is looked up only once. Any subsequent changes to DateTimes DefaultLocale setting will be ignored until/unless this attribute is reset to undef.

time_zone [TZ]

Get or set the default time zone. This value is passed to DateTime->new(...) as the value of the time_zone parameter when parse_date() creates the DateTime object that it returns. The default value is "floating".

Rose::HTML::Objects is a Perl object-oriented interfaces for HTML.

SYNOPSIS

use Rose::HTML::Form;

$form = Rose::HTML::Form->new(action => /foo,
method => post);

$form->add_fields
(
name => { type => text, size => 20, required => 1 },
height => { type => text, size => 5, maxlength => 5 },
bday => { type => datetime },
);

$form->params(name => John, height => 6ft, bday => 01/24/1984);

$form->init_fields();

$bday = $form->field(bday)->internal_value; # DateTime object

print $bday->strftime(%A); # Tuesday

print $form->field(bday)->html;

The Rose::HTML::Object::* family of classes represent HTML tags, or groups of tags. These objects allow HTML to be arbitrarily manipulated, then serialized to actual HTML (or XHTML). Currently, the process only works in one direction. Objects cannot be constructed from their serialized representations. In practice, given the purpose of these modules, this is not an important limitation.

Any HTML tag can theoretically be represented by a Rose::HTML::Object-derived class, but this family of modules was originally motivated by a desire to simplify the use of HTML forms.

The form/field object interfaces have been heavily abstracted to allow for input and output filtering, inflation/deflation of values, and compound fields (fields that contain other fields). The classes are also designed to be subclassed. The creation of custom form and field subclasses is really the "big win" for these modules.

There is also a simple image tag class which is useful for auto-populating the width and height attributes of img tags. Future releases may include object representations of other HTML tags. Contributions are welcome.

Rose::DB::Object::QueryBuilder is a Perl module that can build SQL queries on behalf of Rose::DB::Object::Manager.

SYNOPSIS

use Rose::DB::Object::QueryBuilder qw(build_select);

# Build simple query
$sql = build_select
(
dbh => $dbh,
select => COUNT(*),
tables => [ articles ],
columns => { articles => [ qw(id category type title date) ] },
query =>
[
category => [ sports, science ],
type => news,
title => { like => [ %million%,
%resident% ] },
],
query_is_sql => 1);

$sth = $dbh->prepare($sql);
$dbh->execute;
$count = $sth->fetchrow_array;

...

# Return query with placeholders, plus bind values
($sql, $bind) = build_select
(
dbh => $dbh,
tables => [ articles ],
columns => { articles => [ qw(id category type title date) ] },
query =>
[
category => [ sports, science ],
type => news,
title => { like => [ %million%,
%resident% ] },
],
query_is_sql => 1,
sort_by => title DESC, category,
limit => 5);

$sth = $dbh->prepare($sql);
$dbh->execute(@$bind);

while($row = $sth->fetchrow_hashref) { ... }

...

# Coerce query values into the right format
($sql, $bind) = build_select
(
db => $db,
tables => [ articles ],
columns => { articles => [ qw(id category type title date) ] },
classes => { articles => Article },
query =>
[
type => news,
date => { lt => now },
date => { gt => DateTime->new(...) },
],
sort_by => title DESC, category,
limit => 5);

$sth = $dbh->prepare($sql);
$dbh->execute(@$bind);

Rose::DB::Object::Tutorial is a guided tour of the basics of Rose::DB::Object.

INTRODUCTION

This document provides a step-by-step introduction to the Rose::DB::Object module distribution. It demonstrates all of the important features using a semi-realistic example database. This tutorial does not replace the actual documentation for each module, however. The "reference" documentation found in each ".pm" file is still essential, and contains some good examples of its own.

This tutorial provides a gradual introduction to Rose::DB::Object. It also describes "best practices" for using Rose::DB::Object in the most robust, maintainable manner. If youre just trying to get a feel for whats possible, you can skip to the end and take a look at the completed example database and associated Perl code. But I recommend reading the tutorial from start to finish at least once.

The examples will start simple and get progressively more complex. You, the developer, have to decide which level of complexity or abstraction is appropriate for your particular task.

CONVENTIONS

Some of the examples in this tutorial will use the fictional My:: namespace prefix. Some will use no prefix at all. Your code should use whatever namespace you deem appropriate. Usually, it will be something like MyCorp::MyProject:: (i.e., your corporation, organization, and/or project). Ive chosen to use My:: or to omit the prefix entirely simply because this produces shorter class names, which will help this tutorial stay within an 80-column width.

For the sake of brevity, the use strict directive and associated "my" declarations have also been omitted from the example code. Needless to say, you should always use strict in your actual code.

Similarly, the traditional "1;" true value used at the end of each ".pm" file has been omitted from the examples. Dont forget to add this to the end of your actual Perl module files.

Although most of the examples in this tutorial use the base.pm module to set up inheritance, directly modifying the @ISA package variable usually works just as well. In situations where there are circular relationships between classes, the use base ... form may be preferable because it runs at compile-time, whereas @ISA modification happens at run-time. In either case, its a good idea to set up inheritance as early as possible in each module.

package Product;

# Set up inheritance first
use base qw(Rose::DB::Object);

# Then do other stuff...
...

Rose::HTML::Form is a HTML form base class.

SYNOPSIS

package PersonForm;

use Rose::HTML::Form;
our @ISA = qw(Rose::HTML::Form);

use Person;

sub build_form
{
my($self) = shift;

$self->add_fields
(
name => { type => text, size => 25, required => 1 },
email => { type => email, size => 50, required => 1 },
phone => { type => phone },
);
}

sub validate
{
my($self) = shift;

# Base class will validate individual fields in isolation,
# confirming that all required fields are filled in, and that
# the email address and phone number are formatted correctly.
my $ok = $self->SUPER::validate(@_);
return $ok unless($ok);

# Inter-field validation goes here
if($self->field(name)->internal_value ne John Doe &&
$self->field(phone)->internal_value =~ /^555/)
{
$self->error(Only John Doe can have a 555 phone number.);
return 0;
}

return 1;
}

sub init_with_person # give a friendlier name to a base-class method
{
my($self, $person) = @_;
$self->init_with_object($person);
}

sub person_from_form
{
my($self) = shift;

# Base class method does most of the work
my $person = $self->object_from_form(class => Person);

# Now fill in the non-obvious details...
# e.g., set alt phone to be the same as the regular phone
$person->alt_phone($self->field(phone)->internal_value);

return $person;
}

...

#
# Sample usage in a hypothetical web application
#

$form = PersonForm->new;

if(...)
{
# Get query parameters in a hash ref and pass to the form
my $params = MyWebServer->get_query_params();
$form->params($params);

# ...or initialize form params from a CGI object
# $form->params_from_cgi($cgi); # $cgi "isa" CGI

# ...or initialize params from an Apache request object
# (mod_perl 1 and 2 both supported)
# $form->params_from_apache($r);

# Initialize the fields based on params
$form->init_fields();

unless($form->validate)
{
return error_page(error => $form->error);
}

$person = $form->person_from_form; # $person is a Person object

do_something_with($person);
...
}
else
{
$person = ...; # Get or create a Person object somehow

# Initialize the form with the Person object
$form->init_with_person($person);

# Pass the initialized form object to the template
display_page(form => $form);
}
...

Rose::HTML::Form is more than just an object representation of the HTML tag. It is meant to be a base class for custom form classes that can be initialized with and return "rich" values such as objects, or collections of objects.

Building up a reusable library of form classes is extremely helpful when building large web applications with forms that may appear in many different places. Similar forms can inherit from a common subclass, and forms may be nested.

This class inherits from, and follows the conventions of, Rose::HTML::Object. Inherited methods that are not overridden will not be documented a second time here. See the Rose::HTML::Object documentation for more information.

Rose::Object::MakeMethods::Generic is a Perl module that can create simple object methods.

SYNOPSIS

package MyObject;

use Rose::Object::MakeMethods::Generic
(
scalar =>
[
power,
error,
],

scalar --get_set_init => name,

boolean --get_set_init => is_tall,

boolean =>
[
is_red,
is_happy => { default => 1 },
],

array =>
[
jobs => {},
job => { interface => get_set_item, hash_key => jobs },
clear_jobs => { interface => clear, hash_key => jobs },
reset_jobs => { interface => reset, hash_key => jobs },
],

hash =>
[
param => { hash_key => params },
params => { interface => get_set_all },
param_names => { interface => keys, hash_key => params },
param_values => { interface => values, hash_key => params },
param_exists => { interface => exists, hash_key => params },
delete_param => { interface => delete, hash_key => params },

clear_params => { interface => clear, hash_key => params },
reset_params => { interface => reset, hash_key => params },
],
);

sub init_name { Fred }
sub init_is_tall { 1 }
...

$obj = MyObject->new(power => 5);

print $obj->name; # Fred

$obj->do_something or die $obj->error;

$obj->is_tall; # true
$obj->is_tall(undef); # false (but defined)
$obj->is_tall; # false (but defined)

$obj->is_red; # undef
$obj->is_red(1234); # true
$obj->is_red(); # false (but defined)
$obj->is_red; # false (but defined)

$obj->is_happy; # true

$obj->params(a => 1, b => 2); # add pairs
$val = $obj->param(b); # 2
$obj->param_exists(x); # false

$obj->jobs(butcher, baker); # add values
$obj->job(0 => sailor); # set value
$job = $obj->job(0); # sailor

Petals on a Rose is an intriguing puzzle game for all ages. This website claims that Bill Gates was stumped by it for two days. Its usually played with a group of friends and a set of 5 dice. The game master rolls the dice and tells everyone the answer. This computer version of the puzzle works similarly, only in this case the computer plays as the game master.

To play you just double click the icon to start the program. Type your guess in the "Answer" field and press "Check". If your guess is correct you get congratulated, otherwise you need to try again. If you get tired of guessing you can press the "Give Up" button and youll get the answer to that particular roll.

Just press the "Roll Dice" button at any time to get a new set of numbers.

Always remember, dont tell the answer to anyone!

Have fun, and good luck.