History for HomePage

??changed:
-
!TransWarp has been replaced by PEAK

 Please see "PEAK - The Python Enterprise Application Kit":http://peak.telecommunity.com/ for more information.

This Wiki Is Mostly Obsolete

 ...but it still contains some moderately useful historical information.  Over time, it will be replaced with content at the new "!TransWarp Central":http://telecommunity.com/TransWarp/ website.  Please consider any information there to be more current and correct than anything here.  Thanks.

Wiki Starting Points
 
 * !TransWarp itself:

   - VisionStatement

   - "Mailing Lists":http://www.eby-sarna.com/mailman/listinfo

   - "CVS Repository":http://cvs.eby-sarna.com/TransWarp/
 
   - TransWarpFAQ

   - PackageLayout

   - "Installation and Download Instructions":http://www.zope.org/Members/pje/TransWarp/

   - IPC 9 Talk Slides, in "HTML":http://telecommunity.com/TW/IPC9Talk.htm or "!PowerPoint":http://telecommunity.com/TW/IPC9Talk.ppt

 * Aspect-Oriented Programming:

   - IntroToAOP - What is this AOP stuff, anyway, and why would I use it?

   - AOPTutorial - (Under Construction) Getting your hands dirty with !TransWarp's AOP library

 * Generative Programming and CASE:

   - ServicesElementsAndFeatures

 See also:

 - RecentChanges

 - ZWikiLinks

What is !TransWarp?

 !TransWarp is a general purpose Aspect-Oriented Programming, Generative Programming, and CASE toolkit for Python.  Its goals are to make developing applications as simple as 1-2-3:

  1. Draw UML diagrams in the XMI-compatible tool of your choice.

  2. Write domain-specific logic, as needed.

  3. Plug in off-the-shelf (but customizable) "horizontal frameworks" such as UI, data storage, testing code, security management, etc.

 !TransWarp is the likely successor to ZPatterns for Zope 3, and has a wide variety of applications for Python programming in general.  See the VisionStatement for more information on the planned direction of the software.

Aspect-Oriented Programming

 Central to !TransWarp is the ability to transform UML models into "structural aspects" which may be then "woven" with other "aspects" (such as domain logic, storage management, and user interface) to create applications.  Each of the "aspects", however, is reusable and interchangeable with other aspects.  Aspects are specified simply, using Python classes and nested classes.  Weaving aspects together is as simple as adding them, e.g. 'MyApplicationClass = (myDomainLogicAspect + structuralAspect + someGUIAspect + !ZopeSecurityAspect)()'.

 If you've ever wanted to do AOP in Python, !TransWarp is the toolkit for you!  You'll probably want to jump straight into the AOPTutorial.  But if you're not familiar with AOP and its benefits, you might want to check out the IntroToAOP first.  Benefits of AOP include:

  * Enhanced re-use -- When you seperate the problem-domain abstractions from your implementation details, both parts become more reusable

  * Enhanced modularization and localization of concerns -- code is easier to read, understand, and maintain, because code that deals with a particular area of concern is grouped together as a unit, even if it affects a large number of classes.

  * Enhanced flexibility -- The ability to create and "weave in" entirely new aspects to accomplish different results.  For example, a testing aspect that replaces database accesses with data read from and written to test files.


Generative Programming and CASE

 Beyond AOP, !TransWarp also provides Generative Programming tools, by letting you programmatically create aspects.  This is not done by generating text from templates, but rather by assembling "FeatureDef" objects that specify in an abstract way such notions as attributes, relationships, and so on.  Implementation of these features is deferred until aspect-weaving time, which means that what an "attribute" or "relationship" is, is actually defined by what aspects you add together.  So if you add a GUI aspect and a database aspect to a generated aspect, the resulting class family will have "attribute" objects that know how to display themselves in a GUI *and* store themselves in a database.  And which classes have which attributes will have been determined by the UML model used to generate the structural aspect.

 This approach leaves conventional text-based code generation approaches in the dust, while eliminating the need for tricky "round trip engineering" parsers and the like.  With !TransWarp, you write your domain logic as a seperate aspect which is then added to a generated aspect.  You never have to modify the generated aspect directly in order to change something - and you can't, anyway.  The generated aspect is just a blueprint for assembling features - and you have total control over what the classes used to implement those features.

 !TransWarp gives the CASE concept a new lease-on-life, giving you power beyond that of the most expensive CASE tools' code generators, while needing only the most inexpensive (or free) UML drawing tools to create your designs.