YAPC::NA 2006 Presentations

How Perl::Critic Facilitates Code Best Practices

2006-11-13T15:16:48-06:00

Damian Conway's book "Perl Best Practices" has sparked a revolution in coding style among CPAN developers. Even before that book, many of those developers have wanted a way to judge whether their code conforms with a selection of best practices, hence modules like Perl::Tidy, B::Lint and even "use strict". Perl::Critic is a new module which strives to be a powerful and flexible tool to judge code against a user-selected array of "Policy" modules. Example policies include "CodeLayout::ProhibitHardTabs" and "TestingAndDebugging::RequireUseStrict". As of v0.15, we have implemented 70 policies, most of which derive from the 256 recommendations made by Conway. The API uses Module::Pluggable to enable third-parties to easily add more policies. A separate Test::Perl::Critic module makes it easy to confirm that your code is still in compliance with your established policies.

In this presentation, I will present Perl::Critic's features and demonstrate how you can start using it against your own code.

Shrinkwrap Software Development with Perl, PAR and SOAP

2006-11-13T15:17:50-06:00

Until recently, Perl has experienced a deployment problem getting applications in front of novice end users on platforms where Perl is not bundled, like Microsoft Windows. Now, the invention of the PAR file format and software infrastructure has made it easy to ship software with a bundled Perl interpreter. This saves the user the barrier step of installing Perl and worrying about which version of Perl may be previously installed.

In this presentation, I will demonstrate using PAR to create standalone, installable applications. I will discuss a few of the gotchas with the current implementation and their solutions. Furthermore, I will demonstrate a technique for using SOAP to let the Perl application be a backend engine to a frontend GUI written in Flash to allow for a highly modular system with a customizable look.

Get out of Technical Debt Now!

2006-11-13T15:17:36-06:00

Technical debt is stuff that gets left behind during a project: postponed documentation, unwritten tests, unfixed "TODO" notes throughout your code, and other workarounds you promise to do to "later". Like financial debt, unpaid technical debt accrues interest until you go bankrupt. Software projects start out fun, but often accumulate technical debt that drains project resources and makes developers miserable.

In this session, you'll learn:

How to work debt payments into projects, and show the value of this unseen work
How to tell good debt from bad
Where to start correcting a debt-ridden project
Automated tools for measuring and tracking your debt level
Habits to develop to keep debt to a minimum
How to keep the quest for perfection from causing paralysis

Lint

2006-11-13T15:17:49-06:00

Now that perl's Lint has support for plugins, I'd like to publicize that a bit and hopefully demystisize the process of writing lint detectors a bit.

Through the use of plugins for B::Lint and Perl::Critic, programmers can add warnings and other validation. I'll demonstrate how to add create new warnings to flag bad code. There'll be a breezy tour of the optree using B::Concise and how to match bad stuff.

Opening Ceremonies

2006-11-13T15:17:44-06:00

Josh McAdams welcomes everyone to YAPC::NA 2006.

PITA - Ridiculously Large Scale Testing

2006-11-17T06:49:26-06:00

The Perl testing modules, unified through TAP (the Test Anything Protocol) have been hugely successful.

But one large problem remains. Perl runs on 100+ platforms, and could be any of 20+ versions on each. This incredible diversity means that it has become a massive task to test even a single module on a reasonable set of platforms, a total Pain In The Arse (PITA). Even CPAN Testers is at its scaling limit, and starting to buckle under the strain.

This talk will unveil the Practical Image Testing Architecture (PITA), an automated mass-testing toolkit based on the concept of Completely Virtualised Testing. The goal, to test any variation of any software package, in any language, on any operating system, on any hardware. And then to test everything, everywhere.

Plagger - DIY RSS/Atom Aggregation

2006-11-17T17:29:58-06:00

Plagger (http://plagger.org/) is a pluggable RSS/Atom aggregation and syndication tool written in Perl. Plagger comes with various API hooks that external plugins can extend: Subscription, Aggregator, Custom Feed, Filter/Tag Content, Content Widget & Publish.

With these plugin hooks, you can do pretty neat stuff like "Get the updates from Bloglines, create rich-text email and forward them all to my Gmail inbox. But if the entry title contains 'YAPC' and bookmarked by more than 10 users on del.icio.us, send SMS to my cellphpone as well." They're all rule-based and can be done in a single config file update.

This talk covers how to setup Plagger, shows how powerful it is, and takes an example tour how to write your own plugin to mashup your feed content with cool new Web API technologies.

A Quick Introduction to Catalyst

2006-11-17T22:06:33-06:00

There has been a surge in "Web Application Frameworks" for Perl recently. We have Maypole, Catalyst, Jifty and the more traditional CGI::Application and CGI::Prototype. When sitting down to write a new application, it can be confusing and time consuming to go over all of these various frameworks looking at the samples and digesting lists of plugins and configuration options. In the interest of helping, I will demonstrate how to create an address book/PIM application using the Catalyst framework. This is simple enough to walk through the code in short period of time, but complicated enough to require the use of some more complicated example code than one often finds in tutorials.

7 Essential CGI::Application Plugins

2006-11-20T07:15:14-06:00

CGI::Application is a very flexible platform for web development. It can scale to handle both small one-off CGI scripts and complete web development frameworks. Its rich set of plugins allows developers to pick and choose featuresthat suit their needs.

This talk will give a quick tour of the 7 "most essential" CGI::Application plugins on CPAN:

CGI::Application::Plugin::ValidateRM
CGI::Application::Plugin::FillInForm
CGI::Application::Plugin::Session
CGI::Application::Plugin::AutoRunmode
CGI::Application::Plugin::Auth[enz]
CGI::Application::Dispatch
CGI::Application::Plugin::DevPopup

Building a Workflow Engine with POE and mod_perl

2006-11-20T23:11:11-06:00

Many times as a programmer you need to have a mechanism for dealing with long running events outside of your application. For instance, you may need to send 100,000 emails from a web app. Or you may need to poll a web service for something asynchronously. Or maybe you need an event to be kicked off at a secheduled time. Whatever your pleasure, we'll show you how to build a workflow system that will fit your needs, or at least get you started.

In this session we'll show you how to construct a feature-rich workflow engine using POE and mod_perl. When we're done it will be distributed, secure, scalable, and extensible; and best of all simple to use. We'll even provide you with working code when we're done so you can take it to home, work, or school and start using it right away.

Parrot - Evolution

2006-11-21T19:08:05-06:00

The Parrot virtual machine is best known as the primary target platform for Perl 6. But Parrot is much more than that. It is a general platform for almost any language, focussing on the special needs of dynamic languages - all of them, at the same time. Have you ever wanted to use Perl's CPAN archive from Python, or mix Perl 5 and Perl 6 code with Python modules, or call APL subroutines from Basic? This is the Parrot vision.

Chip Salzenberg, Architect of the Parrot virtual machine, will explain Parrot's architecture as it is and shall be. He will start by explaining Parrot's overall architecture, with a focus on recent evolution, such as cross-language support for namespaces and lexical variables, and future evolution on the horizon. He will point out how Parrot's intrepid developers have made Parrot better and stronger (we have the technology!) to meet the changing needs of today's language implementors. He will then set out the road map for Parrot's future.

Chip Salzenberg, Parrot Architect, will explain the architecture of Parrot, its recent evolution, its future, and how you can be part of that future.

Learn Perl Inside Out

2006-11-23T10:39:10-06:00

This workshop presents an alternative approach to learning Perl. Using the different aspects of the language - the one liner, the short script, the debugger, and the full-fledged application - it presents the information needed to write a Perl program combined with the practices necessary to write good programs.

This approach is still under development, and 45 minutes is not quite sufficient time to turn beginners into gurus, but it's a start .... and maybe this workshop will set you off on a path of good software engineering.

Automated Web Testing with Selenium

2006-11-23T10:41:40-06:00

Selenium is a cross-browser functional web testing framework. In this session, you'll learn how Selenium works, and how YOU can quickly get started testing your products with this excellent tool. We'll cover basic setup, the simple table driven mode, and then move on to driving Selenium from your perl test scripts.

Jifty

2006-11-24T21:00:24-06:00

Jifty is a new way to build web applications in Perl. With Jifty, you write less code, experience less pain and have a lot more fun, all while building great-looking applications. Jifty comes with a pony.

Parsers, Perl 6 Rules, and the Parrot Grammar Engine

2006-11-27T16:45:51-06:00

Perl 6 defines a new, powerful pattern-matching syntax known as "rule expressions", which is an extension and redesign of the regular expression syntax used in earlier versions of Perl. Notably, Perl 6 rule syntax has been explicitly designed to ease the task of creating language parsers.

The Parrot Grammar Engine (PGE) is the implementation of Perl 6 rules on top of Parrot, the virtual machine implementation underlying Perl 6. PGE not only implements Perl 6 rule syntax for top-down parsing, but it also integrates a bottom-up operator precedence parser for fast processing of common expressions. PGE also allows the arbitrary mixing of top-down, bottom-up, and custom parsing subroutines.

This talk will a detailed overview of Perl 6 rules, an introduction to using PGE, and how these can be quickly used to build custom parsers for a variety of languages. Numerous examples will be provided, including complete examples for simple languages and key excerpts from the Perl 6 parser (written using Perl 6 rules and PGE).

Parsers, Perl 6 Rules, and the Parrot Grammar Engine

2006-11-27T16:45:59-06:00

UR - Universal Relational Software Framework

2006-11-27T16:46:15-06:00

Recently, OO-RDBMS development frameworks have come into popular usage. Projects such as Class::DBI, Ruby on Rails, Rose::DB, and others provide a reusable solution to a common problem and save a lot of development effort. The UR suite re-frames the standard object-relational problem. It is resolved by giving the developer a powerful general class definition system, which can leverage knowledge about an underlying database, but does not require one to exist at all, managing non-persistent objects, and giving them a similar feature set. The net result for the developer is a software architecture which cleanly separates "business logic" from data management, while actually maximizing efficiency in the later instead of sacrificing it.

Often, many of the issues addressed in database design are in fact general class design problems. These solutions are even applicable when the classes in question will not have any external persistence. The UR suite allows developers to write more powerful classes by providing/enabling simple/easy entity identity, pointerless references, named relationships, "normalization", transactions, and meta-data. Even for applications that are not concerned with complex interactions with external data storage, managing object states and relationships is still key to good software architecture. For applications which do interact with external data sources, especially large relational databases, this management is critical for scalablilty, stability, and an agile development cycle.

The UR suite provides a base class for objects and provides classes for object/class meta-data. A class definition at the top of a Perl module enables a host of features, including optional, automatic RDBMS mapping and pluggable mapping to other persistence systems. The entire state of the application is managed by centrally tracking all changes to these objects, including creation, changes, and deletion. Synchronizing the changes made in an application with the objects' persistent storage is a single operation, independent of the implementation of the methods which effected that change in the object layer. The methods implementing an object class, in turn, are written in a context-independent way, uncluttered with data management. Classes provide a query interface, which is simple and powerful and which is orthogonal to the external database access which may or may not coincide with it. Object requests return data reflecting all of the unsaved application changes, which are transparently overlayed on the state of the external database(s).

Other features include: support for multi-table inheritance, a viewer base class for GUIs with full MVC support, a base class for logical object sets, application-level "undo", database data caching, structurally defined queries, dynamic class loading, and dynamic class generation. Because UR classes have extended definitions, it is possible to componentize these and many other features in efficient ways, besides mapping to external persistent storage.

This software is the core of an internally developed suite of applications used in a production environment at the Washington University Genome Sequencing Center. It provides access to over 10TB of data, in over 400 tables, with the largest table having over a billion rows. Three multi-server instances of Oracle deliver data to several hundred users and a several hundred node compute cluster.

Introducing the Solstice Framework

2006-11-27T16:46:25-06:00

The Solstice framework is a new MVC-oriented web development framework for mod_perl. Stressing scalability, embedability of application components, and a state-machine driven navigation model, Solstice provides some new approaches to creating Perl web applications. Developed by a group at the University of Washington, this system has allowed our four developers to create and maintain 8 campus-wide applications in two years. We intend to introduce the strengths and features of Solstice as well as do a quick demo of the development process.

An Overview of Perl 5.10

2006-11-29T22:08:39-06:00

Although
much attention has been focused on the development of Perl 6 over the
past year, development of Perl 5.10 has continued to move ahead.
Improvements in the regular expression engine, state variables, new
optional keywords, new operators, and new core modules are all new
things to look forward to. This session will give a high level overview
of what to expect with the next version of Perl 5.

So You Want to Write About Perl!

2006-11-30T23:44:25-06:00

Advocate
Perl by writing about it. Want to write a book about Perl? How about a
magazine article? How do you start and how do you manage the project?
Learn what you need to do and who you can help you from brian d foy,
columnist for The Perl Journal, publisher of The Perl Review, co-author
of Learning Perl and Intermediate Perl, and editor working with Onyx
Neon Press. You might just walk away from this session with a magazine
or book deal (but we don't make any promises).

Perl Program Repair Shop

2006-12-02T08:53:35-06:00

Most programs are overwritten. You can remove one-third to one-half of the code from the typical program while improving it in every other way: afterwards, it will be more readable, more efficient, more maintainable, and more modular. I will show you how to do this.

I'll take as a case study a program contributed by a programmer I don't know. We'll look at this example in detail and see how to improve it. The class focuses on 'red flags', which are obvious warning signs in the code that are plainly visible if you are looking for them. The techniques for improving code are easy, and require little thought or ingenuity. The motto of this class is "no clever tricks."

Nothing Can Possibly Go Wrong

2006-12-03T20:06:09-06:00

Everybody makes mistakes. Most of the time they can be fixed.

But
as you gain more experience and your projects get larger you enter the
dangerous and exotic world of large-scale design, with mistakes so
seductive you won't notice until years after you make them, and so
dangerous you can't risk fixing them even once you do.

In the
style of "You Can't Get There From Here", this talk will cover the
theoretical basis of some of the worst design mistakes, and take you on
a tour of some the biggest mistakes in the Perl world (including mine).

Assuring Quality

2006-12-05T20:45:53-06:00

This talk will be an introduction to Perl and CPAN testing. A quick guided tour taking in CPAN Testers, CPAN::YACSmoke and the CPAN testing statistics. Many companies need to have confidence in the quality of the software they use, particularly for third party software. Perl and CPAN testing help to promote Perl as a language of choice for providing the tools and environment by default.

How to Join the Perl Community

2006-12-13T20:10:49-06:00

Discovering
the Perl community: use.Perl, Perlmonks, IRC channels and servers, PM
groups, conferences, mailing lists and much more.

How it all works, how to fit in and how to get the most out of it all.