Class Outline: Zope Component Architecture and zc.buildout

   The Zope Component Architecture

     - Introduction - Why and why not to care about components:

       This part of the presentation will give a theoretical
       background to help people understand when and when not to use a
       component architecture.

       - Composition versus inheritance

       - Framework interoperability

       - Plug-in frameworks

       - Scale: doing the simplest things that can possibly work, 
         but knowing when to use more powerful technologies.

     - Zope Component Architecture

       In this part, I'll present the main features of the component
       architecture.  For each, I'll discuss the motivation, describe
       the relevant APIs from the component architecture, and provide
       examples.  I'll show how the ideas are applied in an ad-hoc
       fashion by Python standard library modules. I'll also describe
       some alternatives from other frameworks.

       - Interfaces

       - Utilities -- a simple plug-in registry

       - Adapters -- gluing different frameworks together

       - Events & Subscribers -- adding rules and extending behavior

     - Advanced topic: registration management issues

     - Summary

       In the summary we'll look back over the component architecture
       from the point of view of scale.  In light of the desire to do
       the simplest thing that can possibly work, we'll discuss when
       should you use either the technology or ideas from the
       component architecture.

   Break

   Introduction to zc.buildout

     - Why zc.buildout?

       - System assembly

         - why not make or scons?

       - Python application assembly with eggs

         - Support for developers

         - Assembling applications versus installing packages

         - Why not easy_install?

     - A Python Egg Primer

       Here I'll provide an introduction to using eggs from the point
       of view of a the lazy programmer.  I'll omit setuptools arcana
       and focus on the core concepts that make eggs so useful.

       - Eggs  

         They can sound complicated, but they are actually pretty
         simple.

       - easy_install and setuptools

       - Some egg-related jargon

         - distributions

         - source and binary distributions

         - eggs and develop eggs

         - requirements

         - index- and link-servers

       - entry points and script generation

     - Quick buildout introduction

       - A buildout.cfg file

       - Parts

       - Recipes

       - Special recipes for supporting Python application development

     - Buildout examples

       - Using buildout to try out new packages

       - Using buildout to create a development environment

       - Installing egg-based scripts for personal use

       - System assembly

     - A lazy programmer's introduction to creating eggs

       - Develop eggs, a minimal starting point

       - Adding data needed for distribution

       - Creating distribution files

     - Extending buildout with new recipes

       - The recipe API

       - A sample recipe

       - Part dependencies

     - Advanced topics

       - Sharing an egg repository across projects

       - Offline mode

       - Multiple deployment environments (dev/stage/prod) and
         multiple machines.

       - Using buildout with system-packaging tools (e.g. RPM).