By
Download on the App Store

episodes

  • How to Join the Perl Community
    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.
    30 min
  • Assuring Quality
    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.
    26 min
  • Nothing Can Possibly Go Wrong
    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).
    47 min
  • Perl Program Repair Shop
    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."
    41 min
  • So You Want to Write About Perl!
    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).
    53 min
  • An Overview of Perl 5.10
    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.
    25 min
  • Parsers, Perl 6 Rules, and the Parrot Grammar Engine
    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).
    26 min
  • UR - Universal Relational Software Framework
    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.
    37 min
  • Introducing the Solstice Framework
    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.
    42 min
  • Jifty
    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.
    36 min