Fw: [ANNOUNCE] Damian Conway & brian d foy in Chicago, IL, 19-23 Aug

Tim Chambers japh at cos.agilent.com
Thu May 30 16:01:14 CDT 2002


Date: Thu, 30 May 2002 06:04:19 UT
Subject: [ANNOUNCE] Damian Conway & brian d foy in Chicago, IL, 19-23 Aug
From: lembark at wrkhors.com

Aside: helps if I add the attachments...

This is going out to the North American PM group Tsars. I'd appreciate
it if you could forward this to the local PM's -- or anyone else
who might be interested.

Damaian Conway and brian d foy will be teaching in Chicago, IL
during the week of 19-23 Aug, 2002. Damian will be offering
Data Munging with Perl, Advanced OO Perl, and Practical Parsing
with Perl; brian d foy will cover an introduction to mod_perl
with a pre-class session for anyone wanting help getting mod_perl
and apache running on their own machine.

The course notes for everything are attached.

Data Munging, OO Perl, and Learning mod_perl are all two day
classes; Practical Parsing is one day (See the schedule below).

Pricing for all of the classes is US$375/day with a 10%
discount for payment by 15-July or 3+ people paying on the
same invoice. Payments can be made by check or Purchase
Order; PO's will be presented for payment Mon, 19-Aug so
that the checks are here by the time Damian heads out of
town.

The $375/day covers attendance, course materials (several
hundred pages of it for most classes), various caffeine
sources, and finger food at the breaks.

The classes will be taught in Chicago's loop. The exact
location will depend on the response. We are currently
hoping to fill the the United Stadium now that the Bulls
season is over, but the Club Quarters downtown is the
most likely. In any case rooms will be available well in
advance.

Damian will also be giving a free talk on Extreme Perl Monday
night at the regular Chicago Perl Monger's meeting in the
Chicago Loop.


Schedule

Aug         Damian Conway               brian d foy


19  Mon     Data Munging (day 1)
20  Tue     Data Munging (day 2)        Installing mod_perl (evening)

21  Wed     Adv. OO Perl (day 1)        Learning mod_perl (day 1)
22  Thu     Adv. OO Perl (day 2)        Learning mod_perl (day 2)

23  Fri     Parsing (1 day only)



Please direct all inquiries to:

    mailto:lembark at wrkhors.com

    Steven Lembark
 Workhorse Computing
    2930 W. Palmer
    Chicago, IL 60647

    +1 800 762 1582 (voice)
    +1 305 832 0998 (efax)

thanx.




Title:
 Data Munging

Length:
 2 days (8 x 1.5-hour sessions)

Variant:
 Also available in a 1-day version

Presenter:
 Dr Damian Conway

 School of Computer Science and Software Engineering,
 Monash University,
 AUSTRALIA


Target audience:

        Novice perl programmers who are familiar with simple I/O and
        variables, and who want to a deeper insight into the techniques
        of Perl's "core business": extraction, manipulation, and
        reporting of data.


What attendees will learn:

        This tutorial will show you how to use a range of standard Perl
        features and numerous CPAN modules to read in, decipher, process,
        and reformat ASCII text data.

        You will learn:

                * how regular expressions work, and how to make them
                  work better for you,

                * how to balance nested brackets and match delimiters
                  without a complex regular expression,

                * how to recognize and process common text formats like
                  CSV and various tagged mark-up notations,

                * how to use grammar-based parsing to extract text with
                  complex structure,

                * how to preprocess archived text formats like (g)zip,
                  tar, uuencoding, MIME, and binary formats,

                * how to handle ambiguity and errors when processing
                  text,

                * how to convert your processed data back into readable
                  text, in either fixed or floating formats

                * how to extract, process, and generate simple natural
                  language data,


Tutorial outline:

        Part 1: Extraction

                * Getting at the data in the first place
                        - Un(g)zipping, untarring, uudecoding, demiming
                        - Compress::Zlib
                        - Archive::Tar
                        - Convert::UU
                        - MIME tools
   - Cheating with $/
                        - Handling file inclusions
                * Regular expressions
                        - How they work
                        - How they're used (m//, s///, split, grep)
                        - How to build them (easily)
                        - Common regexps and Regexp::Common
                * Some useful modules for decoding particular formats
                        - Text::CSV_XS for comma separated values
                        - Text::Balanced for delimiters, brackets, code, and
tags
                        - POD::Text and Pod::Tree for Plain Ol'
Documentation
                        - HTML::TreeBuilder for HTML
                        - unpack and vec for binary formats
                * Grammar-based parsing
                        - Theory and principles
                        - When it's needed (and when it's not)
                        - Introduction to the Parse::RecDescent module

        Part 2: Manipulation

                * Simple transformations
                        - m// and s/// revisited
                        - Text::Tabs
                        - Text::Autoformat
                * Fuzzy processing
                        - String::Approx and String::EditDistance
                        - Text::Soundex and Text::DoubleMetaphone
                * Grammar-based transformations
                * Natural language
                        * Lingua::EN::Inflect
                        * Lingua::EN::Infinitive
                        * Lingua::Conjugation

        Part 3: Generation

                * printf and sprintf
                * Fixed-format interpolation
                        - Perl formats
                        - Text::Wrap
                        - Text::Autoformat::form()
                * Free-form interpolation
                        - Interpolation
                        - Data::Locations
                        - Text::Template
                * Grammatical (recursive ascent) text generation

        Part 4: Putting it all together


Presenter biography:

        Damian Conway holds a Ph.D. in Computer Science and is a
        Research Fellow with the School of Computer Science and Software
        Engineering at Monash University, Melbourne, Australia.

        He is the author of numerous well-known modules including:
        Class::Contract, Text::Autoformat, Parse::RecDescent,
        Text::Balanced, Lingua::EN::Inflect, Class::Multimethods,
        Switch, Quantum::Superpositions, NEXT, Filter::Simple,
        Attribute::Handlers, Inline::Files, and Coy (all available from
        your local CPAN mirror).

        Damian was the winner of the 1998, 1999, and 2000 Larry Wall
        Awards for Practical Utility. He is a member of the technical
        committee for The Perl Conference, a columnist for The Perl
        Journal, and author of the book "Object Oriented Perl".

        In 2001 Damian received the first "YAS Perl Development
        Grant" and has spent the year working on projects for the
        betterment of Perl.




Title:
 Advanced Object-Oriented Perl

Length:
 2 days (8 x 1.5-hour sessions)

Variant:
 Also available in a 1-day version

Presenter:
 Dr Damian Conway

 School of Computer Science and Software Engineering,
 Monash University,
 AUSTRALIA


Target audience:

        Perl programmers who have a basic familiarity with simple
 hash-based OO Perl.


What attendees will learn:

        This tutorial will show you how to build on the basic
        object-oriented Perl techniques you already know and unlock
 more of the power of Perl's OO capabilities.

 You will learn:

                * how to use pseudo-hashes and the standard fields.pm
                  and base.pm modules;

  * how (and when) to bless arrays and scalars;

  * three different ways to implement data hiding for
    Perl objects (including the Tie::SecureHash module);

  * how Perl implements inheritance and polymorphism
    (and how you can change the rules of either);

  * how to simulate scalars, arrays, hashes, and typeglobs
    using ties;

  * the features (and traps) of operator overloading in Perl;

                * two easy ways to build complete classes
                  (semi-)automatically;

                * how to do design-by-contract programming in OO Perl
                  (using the Class::Contract module);

                * two ways to do generic programming in Perl;

                * how to use the Class::Classless module to build OO
                  programs without classes;

                * how to use multiple dispatch (an advanced form of
                  polymorphism ) to implement event-driven class
                  hierarchies for simulation and GUI applications.


Tutorial outline:

        * Review of Perl OO basics
                - packages, references, blessing
                - the three rules
        * Non-hash-based objects
                - arrays as objects
                - scalars as objects
        * Pseudo-hashes
                - what they are, how to use them as objects
                - the fields.pm  module
                - compile-time type checking
        * Automating class construction and DBC programming
                - Class::Struct
                - design-by-contract with Class::Contract
        * Inheritance
                - revision of concepts
                - how they work in Perl
                - @ISA, isa(), can(), SUPER
        * Polymorphism
                - When and how to use it
                - Variations on the theme
        * Encapsulation
                - the pros and cons of data hiding
                - encapsulation via closures
                - encapsulation via scalars
                - encapsulation via the Tie::SecureHash module
        * Inheritance revisited
                - tricks with inherited constructors and destructors
                - abstract methods
                - attribute collisions
                - inheritance and pseudohashes: the base.pm module
        * Ties
                - simulating implementing scalars, arrays, hashes, typeglobs
                - scalar example (a maximizing scalar)
                - hash example (a case-insensitive hash)
                - Examples: an optimizing scalar; an approximate hash
        * Operator overloading
                - overview and limitations of mechanism
                - overloading operations, conversions, and constants
                - problems with references
        * Grafting other OO models onto Perl
                - classless programming with Class::Classless
        * Generic programming
                - Why you don't need it in Perl
                - How to do it anyway
                - Examples: generic lists; generic trees
        * Multiple dispatch
                - when regular polymorphism isn't enough
                - cascaded polymorphism
                - table driven dispatch
                - Class::Multimethods


Presenter biography:

        Damian Conway holds a Ph.D. in Computer Science and is a
        Research Fellow with the School of Computer Science and Software
        Engineering at Monash University, Melbourne, Australia.

        He is the author of numerous well-known modules including:
        Class::Contract, Text::Autoformat, Parse::RecDescent,
        Text::Balanced, Lingua::EN::Inflect, Class::Multimethods,
        Switch, Quantum::Superpositions, NEXT, Filter::Simple,
        Attribute::Handlers, Inline::Files, and Coy (all available from
        your local CPAN mirror).

        Damian was the winner of the 1998, 1999, and 2000 Larry Wall
        Awards for Practical Utility. He is a member of the technical
        committee for The Perl Conference, a columnist for The Perl
        Journal, and author of the book "Object Oriented Perl".

        In 2001 Damian received the first "YAS Perl Development
        Grant" and has spent the year working on projects for the
        betterment of Perl.



Title:
 Practical Parsing with Parse::RecDescent

Length:
 1 day (4 x 1.5-hour sessions)

Variants:
 * Also available in a half-day version.

 * Often combined with "Advanced Parsing with Parse::RecDescent"

Presenter:
 Dr Damian Conway

 School of Computer Science and Software Engineering,
 Monash University,
 AUSTRALIA


Target audience:

        Perl programmers who are familiar with simple regular
        expressions and the use of modules. The techniques presented
        are not restricted to the applications mentioned below, and
        will be useful to anyone who needs to process structured input
        of any kind.


What attendees will learn:

        This tutorial will show you how to use a range of standard Perl
        features and several CPAN modules (in particular,
        Parse::RecDescent) to decipher and process a variety of complex
        data and command formats. It's a practical introduction to the
        techniques of grammar-based recursive-descent parsing.

 You will learn:

  * how to design and build parsers to process
    Apache configuration files and log data,

  * how to process structured expressions
    (e.g. search engine queries),

  * how to balance nested brackets and match
    delimiters without a regular expression,

  * how to fold, spindle and mutilate the
    comments in a C program,

  * how to allow embedded Perl code in your
    own data format or command language,

  * how convert natural language queries
    into SQL.

 There'll even be some useful stuff, like how to write a
 program that does stand-up comedy.


Tutorial outline:

 * A brief history of parsing
  - grammars, rules, recursive descent, etc.
 * Implementing parsers
  - top-down vs bottom-up approaches
 * Useful tools
  - Text::Balanced, Parse::Yapp, perl-byacc, Parse::RecDescent
 * Simple parsing
  - Parsing delimited text, parsing Perl subsets
 * Parsing data
  - Parsing Apache log files
  - optional subrules, list parsing
  - run-time parser generation
 <break>
 * Parsing input
  - The Text::Query modules
  - OO parsing
  - operator precedence, lists, look-ahead, rejections, etc.
 * Parsing code
  - parsing C and C++
  - stateful grammars
  - porting yacc grammars (including left-recursion)
  - self-extending parsers, committing rules, deferred actions
  - grammar precompilation
 * Parsing natural language
  - generating SQL queries for natural language input
  - synthetic stand-up via reciprocal parsers


Presenter biography:

        Damian Conway holds a Ph.D. in Computer Science and is a
        Research Fellow with the School of Computer Science and Software
        Engineering at Monash University, Melbourne, Australia.

        He is the author of numerous well-known modules including:
        Class::Contract, Text::Autoformat, Parse::RecDescent,
        Text::Balanced, Lingua::EN::Inflect, Class::Multimethods,
        Switch, Quantum::Superpositions, NEXT, Filter::Simple,
        Attribute::Handlers, Inline::Files, and Coy (all available from
        your local CPAN mirror).

        Damian was the winner of the 1998, 1999, and 2000 Larry Wall
        Awards for Practical Utility. He is a member of the technical
        committee for The Perl Conference, a columnist for The Perl
        Journal, and author of the book "Object Oriented Perl".

        In 2001 Damian received the first "YAS Perl Development
        Grant" and has spent the year working on projects for the
        betterment of Perl.



Learning mod_perl Course Outline

brian d foy <comdog at panix.com>


"Learning mod_perl" introduces the student to programming the
Apache API with Perl, including custom handlers, database
persistence, and post-request actions.  The students will be
able to try new things during class time and get immediate
feedback.

Students should be comfortable with object-oriented notation
in Perl to use the mod_perl API. Students should have
"Writing Apache Modules with Perl and C" by Lincoln Stein &
Doug MacEachern and the quick reference card that comes with
it.  Pre-class mod_perl installation help will be available
(details to follow).

===Day One===

 1. Setting up mod_perl
 - download
 - compile
 - install
 - test

 2. Migrating CGI scripts to Apache::Registry
  - quick and dirty speed ups

 3. The Apache request cycle
  - reading the request
  - interpreting the request
  - responding to the request
  - post request actions

 4. mod_perl handlers / Apache API
 - HTTP responses
 - accessing Apache data structures

 5. A URL translation handler
 - mapping URLs to resources
 - redirection

 6. Apache::DBI
 - database persistence

===Day Two===

 7. Content Handlers

 8. Stacked Handlers
 - headers and footers

 9. Access handlers

10. Authentication & Authorization handlers

11. Apache <Perl> sections
 - dynamic configuration

12. Post request phases
 - logging
 - post request processing

13. Miscellaneous topics
 - adding headers
 - passing notes
 - modules on CPAN


--




More information about the Pikes-peak-pm mailing list