[pgh-pm] [Fwd: [dcpm] Perl tutorials at U Penn on Monday April 14 and April 21]

[Chris Winters]

Just in case anyone's in Philly...

-------- Original Message --------
Subject: [dcpm] Perl tutorials at U Penn on Monday April 14 and April 21
Date: Wed, 09 Apr 2003 21:54:45 -0400
From: mjd-list-dcpm at plover.com
Reply-To: dc at lists.pm.org
To: dc at lists.pm.org


This year I'll be doing three tutorials at the big Perl conference in
San Diego.  One is entirely new, and one is substantially
refurbished. I need to practice these before I go to San Diego, so
I'll be giving the tutorials in Philadelphia this month.

If you were to attend in San Diego, you would pay between $250 and
$345 for each tutorial.  But you can come to my practice session for
less than that.  I am asking for a (voluntary) donation of $10.  If
this covers my expenses for the class, I will contribute 30% of the
surplus to the EFF, a non-profit legal action group devoted to
defending digital rights.  (See http://www.eff.org/ for details.)

The two tutorials are titled:

         Tricks of the Wizards (2003 Edition)

         Making Programs Faster:
           Benchmarking, Profiling, and Performance Tuning


                                  WHEN


Tricks of the Wizards: Monday, 14 April 2003.
Making Programs Faster: Monday, 21 April 2003.

Both tutorials will start around 6PM and will last until about 9:30,
including a 30-minute break in the middle.

                                  WHAT

Here are the brochure descriptions:

TRICKS OF THE WIZARDS
*********************

         This class will explore Perl's most unusual features.  We'll
         look at some of the standard modules written by famous wizards
         like Tom Christiansen, Damian Conway, and Larry Wall, and
         learn what they're for and how they work.

         First we'll investigate Perl's remarkable 'glob' feature.
         We'll see many uses of globs, including the 'Exporter' module,
         which everyone uses but hardly anyone understands.  We'll
         discuss how to accomplish the same globby magic in Perl 6,
         which won't have globs.

         After this we'll look at unusual uses of Perl's 'tie'
         function, which scoops the brain out of an ordinary Perl
         array, hash, or filehandle, replacing it with your own
         concoction.  We'll make hashes with case-insensitive keys,
         arrays that mirror the contents of a file, and filehandles
         that suppress annoying output.

         Then we'll learn about AUTOLOAD, Perl's function of last
         resort.  We'll see a tremendously useful application: How to
         generate the accessor methods of a class *without* writing
         pages of repetitive code.  We'll see how Larry's 'Shell'
         module uses AUTOLOAD to emulate the Unix shell inside Perl
         scripts, and how Damian Conway's 'NEXT' module uses AUTOLOAD
         for method redispatch.

         Section 4 discusses Perl's new "source filter" feature.  This
         magic allows you to write Perl programs in any language, and
         translate them to Perl at the last moment.  We'll add a
         'switch' statement to Perl and we'll see how Perl 5 can
         emulate the variable syntax of Perl 6.

         The class will finish with ten very small but useful
         enchantments that take thirty seconds each.


MAKING PROGRAMS FASTER
**********************

         Almost every application must be made to run faster; some
         sooner, some later. Performance tuning of applications has
         long been a dark art, understood by few and riddled with
         terrible pitfalls. Stories abound of optimization projects
         that took weeks but yielded a pathetic 2% decrease in total
         run time.  Don't let this happen to you.

         The class begins with a brief introduction to the basic
         concepts of performance tuning. We'll then take an extensive
         look at modules for benchmarking and profiling, including
         several common blunders that even experts commit when
         benchmarking. We'll finish with a discussion of a few of the
         most important optimizations.

         Throughout, the class will emphasize both high- and low-level
         approaches to performance tuning: when to tune and when to try
         something different, and if tuning is necessary, how to focus
         your efforts where they will do the most good. We'll learn how
         to rationally evaluate programming situations and when to try
         alternative approaches.

         Short introduction: Basic concepts and tools; CPU, wallclock,
           system, and user times; I/O, CPU, and memory-bound programs;
           'time,' 'times,' 'Time::HiRes'.

         Performance tuning tools:
           Benchmarking:
             The cardinal rule of benchmarking (look at the big picture)
             Benchmark.pm
             Common errors of commission and interpretation
               The incredible shrinking test case
               When two optimizations look like zero
               The pseudo-hash disaster
             Case studies: Speeding up regexes, numerical calculation.
          Profiling:
             The 90-10 rule
             The Wrong Question
             The Innermost Loop
             Speeding up the case that never occurs
             Standard profiling modules
             Case study: high-turnaround XML processing.

         Common optimizations;
           When common optimizations don't work.


                                WHARNING

These are NOT introductory classes.  Both tutorials are
intermediate-level Perl classes.  Basic familiarity with Perl is
assumed for both; "Tricks of the Wizards" requires some familiarity
with packages, objects, modules, and references.

A notice was circulated recently that asked "Interested in learning
perl?"  Anyone who is "interested in learning Perl" is probably not
going to get a lot out of these classes.


                                 WHERE

The classes will be held in Heilmeier Hall (room 100, formerly Alumni
Hall) in the Towne Building at the University of Pennsylvania.  The
Towne Building is located at 220 South 33rd Street in Philadelphia.

For directions to the University, see

         http://www.facilities.upenn.edu/visitUs/

A map is available at:

         http://www.facilities.upenn.edu/mapsBldgs/view_map.php3?id=158


                                  WHO

According the the conference web site:

         Mark-Jason Dominus has been programming in Perl since 1992. He
         is the author of the 'Memoize', 'Text::Template', and
         'Tie::File' modules, the author of the 'perlreftut' man page,
         and an occasional contributor to the Perl core.  He won the
         2001 Larry Wall award for Practical Utility.

For more details about me, see

         http://perl.plover.com/yak/aboutme.html

For more details about classes I teach, see

         http://perl.plover.com/yak/


                                  WHOW

We have plenty of space this year, but please make an advance
reservation so that I know how many handouts to bring.  To reserve,
please send an email message to:

         mjd-tpc-practice-tricks+ at plover.com
         mjd-tpc-practice-performance+ at plover.com

or both.

Please do circulate this notice to any people or mailing lists that
you think might want to see it.

My grateful thanks go to Helen Anderson and Chip Buchholtz of the
University of Pennsylvania School of Engineering and Applied Science
for providing the space and AV equipment for these classes.

                                 WHUH?

Questions?  Send me email.




-- 
Chris Winters (chris at cwinters.com)
Building enterprise-capable snack solutions since 1988.