Munich {
    Registration
    Accommodation
    Transport
    Venue {
       Pictures & Mpg
       Timetable
       Events
       Lunch
       Speakers {
          Abstracts
          Dinner
       }
    }
 }
 Sponsors {
    Sponsoring
    Sponsor_sheet
 }
 Links {
    Mailing_lists
    Organisers
    Program Committee
    Credits
    YAPC USA 
 }

YAPC::Europe::2002 ->Abstracts;

Some of the proceedings and slides can be found online:

Evolutionary Computation in Perl  

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:

1. Evolutionary computation at large
2. Designing an EC framework in Perl: pros and cons
3. Specifying EC problems in XML, reading them in Perl
4. Distributing EC problems using SOAP.

I would go for a 1.5 hour presentation, if there's no time slot available for tutorials.

Advanced Testing 

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.

• Testing services and daemons
• Testing network applications
• Testing web applications with WWW::Automate
• Testing GUI applications
• Testing databases
• Testing failure
• Test coverage analysis with Devel::Cover
• Common cross-platform testing pitfalls

Practical Web Programming 

Developing GUI applications with Gtk.pm 

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)

Creepy featurism 

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.

How to Integrate Anything with SOAP 

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:

• Reusing Perl code in non-Perl applications
• Extending the capabilities of non-Perl applications to do things that are only sensible to write in Perl
• Why I love .NET and BizTalk server even though Microsoft are still bad and evil.
• The choice of Perl SOAP Toolkit and a comparison with some non-Perl ones.
• Why you might want to use the 'Document Style' rather than RPC and how you might do this.
• Why you might not want to look into the inside of SOAP::Lite if you value your sanity :)
• What are "Web Services" and how are they different to SOAP?
• The reason to choose between the various transport mechanisms.

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.

Perl 5.8 At Last 

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.

Smoking Bleadperl 

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''.

Introduction

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 theircomputer(s)and who are willing to spend a few minutes in installing the package which then will run a number of tests on the most recent bleadperl situation in as many configurations as possible.

Talk

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.

Perl 6 Prospective 

See Damian's online abstract .

On Topic and Topicalizers in Perl 6 

This talk describes the new behaviour of $_ in Perl 6. (it was well received at YAPC::NA)

POE for Beginners 

About POE

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 CPAN-module Acme::POE::Knee , which is a simple module I wrote a while ago to demonstrate how the POE kernel dispatches events. It shows the behaviour of the 'state machine' illustrated as a pony race (or POEny, as we like to call it). The second main source of material will come from the likes of the POE article, which appeared on perl.com a while ago. The actual article can be found here: <http://www.perl.com/pub/a/2001/01/poe.html> . The article describes how to build a server daemon that understands TCP using POE.

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.

Writing secure applications - Tips, pitfalls and guidelines 

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.

Intelligent Autonomous Avatars 

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.

The simulation and visualisation of objects in 3D space 

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.

CPANPLUS - Beyond CPAN.pm 

CPANPLUS is a new and flexible method of perl module management and installation, using the Comprehensive Perl Archive Network.

About CPANPLUS

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>

Contents

Depending on how much time I am given, the following topics would be discussed:

• Reason for creating CPANPLUS (25)
• Improvements of CPANPLUS vs CPAN.pm (25)
• A short description of the developers of CPANPLUS (45+)
• The user-interface 'Shell' (25)
• Sample usage of 'Shell' (25)
• The script-interface 'Backend' (25+)
• Sample code utilizing 'Backend' (25+)
• The developer-interface 'Internals' (60+)
• The merits of the various interfaces (45+)
• The current developments (45+)
• The future developments (60+)
• How to contribute to the project (60+)

When perl is not quite fast enough  - or /sacrificing (?:style|maintainability) on the altar of speed/

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:

Testing and Code Coverage 

• What is code coverage?
  • A way of ensuring your tests are actually testing your code
• Where does code coverage fit into testing?
  • Module testing
  • Other important ways of testing
  • Black box testing
  • Regression testing
  • Coverage is white box testing
• How do people normally write tests?
  • Not at all
  • Very quickly
  • At the end - call major functions
  • At the beginning - call major functions
  • When a bug comes in
• Coverage metrics
  • Statement
  • Branch
  • Condition
  • Path
  • Time (!)
  • Pod
  • Others
• How coverage can help find errors
  • Statement
    • Untested functions
    • Untaken conditionals and loops
  • Branch
    • Missing elses
  • Condition
    • Boolean expressions
  • Path
    • Variables in outer scope
  • Time
    • Algorithm problems
  • Pod
    • Insufficient documentation
• How to use code coverage
  • Write tests to test for untested constructs
  • May show up design or implementation errors
• When to use code coverage
  • From the beginning, regularly
  • make cover
• How to use code coverage - a suggestion
  • Decide you need a new method
  • Write tests and documentation
  • Write the method
  • Check the coverage
  • Add tests or refine the design until coverage is satisfactory
  • This may or may not be more fun than your current method, depending on
  • your current method, your definition of fun and how much you enjoy bug
  • reports and maintenance.
• What coverage metrics to use
  • How well do you want to test?
  • What percentages to aim for
• What code coverage won't do (yet)
  • Data coverage
  • Regular expressions
• Devel::Coverage
  • Uses debugger
  • Statement only
  • Slow
  • Stable (Jarkko's sig)
• Devel::Cover
  • Uses opcodes
  • Many criteria
  • Fast
  • Unfinished
  • Current problems
  • Parrot / Perl 6
  • Database format
• How to use Devel::Cover
  • How problems are flagged
  • Real world examples
  • What's going on behind the scenes
• C code
  • Perl core
  • XS modules
  • Devel::Cover backend to gcov
• Comments / Questions / Abuse

Source Filters in Perl 

Duration

I have NO idea yet.

Level

intermediate

Requirements

basic knowledge of modules

Introduction

1. What are source filters?
2. Why do people write them?
3. Why do people use them?
4. How do you use them?

Writing source filters

1. How do you write them?
2. Writing source filters with Filter
   1. How to use Filter
   2. The Example
   3. Autofiltering
3. Filter::Simple
   1. How to use Filter::Simple
   2. The Example
   3. Autofiltering
4. Modules from scratch
   1. The Example
   2. Autofiltering

Dissecting existing source filters

1. Acme::Bleach
2. Acme::Buffy
3. Filter::CBC

The End

1. Conclusion
2. Links
3. Thanks

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)

The Acme::* Modules 

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!

ELEKTRA Peripheral Simulation: A Perl Application Program 

Introduction

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.

Why Perl?

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 Programs

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.

Conclusion

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.

Case Study: Psychometric Testing with Perl 

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:

• What to do when you have to build a system in a hurry.
• Making the CPAN work for you.
• Reducing your workload by 90% by using Class::DBI and Template::Toolkit as 2 legs of an MVC system.
• Reducing the remainder of your workload by another 80% by building a simple, generic, extensible, reusable web-based-forms controller.
• Managing customer expectations with eXtreme Programming.
• How a heavyweight Configuration Management System (Aegis) can help speed the development process up dramatically.
• How to build a $20,000 web site in an afternoon.

Imaging with Perl (Imager) 

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.

The Dark Art of Obfuscation 

I'd like to give an introduction to the dark art of Obfuscation. Topics covererd will be:

• Why obfuscate?

• japhs

• Obfuscation Techniques (chr/ord/pack, special variables, encrypted data, encrypted code, generating code, algorithm-obfuscation, self-reading code...)

• Tools to (de-)obfuscate (Deparse, ACME::EyeDrops ..)

• famous obfuscations

How to write slow algorithms quickly in Perl ? 

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.

OpenMMS - Telco Industrie meets perl  - Implementing an MMS server in perl

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....

Introduction to Net::DNS 

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.

Distributed Hashing With Sexeger Improvements 

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 [1]. 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".

[1] Fisher, G. (2001) NIST ITL Bulletin, " Computer Forensics Guidance ".

Can a company use Perl to develop (and sell) commercial tools?  - The SANFACE Software experience

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.

Creating Dynamic Sites in a Flash with the Template Toolkit 

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.

Threads 

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

ModuleMaker 

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.

Nemo: TeXmacs the Scientific Editor with Perl 

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).

Tentative TOC

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.

wxPerl - another portable GUI for Perl 

See the wxPerl tutorial on perl.com.

Extending the Template Toolkit 

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.

Quantum::Superpositions 

See Damian's online abstract .

Tales Of Refactoring: Remaking MakeMaker and Other Horrors 

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:

• The modernization of Test::Harness and MakeMaker.
• The relationship between testing, documentation and refactoring.
• Untangling messy code.
• Some social aspects of refactoring.
• The refactoring tools available in Perl.
• Lots and lots of my mistakes and experiences.

OpenFrame Application Server 

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.

Pixie 

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.

Send and Receive SMS messages using a GSM modem 

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.

Extreme Perl  - The Horror That Is SelfGOL

See Damian's online abstract .

Tagmemics  - An Introduction to Linguistics for Perl Developers

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)

Perl 5.10 

What can we expect from perl 5.10?

How to Build Large Scale Websites/Web Applications With Embperl 2.0 

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> )

Inside Parrot 

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.

Perl 5.10 

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.

E-Mail Processing with Perl 

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.

Introduction to OO Programming  - There's a method to this madness

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 beginners@perl.org 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.

Sex, flies and microarrays 

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.

Object::Realize::Later 

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.

Bull In A China Shop, Canary In A Coal Mine 

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".

We're not Building a F******g House! 

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.

Typed Perl 

Quick examples of a typing system using types.pm

Introducing Perltraining.org 

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.

WAIT@oreilly.de 

<http://www.oreilly.de/catalog/search.html> - <http://sourceforge.net/projects/wait/>

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:

• It's hard to find a query that tells you "No hits".

  Only two-letter searches may fail. Anything else that doesn't match a word in the dictionary is handed over to a second-level search engine through similarly written words.

• Even if there is no hit, you still get a helpful answer

  Queries that fit no document are turned into digram-searches through the dictionary of all possible words.

• Results are sorted well

  Watch the indicator of the relevance ranking for every hit, even for multiword searches.

• Not all words of a multiword search must be in the dictionary

  Any of the words in a multiword search may be a miss in the dictionary and yet the answers make sense. The reason for that is that search terms are generally ORed together (unlike google).

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> ).

Source code

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.

Thanks

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.

Lessons from a failed Perl-XS project 

• attempting to interface the Lotus Notes C API to Perl
• still an interesting thing to do as poor Notes Admins are still lost without a good scripting language, not to mention data import/export headaches with Notes databases
• Lotus Notes is definitely more a Win32 thing even on the server side
• Lotus Notes on Win32 needs dealing with threads
• right decision for the Perl-XS interface: steal the design of the interface from existing LotusScript class design
• wrong ansatz: tried to construct the objects on the C level for speed reasons

lessons learned:

• for such large APIs (600+ functions and numerous structs) always start with SWIG to get at the Perl level ASAP
• Perl, XS and Win32 has been a really explosive mixture for me and ... booom ... left me shattered in pieces