| |
|
|
|
|
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
• Using EXPLAIN ANALYSE
• 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 CGI.pm", 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. |
|
