Free webobjects tutorial software for linux

Derbrill Tutorials are Free Tutorials For Writing Games and Multimedia Applications in Runtime Revolution with ArcadeEngine.

The tutorials come in a visually appealing e-book format which is both easy to read and use, the range of topics covered includes:

* The basics of Revolution such as: stacks, cards, scripts, messages and timers
* How to use geometric properties such as distances, angles and intersection rectangles
* Understanding and using different movements including linear, polygonal, circular and elliptic
* Advanced use of images
* Using the built-in collision detection

Test::LectroTest::Tutorial is a Perl module that contains documentation on how to use LectroTest to test your software.

SYNOPSIS

LectroTest is an automated, specification-based testing system. To use it, declare properties that specify the expected behavior of your software. Then invoke LectroTest to test whether those properties hold.

LectroTest does this by running repeated random trials against your software. If LectroTest finds that a property doesnt hold, it emits the counterexample that "broke" your software. You can then plug the counterexample into your software to debug the problem. (Its also a good idea to add the counterexample to your list of regression tests.)

Think of your softwares behavior as a haystack that youre searching for needles. Each error is a needle. You want to find the needles and remove of them. LectroTest will search the haystack for you -- its nice that way -- but first you must tell it about the shape of the haystack and how to recognize a needle when it sees one.

The Haystack

The shape of the haystack is defined by a set of "generator bindings," in which variables are bound to the output of value generators:

x = 0;

The above asserts for each point in the haystack that the output of the function the_thing_we_are_testing must be non-negative.

Put them together to make a Property

The generator bindings and needle recognizer are combined to make a property:

Property {
##[ x = 0;
}, name => "the_thing_we_are_testing(...) is non-negative";

Youll note that we also added a meaningful name. Although not strictly required, its an excellent practice that makes life easier. (Youll also note that we placed the generator bindings inside of the magic delimiters ##[ ]##. This tells Perl that our bindings are bindings and not regular Perl code.)

We can read the above property like so: "For all integers x and all characters c in the range A through Z, we assert that the_thing_we_are_testing is non-negative."

Testing whether your Properties hold

After you define properties for your software, just add them to a small Perl program that uses the Test::LectroTest module:

# MyProperties.l.t

use MyModule; # provides the_thing_we_are_testing
use Test::LectroTest;

Property {
##[ x = 0;
}, name => "the_thing_we_are_testing(...) is non-negative";

Then you can test your properties simply by running the program:

$ perl MyProperties.l.t

If your properties check out, youll see something like this:

1..1
ok 1 - the_thing_we_are_testing(...) is non-negative (1000 attempts)

If something goes wrong, however, LectroTest will tell you where it happened:

1..1
not ok 1 - the_thing_we_are_testing(...) is non-negative
falsified in 23 attempts
# Counterexample:
# $x = 4
# $c = "R"

What this says is that at the point (x=4, c="R") in the haystack, there is a needle (i.e., your property doesnt hold). With this information, you can examine your code to determine the cause of the error.

Bigtop::Docs::Tutorial is a simple case study of building a web app with bigtop.
Many (not all) applications are mostly data managers. That is, they are really intermediaries between users and various tables in a database. A bigtop file is meant to be a single place to describe all (or practically all) facits of the data in an application. This includes at least:
- The name and special features of each controller.
- The name of each table in the database.
- A description of each column (field) in each table in the database. This includes at least:
- its name and SQL type
- the label the user sees for it when it appears on the screen
- what type of html form element the user uses to enter or update it
- how the data is validated and filtered on its way into and out of the database (filtering yet supported)
- which table the field refers to if it is a foreign key
- etc.
All of these things, and more, are described in a Bigtop file. That file can be given to bigtop to build the application. Once it is built, it can be safely rebuilt so that only the generated bits are changed (this is accomplished by maintaining a clean separation between generated and hand edited files, and by config options in the bigtop file).
Notice that nothing in the above has committed you or me to any particular web application framework, data modeling scheme, templating system, or web server. Bigtop is neutral (think big tent), at least for Perl apps delivered via the web.

Album::Tutorial is a Perl module on how to use the Album program.

SYNOPSIS

This tutorial describes the basic use of the Album program to create and maintain browser based photo albums.

Getting started

To get started, create a new directory and cd to it. Create a subdirectory large and put some pictures there. If you have installed the album tool in your execution path, you can now execute it as follows:

$ album -v
No info.dat, adding images from large
info.dat: Cannot update (does not exist)
Number of entries = 7 (7 added)
mkdir thumbnails
mkdir icons
mkdir css
Creating icons: first-gr.png first.png ... sound.png movie.jpg
Creating style sheets: common.css index.css ... journal.css
im023.jpg: thumbnail OK
im024.jpg: thumbnail OK
im025.jpg: thumbnail OK
im026.jpg: thumbnail OK
im027.jpg: thumbnail OK
im028.jpg: thumbnail OK
im029.jpg: thumbnail OK
Creating pages for 7 images
(Needed to write 7 image pages)
Creating pages for 1 index
(Needed to write 1 index page)

Your results will vary, but be similar to this example run. What you can see is that album found 7 images in the large directory, created thumbnails, icons and css directories, created thumbnails by resizing the images, and finally created the HTML pages. You can inspect your first photo album by opening file index.html with your favorite browser. You can click on any image to see the larger version. Navigation buttons are provided to the left of the image.

It is interesting to run album again:

$ album -v
No info.dat, adding images from large
info.dat: Cannot update (does not exist)
Number of entries = 7 (7 added)
.......[7]
Creating pages for 7 images
(No image pages needed updating)
Creating pages for 1 index
(No index pages needed updating)

album tries to avoid doing unnecessary work as much as possible. In this case, all thumbnails and image and index pages are up to date. The line of periods shows progress, one period for each image processed.

Test::Unit::Tutorial is a Perl module that contains a tutorial on unit testing.

SYNOPSIS

perldoc Test::Unit::Tutorial

Here should be extensive documentation on what unit testing is, why it is useful, and how to do it with the Test::Unit collection of modules.

Sorry for not implementing this yet.

Please have a look at the examples in the examples directory and read the README file that came with this distribution.

A short tutorial on how to use the unit testing framework is included in Test::Unit::TestCase.

Further examples can be found by looking at the self test collection, starting in Test::Unit::tests::AllTests.

PDF::Reuse::Tutorial is a Perl module that will teach you how to produce PDF-files with PDF::Reuse.

In this tutorial I will show some aspects of PDF::Reuse, so you should be able to use it in your own programs. Most important is how to produce and reuse PDF-code, and then if you are interested, you can look at Graphics and JavaScript, so you can to do special things.

Reusing code:

You can take advantage of what has been done before, it is not necessary to start from scratch every time you create a PDF-file. You use old PDF-files as a source for forms, images, fonts and texts. The components are taken as they are, or rearranged, and you add your own texts and you produce new output.
If you dont care too much about the size of your templates, you should make them with a commercial, visual tool, thats most practical; and then you should use PDF::Reuse to mass produce your files. In this tutorial I show in many places how create single files with PDF::Reuse. That is possible, but more of an exception. I do it here to show the technique. You will anyway need it to add texts and graphics to your templates.

Graphics:

With this module you get a good possibility to program directly with the basic graphic operators of PDF. This is perhaps an advanced level, and you can avoid it if you want. On the other hand, it is not very difficult, and if you take advantage of it, your possibilities to manage text and graphics increase very much. You should look at the "PDF-reference manual" which probably is possible to download from http://partners.adobe.com/asn/developer/acrosdk/docs.html. Look especially at chapter 4 and 5, Graphics and Text, and the Operator summary.
Whenever the function prAdd() is used in this tutorial, you can probably get more explanations in the "PDF-reference manual". The code, you add to the content stream with prAdd(), has to follow the PDF syntax completely.

JavaScript:

You can add JavaScript to your PDF-file programmatically. This works with Acrobat Reader 5.0.5 or Acrobat 5.0 and higher versions.

You should have the "Acrobat JavaScript Object Specification" by hand. If you havent got Acrobat, you can probably download it from http://partners.adobe.com/asn/developer/technotes/acrobatpdf.html. It is technical note # 5186. JavaScript for HTML and PDF differs so much that you need the manual, even if you know JavaScript very well.

Array::Each::Tutorial - POD giving various examples how to use Array::Each.

SYNOPSIS

man Array::Each
man Array::Each::Tutorial

or

perldoc Array::Each
perldoc Array::Each::Tutorial

Overview

This tutorial contains only POD, so dont do this:

use Array::Each::Tutorial; # dont do this

Rather, simply read the POD (as you are doing). But first, please read the docs for Array::Each, because the whole scoop is there.

This tutorial is intended to augment those docs with examples showing situations where you might want to use Array::Each instead of other techniques.

EXAMPLES

Parallel Arrays vs. Using a Hash

First of all, use a hash. Its almost always the best solution if you want to associate a "key" with a "value". And there are modules available that will let you do wonderful things with hashes, like keeping the keys sorted or keeping them in the order they were added.

So given a hash, you might at some point want to do this:

my %h = ( a=>1, b=>2, c=>3, d=>4, e=>5 );
while( my( $k, $v ) = each %h ) {
# ... do something with $k and $v ...
}

On the other hand, if parallel arrays better implement your algorithm, then you may find you want to do something like this:

my @k = qw( a b c d e );
my @v = qw( 1 2 3 4 5 );
for my $i ( 0 .. $#k ) {
my( $k, $v ) = ( $k[$i], $v[$i] );
# ... do something with $k and $v (and maybe $i) ...
}

Using Array::Each, you could do the same thing this way:

use Array::Each;
my @k = qw( a b c d e );
my @v = qw( 1 2 3 4 5 );
my $obj = Array::Each->new( @k, @v );
while( my( $k, $v, $i ) = $obj->each ) {
# ... do something with $k and $v (and maybe $i) ...
}

If you dont need $i at all, you can leave it out, e.g.,

while( my( $k, $v ) = $obj->each ) {
# ... do something with $k and $v ...
}

If you have more than two parallel arrays, include them all in the call to new() and add as many "capture" variables as you need, e.g.,

my @k = qw( a b c d e );
my @v = qw( 1 2 3 4 5 );
my @p = qw( - + ~ = : );
my $obj = Array::Each->new( @k, @v, @p );
while( my( $k, $v, $p, $i ) = $obj->each ) {
# ... do something with $k, $v, and $p (and maybe $i) ...
}