Some of the proceedings and slides can be found online:R. Geoffrey Avery: ModuleMaker
Nicholas Clark: When perl is not quite fast enough
Wolfgang Laun: elektra_ps.ppt
Karen Pauley: PsychometricTesting.pdf
Allison Randal: topic.pdf
Allison Randal: tagmemics.pdf
Lucy McWilliam: Sex, Flies and Microarrays
by Juan J. Merelo; 2h tutorial
I would like to propose a tutorial on evolutionary computation using Perl, SOAP, and XML. It would be based on my EC Perl module, opeal, at <http://opeal.sourceforge.net/> , and would include the following topics:
I would go for a 1.5 hour presentation, if there's no time slot available for tutorials.
by Michael G Schwern ; 3h tutorial
Building on the basic techniques in Test::Tutorial, we'll learn about how to write tests for the more difficult situations you come up against in day-to-day programming.
by Tom Phoenix ; 4h tutorial
by Redvers Davies ; 3h tutorial
The slides and details are still linked off the 2001 YAPC website or directly at <http://www.criticalintegration.com/gtk-tutorial/>
Gtk is a graphical toolkit for building X11 based graphical applications. This tutorial assumes perl knowledge and is not for novices.
The first 20-30 mins or so of the tutorial is a background of Gtk, why, where and how. It emphasises the change in style from the more familier "straight line" programming to the seeming chaotic event-driven programming which is the fundimental of all Graphical programming.
The nasties of packing, boxes and getting used to the idea of giving up control.
A basic crib-sheet of basic widgets, functions and methods will be provided. This I found last year would be vital, as the process of re-affirming syntax via the slides is too time-consuming.
Then the fun starts.
A basic application requirement will be taken from the floor, and the application will be designed using pen and whiteboard. The structure will be explained, pitfalls will be purposefully fallen into to give the attendee a good basic understanding of how to write (and how not to write) basic X11 applications.
Last year, the application was the "Dutch Auction" program which was used at the end of YAPC::Europe.
Learning from the tutorial last year... I will be stricter on answering "pedant" questions like "Why don't you use a foreach loop" instead of assigning individual assignments. (Readability)
by Mark Overmeer ; 45' talk
This is about software development: when a tiny feature in a module gets implemented in a correct way, this one line of code gets encapsulated in subroutines/methods, documentation, tests, etc. This is about the difference between "solving my problem", which is the daily practice for writing applications, and "solving your problems", which is required for CPAN modules.
by Jonathan Stowe ; 60' talk
SOAP started life as the Simple Object Access Protocol, one of the productions of the W3 Consortium's XML Protocol working group. It defined a relatively lightweight means of doing Remote Procedure Calls (RPC) using XML over a pre-existing network transport protocol. The 1.2 version of the specification somewhat downgraded the acronym SOAP as features were added which probably meant that it not quite so Simple anymore and the RPC 'Object Access' simply became one of the ways in which the protocol be used for communication between systems.
Perl has, for quite some time, had good support both for XML processing and for handling a variety of common network transport protocols and thus was in a good position from the start to be able to provide good support for SOAP and so was able to take its deserved reputation as an excellent 'glue language' further beyond the boundaries of a single system or application than it previously had done and into the arena of application integration - previously the preserve of expensive and complicated middleware.
This will talk will include a a brief introduction to the history of and the rationale behind SOAP and the reasons why Perl was in a good position to be an early language for which a toolkit was available to build SOAP applications.
The remainder of the talk will focus on the use of Perl and SOAP in the integration of diverse applications and will include discussion of:
There will be working examples demonstrated in Perl and C++ (and possibly C# or Java) although this will be at a higher level than a tutorial.
This should serve both as an introduction to using SOAP with Perl for the uninitiated and also as a demonstration to people already familiar with it some further ways that it can be used.
by Arthur Bergman ; 45' talk
For the past two years Perl 5.8 has been one of the worst hidden skunkworks ever. Conceived approximately at the same time as the much publicized Perl 6 project, 5.8 (clandestinely disguised as 5.7) has made major enhancements to the Unicode functionality, sprouted a new user-visible threads implementation, silently assimilated several dozen modules, and created some completely new ones. Other new features and enhancements include a new stackable IO architecture, more accurate numbers and arithmetics, restricted hashes, and safe signals. Perl 5.8 is also the most thoroughly tested Perl release ever.
Come to hear what's new, what's changed, and what's gone.
by H.Merijn Brand ; 60' talk
How many hours a programmer will put in his program, and how many bugs he might have solved, and how much of the program is covered with working test code, bugs will probably always be present in the program or script.
The most recent development branch of the Perl code is called bleadperl, and it is patched by many on several parts on a daily basis. For every patch that solves a bug or extends the features of the rich language that Perl offers, other functionality might get busted or slightly broken.
Testing the latest state in as many configurations as possible on as many operating systems as possible with as many development enviroinments as possible is a great source of information to the perl5 porters. This process has been called ``smoke testing''.
With people working on various parts of the perl core simultaniously: threading and variable sharing, IO subsystems, reported bugs, formatting, configuration and hints, etc. etc., it is likely that minor changes might break basic features and patches liked and accepted by the GNU gcc compiler are rejected by other - more rigorously ANSI - C compilers.
To catch those, it would be good to have every patch tested on all supported platforms as soon as possible. But since bleading edge perl is a development release, it is likely to be far from stable at any point in time, and thus not to be installed by the faint of heart. Core dumps are likely to occur if a snapshot is released without being tested on a variety of configurations.
Test-Smoke is a package of scripts that enables
perl5-porters to receive test reports from users that have spare
CPU cycles and some disk space on their
The talk will deal with the development of what has evolved to Test-Smoke, currently available on CPAN. It will also deal with some differences in compilers, with different OS behaviour, and how new users can participate in this valuable process.
As a side step, some of the parts in the perl source tree are explained briefly but not profound and not to show what the implications might be of what smoke testing detects.
by Damian Conway and Larry Wall ; 60' talk
See Damian's online abstract .
by Allison Randal ; 60' talk
This talk describes the new behaviour of $_ in Perl 6. (it was well received at YAPC::NA)
by Jos Boumans ; 90' talk
The following bit is stolen directly off <http://poe.perl.org> (all good things stem from there):
POE parcels out execution time among one or more tasks, called sessions. Sessions multitask through cooperation (at least until Perl's threads become mainstream). That is, each session returns execution to POE as quickly as possible so it can parcel out time to the next.
POE includes a high-level component architecture. Components are modular, reusable pieces of programs. They perform common, often tedious tasks so programmers can work on more interesting things.
Several POE components have been written to handle client, server, and peer networking tasks. Because of them, POE has become a convenient and quick way to write multitasking network applications.
POE supports graphical toolkits such as Tk and Gtk. It is the only Perl programming framework that does this. It also supports Curses, HTTP, and other user interfaces. POE programs can present multiple user interfaces at once.
About the Contents
Most of the material I will be using will be based on the
About the talk
This tutorial is aimed at giving a basic understanding the workings of POE, trying to get the audience to understand how to use POE and to show them some simple programs (or POEgrams). The main obstacle in understanding POE is right at the beginning; it introduces many terms, concepts and technology that might take some time to wrap your ahead around. This tutorials aims to be your guiding light in this process. Once these basics are covered, we can go into the appicatins of POE and teach the audience how to write POEgrams themselves.
by Alejandro Juárez Robles and Gunnar Wolf Iszaevich ; 60' talk
As Perl grows more popular, it also becomes more capable. What started out as a modest reporting language can now be found doing practically everything - And practically everything nowadays is network-related. Be it simple CGIs, mod_perl modules, SOAP services, daemons of all sorts, tailor-made protocols... Everything can be easily coded with Perl. However, power comes at a high price. Many people unfortunately write highly insecure software - This can backfire on themselves or on any other member of the Perl community, as we often share our code. In our talk, we present some examples on what to do, what NOT to do, and how to correctly do it when doing programming. This guidelines should be applied also to non-network-oriented scripts, as they are general enough.
by Richard Jelinek ; 60' talk
I'm currently writing on my dissertation in the field of AI. I also happen to build up a company called PetaMem, that is supposed to commercially "exploit" some of the AI-scientific achievements.
One core product we're building are IAAs - intelligent autonomous avatars. Systems that are able to classify, translate, recognize natural language texts. These systems are - of course - implemented in Perl.
I would like to do some presentation/demonstration of these systems on YAPC. This should be a 45 to 60min talk and pretty fit your "Perl and Science" theme.
by Greg McCarroll ; 30' talk
This talk is about the simulation and visualisation of geometrical objects under their own acceleration in 3D space. It will achieve the visualisation of them via the MesaGL library.
The maths involved will be very simple and there will probably be a crude collision detection model.
by Jos Boumans ; 45' talk
CPANPLUS is a new and flexible method of perl module management and installation, using the Comprehensive Perl Archive Network.
CPANPLUS is a new module. It was born in September of 2001, after that year's YAPC::EU in response to general unhappiness about CPAN.pm. It aims to be a rewrite, and in time a replacement of the current CPAN.pm, but in a completely OO model, adding features unknown to the current CPAN.pm, such as module uninstall, multiple shells and so on. Not in the least, it aims to fix various bugs of CPAN.pm as well as being very modular in its build setup, thus allowing many plug-ins. For example, with a plug-in to the RT bug tracking system, CPANPLUS could send in automatic bug reporting in case a module failed to install.
About the talk
I have given the 90 minute talk about CPANPLUS to Amsterdam.pm and it was very well received. However, it also went into the technical depths of the module and reviewed the history of development, as well as covered the basic knowledge required to develop new applications using CPANPLUS. Although this is very useful information, it's perhaps better suited for a BOF session. In short, I could range the talk from 25 minutes, covering just the bases for the average user, to 90 minutes, covering development, guts, interfaces, features, bugs, direction and so on of the module.
Some more information about the module can be found on the project's homepage at: <http://cpanplus.sourceforge.net>
Depending on how much time I am given, the following topics would be discussed:
When perl is not quite fast enough - or /sacrificing (?:style|maintainability) on the altar of speed/
by Nicholas Clark ; 40' talk
There are times when your perl script just isn't fast enough, and the "obvious" solutions (find a better algorithm; use Inline; rewrite it in another language; etc) are either impractical or politically unacceptable. This talk will describe how to find ways to re-write your perl code to go significantly faster, trading style and maintainability for speed. Serious speed gains are possible, even for already well designed code. Examples will include how I made ext/Encode/bin/enc2xs in the perl 5.8 distribution take significantly less time to deliver the same output.
This would be a talk mostly about the work behind some of the terse comments in enc2xs such as:
by Paul Johnson ; 60' talk
by Hendrik Van Belleghem ; 60' talk
I have NO idea yet.
basic knowledge of modules
Writing source filters
Dissecting existing source filters
A Word of Caution
I'm not entirely certain I'll be able to attend YAPC::Eu 2.00.2. Several factors can alter my plans (one of these factors being exam results)
by Leon Brocard ; 45' talk
The Comprehensive Perl Archive Network is the canonical source for Perl modules. The modules separated into various namespaces. One recent addition is the Acme:: namespace, intended for use for usefulness-challenged but entertainment-advantaged modules. This talk will tour the modules in this increasingly-popular namespace and show that even the most initially-useless module can be a great inspiration. Meep meep!
by Wolfgang Laun ; 60' talk
ELEKTRA is the brand name of ALCATEL Austria's electronic railway interlocking system, installed on more than 70 sites in three countries. Laboratory testing of the system requires the simulation of all the peripheral equipment (points, signals, etc.) and their controlling interfaces. This simulation and the related test environment has been implemented as a set of Perl programs.
Perl 5 was chosen as the implementation language because its promise of portability, the rich set of built-in functions and library packages and the existence of Perl/Tk. Object orientedness was expected to support code reuse.
The simulation of peripheral equipment is done by EPS/Simulation, a server program. Instead of interfacing with the actual hardware, the ELEKTRA equipment controllers set up socket connections as clients to the simulation server. Output commands are passed on to the server which distributes them to the appropriate object, where an evaluation method computes the reactions. Status changes are returned as input to the equipment controller.
EPS/Interface is another client for EPS/Simulation. It provides a graphical user interface showing a canvas map of all trackside equipment and featuring popup windows for all elements. User interactions permit changes in the states of the elements (e.g. occupying or freeing a track section).
Running regression tests is supported by EPS/Batch, an extensible command interpreter. During ELEKTRA system tests it operates as a client to EPS/Simulation, using commands for changing element states. Another connection links this program with an ELEKTRA node for sending simulated operator inputs on mouse and keyboard and for retrieving screen dumps of the ELEKTRA monitors documenting the system status.
Yet another client for EPS/Simulation is EPS/Move, a simple program capable of simulating train movements from a start signal, following tracks and points until a signal showing halt is encountered.
EPS/Track Editor is an offline tool for drawing canvas maps for EPS/Interface.
Simulating a Relay Interlocking System
Since ELEKTRA is also capable of providing a user interface for relay-based interlocking systems the simulation provided by EPS/Simulation also had to include one set of elements corresponding to those that can be found in a relay interlocking system. The simulation of this element group includes interlocking features such as train and shunting route selection and cancellation, and various operations on points, signals and other equipment.
Some Interesting Features
Element (i.e. object) states are communicated via sockets. This is done by sending key-value pairs as plain text, with the receiver eval-ing them into its copy of the object.
The considerable number of objects that need to be shown in the GUI of EPS/Interface is managed by describing each object by its set of output and input lines and external states. The corresponding popup-window is generated from this description.
EPS/Batch uses dynamic loading of code implementing various additional sets of commands. Thus, EPS/Batch is not only used for ELEKTRA system tests but also for MMI and equipment controller subsystem tests. Extension can be written according to a simple command pattern, using a simple interface provided by the core of EPS/Batch.
Development began with 5.005_03 on Solaris which turned out to be very stable and reliable. Later on, 5.6.1 was used (Solaris an Linux), again without any problems. Using Perl/Tk was difficult at times, mostly because of the lack of examples for the more advanced features.
by Karen Pauley ; 30' talk
Psychometric tests are now a standard part of many recruitment processes. Traditionally these are hand-scored by qualified psychologists, at great expense and with a long delay between taking the test and getting the results. We were approached by a company who wanted to produce these tests on-line, so that companies could get instant results from candidates who sit the test.
They wanted a system that they could use to set up different tests for different clients, enter the scoring rules (which could be different for different types of tests), and have the system produce reports on each candidate who sits the test. This was to be web-based and browser-independent, and the 'look and feel' of each test should be easily customisable to look like each client's own web site.
And, of course, it had to be completed in several weeks at minimal cost.
In this case study we'll look at:
by Claes Jacobsson ; 45' talk
45 min - 1 hour tutorial on creating graphics with Perl.
As we all know, an image says more than thousand words. This is a presentation on what imaging modules are available for the perl programmer who wishes to visualize information or manipulate images. An indepth guide to the perl module 'Imager', covering basic drawing operations to more advanced functionallity such as text and filters.
by Thomas Klausner ; 60' talk
I'd like to give an introduction to the dark art of Obfuscation. Topics covererd will be:
by Gabor Szabo ; 60' talk
I would like to present some complexity computation along the development (and hopefully improvement) of Array::Unique and Games::NIM. Does complexity matter ?
The latter module will be presented as a platform for developing some NIM like games and computing winning strategies for finite games in general.
by Jozsef Dojcsak ; 30' talk
After the successful deployment of a perl based SMS system, we faced a new challenge: how difficult it is to implement and deploy an MMS Server, which is implemented entirely in Perl. The presentation will emphasize on the system architecture, the underlaying OO module library and the technical issues, like handling Unicode charsets, parsing binary WAP messages, etc.
Don't forget to bring your MMS phone....
by Casey West ; 45' talk
Introduction to Net::DNS will give an overview of the most useful features of Net::DNS. This module does more than DNS lookups and I'll be giving you a taste of it's crunchy goodness.
by Douglas White ; 30' talk
The National Software Reference Library (NSRL) is designed to collect software from various sources and incorporate file profiles computed from this software into a Reference Data Set (RDS) of information. The RDS can be used by law enforcement, government, and industry organizations to review files on a computer by matching file profiles in the RDS. This will help alleviate much of the effort involved in determining which files are important as evidence on computers or file systems that have been seized as part of criminal investigations . The harvesting of file profiles from software is accomplished by multiple computers in a loose parallel computing environment. The implementation of the environment is discussed, with attention to performance improvements using reverse regular expressions known as "sexeger".
 Fisher, G. (2001) NIST ITL Bulletin, " Computer Forensics Guidance ".
by software team SANFACE ; 30' talk
We'd like to present to Munich our perl tool txt2pdf .
The problem: the tool is shareware (obviously we distribute the perl code) and we know the perl community doesn't like shareware.
by Casey West ; 45' talk
If your boss has ever asked you to build a web site, you've no doubt been subjected to this declaration: "You need to build the best web site ever built by anyone in the history of web site building, with all the whiz bangs, doo dads and gizmos that make marketing drones drool, with half the fat. Plus, you should have been done yesterday; this will come up in your performance review." Oh sure, they never come right out and use those words, but that's what they mean.
I'm going to show you how simple it is to put together such a production quickly and easily. Using a combination of the Template Toolkit and mod_perl - through the Apache::Template module - you have the reusability factor of Server Side Includes (SSI) and the dynamic nature of mod_perl and CGI. Apache::Template is very easy to configure, and through the techniques I'll demonstrate, you'll be creating web sites right quick. With any luck, you'll be able to cut your caffiene intake as well as make your boss happy.
by Arthur Bergman ; 60' talk
Perl 5.8 threading, introduction, shared variables, how it applies to mod_perl 2.0, ends with a how to make current modules threadsafe/threadfriendly and XS (XS last so people can drop off if they don't want it) Roughly around 45-60 minutes
by R. Geoffrey Avery ; 30' talk
Modules are the basic building block for structured programming in Perl. In this session you will learn how to use the ExtUtils::ModuleMaker facility to automatically construct all the base files needed by a well-engineered module, and tools and strategies for converting existing code into well-engineered modules to promote code reuse and maintainability.
by Stéphane Payrard ; 75' talk
Nemo is TeXmacs with Perl. Nem, Niki, Nirc and Nile will be the Nemo tool thanks to TeXmacs and Perl.
TeXmacs is an interactive documentation tool with a power comparable to TeX. It does not include or use any TeX code except for font handling, neither emacs code; but, in addition to a menu-driven interface, it supports keyboard accelerators in a way comparable to emacs but somehow different too because TeXmacs has a more complex and (currently) specialized purpose.
TeXmacs is already used to write complex articles and books with complex maths, TOCs, indexes, footnotes... The current main hindrance is more sociological than technical, as editors prefer to receive Word or TeX documents.
TeXmacs is GPL, available on Unices with X-windows system. It is written in C++, currently uses Guile as an extension language and its own widget library. I have near completed a shallow port using Qtapplication event loop that will be quickly followed by a shallow Perl embedding including a Qt adaptator for POE. Watch CPAN and look for mQT and POE::Kernel::mQt within a week! After that, a complete port to Qt will be done to facilitate port toward non unix-like-systems. The Perl interpreter will eventually have more access to the TeXmacs internal structures.
The Nemo project will eventually culminate in a year or two in Nile (Nemo Interactive Literate Environment) with dynamic syntax hiliting that will support languages like per6 with an unlimited number of Unicode operators. More, Nile opens to these languages the full expressivness of mathematical notation (indices, exponent, matrices...). Think of Nile as literate IDE.
I will present TeXmacs as seen by users, will move to how to a quick review of TeXmacss internal and file format, then will explain how to extend TeXmacs using Perl. Finally I will expose the basic rudiments behind the upcoming parsing/deparsing engine behind Nile, the upcoming interactive literate environment. Steps toward Nile will be Nem (concurrent edtions over the net), Niki (a wiki), Nirc (a TeXmacs client that supports Math Notations).
I expect my presentation to be about an hour. It will be in (non native) English. Depending on my progress in the mean time, the presentation may better fit in 1 hour 30
Material needed (I don't have it): a laptop connected to the net with a recent version of linux, a recent TeXmacs and a recent g++ compiler. A source perl distro too. :)
TeXmacs will be his own presentation tool.
by Jouke Visser ; tutorial
by Mark Fowler ; 45' talk
This talk covers various techniques for extending the Template Toolkit. It starts with a quick overview of how the Template Toolkit works, moving onto discussion of developing Plugins, Filters, and adding Virtual Methods. It moves onto discuss using views effectively to render existing objects and datastuctures and concludes showing this technique applied to XML.
by Damian Conway ; 2h talk
See Damian's online abstract .
by Michael G Schwern ; 45' talk
Refactoring is the process of gradually making code better without changing its functionality. It can be used to redesign existing systems, or to cleanup and modernize old ones. Herein will be related Tales Of Refactoring In Perl. How to go about it, what works, what doesn't and some particularly nasty pitfalls to avoid. We'll see how reworking an existing code base can often succeed where a grand rewrite will fail.
We'll look at:
by James A Duncan ; 60' talk
OpenFrame is an application framework, designed to make programming in a structured manner easier for application developers. This talk presents some of the basic concepts of OpenFrame, the thought that went into creating those concepts, and a couple of the mechanisms that resulted.
Additionally some of the future directions (as of a week ago) that OpenFrame is going in will be presented.
by James A Duncan ; 30' talk
Pixie is an object oriented database that 'just works'. It uses a clever mechanism to serialize the data and a simple query language to view it. More interesting perhaps is the technique that is used to capture the objects. Of particular interest perhaps is that it results in a depth-first non-recursive event based mechanism to discover any object in any perl data structure.
For more information perhaps, my use.Perl journal <http://use.perl.org/~james/journal/> has an entry containing a early prototype of Pixie.
by Johan Van den Brande ; 75' talk
I'm the author of the GSM::SMS modules for Perl ( http://www.tektonica.com/projects/gsmsms ). I would like to ask you if there is a change for me to speak at the conference?
The outline of the talk ( 1 to 1.5 hours) would introduce the concepts of SMS, Short Message Service. Discuss how to send and receive SMS messages using a GSM modem ( or a GSM phone ) with Perl. Also a short introduction to SMS gateways would be included. The talk would touch the following packages: Device::SerialPort, LWP and GSM::SMS.
by Damian Conway; 2h talk
See Damian's online abstract .
by Allison Randal ; 60' talk
This talk explores the influence the theory of tagmemics has had on the development of Perl. (I'm giving this talk on Thursday here at TPC)
by Hugo van der Sanden; 60' talk
What can we expect from perl 5.10?
by Axel Beckert ; 45' talk
This talk shows how to build large scale websites or web applications with Embperl. It discusses the concept of separation of application logic, display logic, content and layout and how this separation can be achieved with Embperl 2.0.
First, the talk shows the importance of application objects and how they are created, how to break up whole pages into components and how Embperl's inheritance model is working and what are its benefits.
It then continues with a short introduction into Embperl's processing pipeline, which allows the creation of component output within multiple transformations, giving the possibility to include nearly every data source (like e.g. POD, XML, RSS, SSI, CGI scripts or plain text) and rendering techniques (like e.g. JSP, ASP or PHP).
The talk will comprise embedding Perl into HTML, using static XML, generating XML dynamically, doing XSLT transformations and using XSL-FO to generate HTML, XML, PDF, text and various other output formats.
It will also touch other features being necessary to build large scale websites like session handling, caching, database access and internationalization.
This talk will be similar to Gerald Richter's Embperl talk given at OSCON 2002. (See <http://conferences.oreillynet.com/cs/os2002/view/e_sess/2716> )
by Dan Sugalski ; 45' talk
Parrot is a virtual machine used to efficiently execute bytecode for interpreted languages. This talk will be a gentle introduction to Parrot, and will cover Parrot basics, and will lead into programming Parrot assembler.
by Hugo van der Sanden ; 60' talk
I'll be giving a talk shortly before YAPC on 'perl 5.10', and I'd like to give essentially the same talk in Munich. I'm aiming to prepare a talk about one hour long.
by Mark Overmeer - MARKOV Solutions; 45' talk
In the last few years, e-mail developed from an application used by a relatively small scientific community into a basic means of communication for everyone. Companies have added e-mail as a new way to keep in touch with consumers, next to the traditional postal and telephone services. Friends post birthday invitations by e-mail, and the pictures of the last family meeting are broadcasted to everyone on them.
Creative new practices for e-mail include spam and spreading viruses. Jokes are not posted in plain text anymore, but preferably as PowerPoint presentations. Plain text is not nice at all: let's send HTML or -even better- full Word and PDF documents to everyone we know!
The concept of e-mail has changed, and with it the need to control that flow has increased. Filters which automatically remove received spam, virus checkers, and message content converters are more and more implemented. At the same time, mail folders grow rapidly in size. The number of messages to read daily explodes. How to cope with that?
The recently developed Mail::Box module is capable of handling various kinds of mail folders and replaces many older Perl modules (like MailTools) with components which are better suited for the current generation of messages. The module supports many advanced features which can help implementing the filters you need.
Some features of Mail::Box, Mail::Address, and MIME::Types will be discussed. A few small programs will be explained. Although Mail::Box is fully Object Oriented, only little OO is really needed to understand the examples.
by Jos Boumans ; 45' talk
About the Contents
Most of the material I will be using is based on the OO tutorials I wrote, which can be found at <http://japh.nu> I wrote these as a response to many questions on the email@example.com mailinglist. Every day, at least a few questions about OO programming would be asked and many of them would have been answered if the users had read Damian's book or Advanced Perl Programming. When people inquired why they hadn't done so, the majority answered that most concepts introduced in the afore mentioned books were over their head. They wanted a simple yet clear introduction to both the vocabulary and the concept of OO perl.
About the talk
This tutorial aims to be just that: an introduction to both the vocabulary and the concept. It requires only basic perl knowledge, and assumes no knowledge of other languages or OO programming in general. I will attempt to divide the talk into a few chapters, aimed at not only helping the audience understand both concept and vocabulary, but also teaching them how to apply this knowledge in their first attempts at their own modules. After attending this talk, both Damian's book as well as Advanced Perl Programming are recommended literature and should no longer be as elusive.
by Lucy McWilliam ; 7' lightning
I'm a bioinformatics research student who uses (admittedly, not very exciting) perl on a daily basis. Given the 'Science of Perl' theme, I thought it might be nice to give a simple overview of the (admittedly, quite funky) biology that perl helps my colleagues and I accomplish.
by Mark Overmeer ; 7' lightning
This is more a 'Damian-style' module, which adds laziness to object initiation. This module redefines AUTOLOAD, isa, can, etc.... it's tricky. This subject may just fit in a lightning-slot, but may be way over the head for many. At the other hand, 30 minutes is a bit too much time, I expect.
by Michael G Schwern ; 7' lightning
My experiences tearing through vmsperl while knowing nothing about VMS. How this helped fixup not just VMS but all non-Unix ports. And how this may result in the first release of Perl that won't have "known failures".
by James A Duncan ; 7' lightning
This talk comes standard with a wee bit of swearing. It can be censored however, but I'd rather do that on the basis of what the audience wants.
As workers in an industry we keep trying to find a metaphor for what we do, rather than just explaining it. We tend to be proud of our achievements inside our technical community. However outside of that tight knit group we tend to clam up when it comes to explaining what we do and how we do it to our friends, families, and random people we meet while drinking. The metaphor approach is not working. No one outside of a software background seems to have any understanding of why its hard to change something six months after the development starts primarily because they don't understand what it is we do. There are very simple measures we can and should take as software professionals (more or less) that attack this problem before it gets any more uncontrollable.
by Arthur Bergman ; 7' lightning
Quick examples of a typing system using types.pm
by Gabor Szabo ; 7' lightning
I'd like to present the perltraining.org directory to the Perl Trainers gathering at YAPC::Europe::2002.
Probably the best would be if this can be the part of a Perl Training BOF if there is going to be one. If not then a 5-7 minute long lightening talk would be great.
by Andreas J. König ; 7' lightning
The WAIT module is the unsung hero among all full text search engines for perl programmers. It is a rewrite of the famous freeWAIS-sf program in perl and XS.
From freeWAIS-sf it inherits bullet-proof algorithms from academic information retrieval background. From perl it gets backing in portability and sophistication. XS contributes speed in time-critical areas.
<http://www.oreilly.de/catalog/search.html> is a proof-of-concept mod_perl application that is featuring WAIT and XSLT. When you try it out, you will notice:
Other features you might not see on first sight, are full Unicode support (because this servlet is written for perl 5.8.0) and incremental indexing and de-indexing (we haven't used this feature at O'Reilly because we have no control over the changes in the documents, but you can watch the incremental indexing feature at <http://netlexikon.akademie.de/query> ).
A working snapshot of the full source code of the O'Reilly servlet is included in the CVS version of WAIT at sourceforge.net. We would wish that the publication of the servlet encourages you to hack your own search engine.
We (Ulrich Pfeifer and me) would like to thank O'Reilly Germany for giving us the opportunity to experiment with 5.8.0 and WAIT in a real-world scenario.
by Martin Brech; 7' lightning
The use of the camel image in association with the Perl language is a trademark of O'Reilly & Associates, Inc. Used with permission.