John Kern <jkern3@NOSPAM.visteon.com> writes:

> Simon Wright wrote:

> > Depends what you mean by _support_, but I've been working on an
> > open-source code generator, currently front-ended by Rose (basic
> > edition). http://www.pushface.org/coldframe/

> I wonder if you could briefly describe what advantages your program
> has over the Ada95 code generation already offered by Rational?

[Sorry for delay in reply, I've been on holiday]

Well, it's open source :-) However, to quote from
http://www.pushface.org/coldframe/architecture.html,

  It's fundamental to the idea of ColdFrame that you don't need to
  build a design model by decorating your clean, beautiful analysis
  model with all sorts of support clutter (lists, queues etc). The
  software architect decides how analysis models are to be translated
  into code, and a mechanical process (applied either by a programmer
  or by a program) applies the rules.

  Examples of commercial products which take this approach are
  Software through Pictures from Aonix and ARTiSAN Software's
  Real-Time Modeler[1].

  It's important that the tool lets the architect adopt different
  strategies depending on circumstances. For example, ColdFrame
  generates quite different code for a class with the stereotype
  �singleton�.

  This need makes it very advantageous to have a complete programming
  environment available while scripting the output. Predetermined
  substitution variables aren't likely to fill the bill.

and from http://www.pushface.org/coldframe/use-cases.html#SEC1

  When code is automatically generated from a model (in the present
  case, a UML model), there are two approaches:

  Use a Design Model 

       A design model is derived from an analysis model by adding
       support classes to map the analysis model to the Software
       Architecture (see section Software Architecture). An example
       would be a container for all the instances of a given class. A
       tool which uses this approach is Rational Rose.

  Use an Analysis model

       An analysis model contains classes and relationships that are
       part of the subject matter of the analyzed subsystem. Code
       which supports the execution of the model (for example,
       navigation from an instance of one class through an association
       to find the set of corresponding instances of another class) is
       automatically generated. Tools which use this approach include
       Software through Pictures from Aonix, Rhapsody from I-Logix,
       iUML from Kennedy-Carter, BridgePoint from Project Technology,
       and the present project.

The Rose alternative to programmability is that extraordinarily
complicated Code Generation Properties dialog box, which gives each of
your developers complete freedom to generate code in different ways
(but only within the limits of variability allowed by the vendor
(bad)).


[1] Actually I'm not so sure about the ARTiSAN product, which I
understand is now available for Ada but haven't seen.