Perl Whirl ’05 Seminars

Southwestern Caribbean • October 2nd to 9th, 2005

Use this form to familiarize yourself with Perl Whirl '05 offerings.

To help us tailor the Perl Whirl program, please select those courses that might interest you — were you to come along on our cruise.

You may choose any combination of full-, half-, or quarter-day seminars for a total of two-and-one-half (2.5) days' worth of sessions. The conference fee is $995 and includes all courses, course materials, and the Bon Voyage Cocktail Party.

Perl Whirl attendees may also "mix and match" and take any of the seminars offered in Linux Lunacy V
Introduction to Perl 6 (half day)
Parrot and the Perl 6 Compiler (half day)
Regular Expression Mastery (half day)
Programming with Iterators and Generators (half day)
Introduction to PostgreSQL (quarter day)
Introduction to Mod_perl 2.0 (half day)
Developing Web Applications using CGI::Prototype (half day)
PostgreSQL and Database Basics
(quarter day)
PostgreSQL: Advanced Topics (half day)
Creating Applications with PostgreSQL
and Perl
(half day)
Testing Perl
(half day)
Debugging Web Applications
(quarter day)
Creating Perl Distributions (half day)
When Perl is Not Quite Fast Enough (half day)
An Introduction to Voice- and Video-Over-IP
(half day)


My Name is:

My Home Email Address:

My Work Email Address:


Home Address

Address Line 1:

Address Line 2:

State or Region:

ZIP / Postal Code:

Home Phone Number:

Home Fax Number:

  Company Address

Company / Business Name (if applicable):

Title / Position:

Address Line 1:

Address Line 2:

State or Region:
ZIP / Postal Code:

Work Phone Number:

Work Fax Number:

  Other Comments:
Introduction to Perl 6 (half day)
Speaker: Allison Randal
    This talk is an introduction to Perl 6, the next major version of Perl. The primary focus is on the syntax of Perl 6, but beyond the syntax, we'll briefly look at the some of reasons behind the changes. What makes one feature more desirable than another? What makes it Perlish? What makes it DWIM? How on earth does Larry decide? You'll leave with a better understanding of the changes in Perl 6, and the fundamental nature of Perl itself.
Parrot and the Perl 6 Compiler (half day)
Speaker: Allison Randal
    Parrot is the virtual machine that will run Perl 6, as well as Python, Ruby, PHP, and a host of other dynamic languages. But more than that, it's a suite of tools for compiler writers. It boasts its own object-oriented assembly language, which is a breath of fresh air to anyone who's worked with XS. It even plays Tetris! This talk is an introduction to Parrot: what it is, how it works, and what you can do with it today. We'll also dig into the implementation of the Perl 6 compiler as a standard compiler module in Parrot.
Regular Expression Mastery (half day)
Speaker: Mark Jason Dominus

Almost everyone has written a regex that failed to match something they wanted it to, or that matched something they thought it shouldn't, and often it can be hard to predict what a regex will do. This class will fix that.

The first section will explore the algorithm that perl uses internally to do regex matching. Understanding this algorithm will allow us to predict whether a regex will match, which of several matches Perl will find, and which regexes will be faster than others. During this discussion we'll pause to discuss practical applications that illustrate features of the algorithm. We'll examine the essential but frequently misunderstood concept of 'greed', and we'll learn why commonly-used regex symbols like '.', '$', and '\1' might not mean what you thought they did.

In the second section, we'll apply our knowledge of the internals, examining at several common disasters, a few practical parsing applications, and some new features such that would have been hard to understand before. We'll see an example of every regex metacharacter and modifier. We'll finish with a discussion of some of the new optimizations that were added in Perl 5.6, and why you should avoid the '/i' modifier.

• Inside the Regex Engine

• Regular Expressions are Programs

• Backtracking

• Quantifiers

• Greed

• Anti-greed

• Anchors and assertions

• Backreferences

• Disasters and Optimizations

• Where machines come from

• Disaster examples

• Regex modifiers

• Tokenizing

• New optimizations

• Matching strings with balanced parentheses

Programming with Iterators and Generators (half day)
Speaker: Mark Jason Dominus

Sometimes you'll write a function that takes too long to run because it produces too much useful information. A search function might locate ten thousand matches. A database query might return ten million records. What can you do?

Perl provides a simple and familiar model for dealing with such problems: The filehandle! Instead of reading every file in one giant gulp, we can use filehandles to staunch the flow of information, trickling it into the program in manageable gulps.

In this class, we'll see several important modules, such as File::Find and DBI, which use this approach. We'll go inside these modules and see how to implement filehandle-like data structures and objects ourselves. We'll see how to write functions that suspend themselves and then pick up later where they left off. We'll learn how to take long-running slow functions and convert them into speedy filehandle-like data generator objects.

This fundamental technique is a mainstay of programmers in other languages, but isn't as well-known as it should be. You'll be amazed at how many difficult problems become simple when you unleash the power of filehandles.

• Introduction

• Filehandles are Iterators

• Iterators are Objects

• Common Examples of Iterators: readdir, each, and DBI

• Building iterators and Examples

• File tree scanning

• Permutations

• Genomic Sequence Generator

• Filehandle Iterators

• A Flat-File Database

• Searching Databases Backwards

• Random Number Generation

• Alternatives to Iterators

• Filters and Transforms: 'map' and 'grep' for iterators

• Recursively-Constructed Iterators

• The Semipredicate Problem

• Alternative Interfaces to Iterators: Tied scalars and handles

• An Extended Example: Web Spiders

Introduction to PostgreSQL (quarter day)
Speaker: Andrew Dunstan

How and why to get PostgreSQL up and running. Designed for those who don't know much about databases, and those who know about databases but don't know much about PostgreSQL. Bring laptops — we might include an installfest if time permits.

• What is a database? Why use one? Why PostgreSQL?

• Installing PostgreSQL

• Introduction to PostgreSQL Server and Client programs

• Configuring PostgreSQL

• Using the psql client

• Adminstrative GUIs

• PostgreSQL directions (or why I helped on the Windows port even though I'm a Linux fan)

PostgreSQL and Database Basics
(quarter day)

Speaker: Andrew Dunstan

Introductory or refresher session covering the major concepts that underlie most database systems. If you don't know or can't remember what a LEFT OUTER JOIN is, or what the difference is between a UNION and a JOIN, this session is for you.

• Relations (a.k.a. tables)

• PostgreSQL data types

• The four basic operations (SELECT INSERT UPDATE DELETE)

• Functions and expressions

• Table JOINs and their flavors

• Table UNIONs

• Indexes

• Foreign keys

• Constraints

• Sequences and ID fields

PostgreSQL: Advanced Topics (half day)
Speaker: Andrew Dunstan

The advanced facilties of PostgreSQL can make your applications work efficiently and securely. We explore what those facilities are, and how to make sure they are working well. This seminar will be very useful for database administrators, systems administrators, data architects, application architects and application programmers.

• Composite types, nested types,
domains, and arrays

• Views

• Permissions and Security

• Schemata

• Rules

• Triggers

• Stored Procedures and Functions

• Transactions

• Tuning PostgreSQL

• Configuration parameters

• Statistics


• Vacuuming

• Connection pooling

• Replication

• Backup and Restoration


Creating Applications with PostgreSQL
and Perl (half day)

Speaker: Andrew Dunstan

In this seminar learn to use the features of PostgreSQL in an application — with the emphasis on Perl-based applications. This session is about putting the knowledge from the previous sessions to practical use. Especially suitable for data architects, application architects, and application programmers.

• Using layered application design

• ServerSide vs. ClientSide programming

• Loading serverside language(s)

• Trusted and Untrusted languages

• Simple functions

• Triggers

• Returning a record

• Returning a set of things

• Calling back to the database

• PL/Perl limitations, and future plans

• Getting and installing the client libraries

• libpq — what it is, who uses it and
who doesn't

• Using DBI with PostgreSQL

• PostgreSQL programming for web apps (including mod_perl)

• Prepared Statements, and why you should use them whenever possible

• Other client interfaces (perl and non-perl).

• Case Studies from the speaker's experience

• Best Practice tips

Testing Perl (half day)
Speaker: brian foy
    Learn how to test your scripts and modules using Perl's test harness, Test::More, Test::Simple, and the popular Test modules available from CPAN. You don't have to be a Perl expert to start testing your creations. Spend a little time with testing and spend a lot less time debugging. Attendees should know how to create and run Perl scripts, and experience using Perl modules is helpful but not necessary. If you want to make your Perl more robust and have more confidence in your work, this course is for you.
Creating Perl Distributions (half day)
Speaker: brian foy
    Learn how to put together a Perl distribution, including an installer, a test suite, documentation, and all of the other \things that go into sharing your creations with the world. Learn how to use Module::Release to distribute your Perl creations. Attendees should know how to create and run Perl scripts, and experience creating Perl modules is helpful but not necessary. If you want to share your Perl code with the world, this course is for you.
When Perl is Not Quite Fast Enough (half day)
Speaker: Nicholas Clark
    This is a tutorial on how make Perl run faster, without having to use C or XS. In it you will learn ways I've found to make your troublesome slow scripts go faster, and how you can try to avoid some problems in the first place.
        The tutorial starts with ways to cheat and duck the whole optimising problem, as that's usually a much better solution. I present a systematic approach to optimising in general, and show the Perl tools available to help you carry it out. By explaining why the cause of slowness in Perl programs often differs from your experience of compiled languages, you will gain a better feel for the right types of trade-offs to make to gain speed.
        The second half presents a smorgasbord of optimising ideas to try out, and speed traps to locate and avoid. From clean grand plans to messy micro-optimising hacks, there is something for everyone. There's bound to be at least one approach you've never seen before that will set your mind racing, thinking about how your own code will benefit.
        The tutorial will demonstrate the techniques using specific real code as examples, showing code before and after. Running this interactively will give a feel for what sort of results can be achieved.
        Health warning — after attending this tutorial you may have trouble sleeping as you brain explores how to apply these ideas to your own code.
An Introduction to Voice- and Video-Over-IP
(half day)

Speaker: maddog

Tired of paying those phenomenal phone bills? Tired of paying for every little service that the telephone company deems you should have? Want to save your business heaps of money, yet still get the type of phone service you dream of? Then welcome to the wonderful world of OpenVoIP. Through projects like Bayonne, GnomeMeeting and Asterisk people can finally do the things that were demonstrated at the 1969 World's Fair, at a price they can afford. By the end of this half-day session you WILL be able to:

• make a long distance phone call from PC to PC for free

• make a long distance phone call from PC to any phone for pennies

• make a video call PC to PC for free

• learn about various low-cost devices to enhance your VoIP experience

and many more things. This talk will be aimed at a minimum of "technobabble" and a maximum of "here is how you do it, and here is where you get more information". Remember, the author wrote the first edition of "Linux for Dummies".

Introduction to Mod_perl 2.0 (half day)
Speaker: Randal Schwartz
    Learn about the heavy-lifting mod_perl interface for Perl embedded in the popular Apache web server in this introduction. We'll go over the API, including sample code, and installation instructions. A light introduction to the emerging mod_perl 2.0 for Apache2 will also be included.
Developing Web Applications using CGI::Prototype (half day)
Speaker: Randal Schwartz

Randal presents an introduction to what Captain Neil calls "the most significant web application module since", the recently released CGI::Prototype module.

Learn how every CGI application can be reduced to "figure out what state we're in ... what got sent ... what to respond", and how to represent that in this flexible framework. The framework maximizes code re-use through easy creation of data accessors and methods in a hierarchical class structure, including trivial one-off lightweight object classes for unusual situations or exceptions. The framework also leverages the industrial-strength Template Toolkit for generating output.

Full and robust "MVC" applications can be created using CGI::Prototype for the Controller, Template Toolkit for the View, and Class::DBI for the Model data. And although the name begins with CGI, this module is also fully compatible with mod_perl as well, either as a direct handler or as an Apache::Registry "script". Even in CGI mode, many things are lazy-loaded and can be cached, for rapid response!

The last half of the class will be spent building a complete application using CGI::Prototype, including deployed Class::DBI classes using DBD::SQLite for the database.

Debugging Web Applications (quarter day)
Speaker: Randal Schwartz

Debugging web applications can be annoying at best, and virtually impossible if you don't follow some basic guidelines. Randal talks about his methodologies of debugging web applications, starting with the basics of avoiding those "500 errors" through a simple placement of CGI::Carp. He then shows how to use a death handler that incorporates Data::Dumper as a means of placing a breakpoint in your web code to reveal the state of the application at any selected point. Randal also talks about using Devel::Cover and good web tests with WWW::Mechanize (and its cousin, CGI::Prototype::Mecha) to ensure that the testing covers your code, so you won't have as many surprises in the field once your code is deployed.