[roch-pm] [ANNOUNCE] Damian Conway & brian d foy in Chicago, IL, 19-23 Aug
(fwd)
Brian Mathis
bmathis at directedge.com
Thu May 30 08:33:16 CDT 2002
---------- Forwarded message ----------
Date: Thu, 30 May 2002 06:05:55 UT
From: lembark at wrkhors.com
To: Brian Mathis <bmathis at directedge.com>
Subject: [ANNOUNCE] Damian Conway & brian d foy in Chicago, IL, 19-23 Aug
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.
-------------- next part --------------
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.
-------------- next part --------------
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.
-------------- next part --------------
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.
-------------- next part --------------
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 Rochester-pm
mailing list