Ada and UML

Ada and UML

[raj]

Are there any UML tools around that support Ada ?

Re: Ada and UML

[David C. Hoos, Sr.]

Yes.  See UMLStudio at http://www.pragsoft.com

----- Original Message ----- 
From: "raj" <israelrt@optushome.com.au>
Newsgroups: comp.lang.ada
To: <comp.lang.ada@ada.eu.org>
Sent: July 11, 2001 12:25 AM
Subject: Ada and UML


> Are there any UML tools around that support Ada ?
> _______________________________________________
> comp.lang.ada mailing list
> comp.lang.ada@ada.eu.org
> http://ada.eu.org/mailman/listinfo/comp.lang.ada
> 

Re: Ada and UML

[Nick Williams]

raj wrote:

> Are there any UML tools around that support Ada ?


Rational Rose?

Cheers,

Nick.

Re: Ada and UML

[Ted Dennison]

In article <3B4F454D.7090200@acm.org>, Nick Williams says...
>
>raj wrote:
>
>> Are there any UML tools around that support Ada ?
>
>
>Rational Rose?

Telelogic TAU does too (I believe that's its name today).

---
T.E.D.    homepage   - http://www.telepath.com/dennison/Ted/TED.html
          home email - mailto:dennison@telepath.com

Re: Ada and UML

[Ken Garlington]

"Nick Williams" <nickw@acm.org> wrote in message
news:3B4F454D.7090200@acm.org...
: raj wrote:
:
: > Are there any UML tools around that support Ada ?
:
:
: Rational Rose?

I've heard rumors that Rose is quietly dropping Ada support?

Re: Ada and UML

[David Humphris]

Ted Dennison wrote
> >raj wrote:
> >
> >> Are there any UML tools around that support Ada ?
> >
> >
> >Rational Rose?
>
> Telelogic TAU does too (I believe that's its name today).

Aonix Software through Pictures (StP) is another to support Ada.

David Humphris
Aonix

Re: Ada and UML

[Simon Wright]

"Ken Garlington" <Ken.Garlington@computer.org> writes:

> "Nick Williams" <nickw@acm.org> wrote in message
> news:3B4F454D.7090200@acm.org...
> : raj wrote:
> :
> : > Are there any UML tools around that support Ada ?
> :
> :
> : Rational Rose?
> 
> I've heard rumors that Rose is quietly dropping Ada support?

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/

Re: Ada and UML

[John Kern]

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

Thanks

Simon Wright wrote:
> 
> "Ken Garlington" <Ken.Garlington@computer.org> writes:
> 
> > "Nick Williams" <nickw@acm.org> wrote in message
> > news:3B4F454D.7090200@acm.org...
> > : raj wrote:
> > :
> > : > Are there any UML tools around that support Ada ?
> > :
> > :
> > : Rational Rose?
> >
> > I've heard rumors that Rose is quietly dropping Ada support?
> 
> 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/

Re: Ada and UML

[Simon Wright]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 3021 bytes --]

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.

Ada and UML

[Paul Foster]

This posting is an extension to my previous posting :
Which OO is in ?? - 02/08/2000

I'd like some addition feedback regarding the use of UML on Ada
projects. For those that have used UML or are currently using UML
what have been the main problems? Which features of UML were
difficult if not impossible to implement and what UML subsets if
any were used to overcome these problems. I'm interested in feedback
for Ada83/95, full-blown and subsets (i.e. SPARK etc).

I'd like to know also what CASE tools are being used or are highly
rated.

Thanks to all respondents

Ada and UML

[Yannick Duchêne (Hibou57)]

Hi all,

A few days ago I get to have a look back at UML after a topic linking to  
an assessment stating graphical representations may help in  
design/application validation. Someone argued there is a lack of semantic  
with UML which dismiss its usage ; one topic I agree on, and after some  
reading to be sure, it seems indeed, there does not have a clearly defined  
semantic (*)

Another topic I oftenly read/heard about Ada and UML, is that it is too  
much oriented toward Java/C++, lacking as an example, handling of class  
and package orthogonality which is typical of Ada.

I've just discovered today it seems there is a kind of package visibility  
with UML expression of classes, which could match Ada concept of package:  
the visibility modifier “~” (the Tilde sign) which seems to means “Private  
at package level”. This should be sufficient for Ada. Nevertheless, there  
is nothing like “friend” or “protected” in Ada, as visibility is only  
handled by packages, so this visibility modifiers could just be  
disallowed. Do you think “~” is OK to express visibility handled by  
packages ?

For you who tried Ada and UML, did you noticed some others unsolvable  
matters to express Ada package in UML ?


(*) TBH, some peoples with interests in UML was aware of that, started  
some research on 1997 to draw a formal definition of the UML semantic, but  
any research in that area seemed to end on 2004, without any successful  
completion.

P.S. As the purpose of UML is clearly underspecification, may be the  
question of this thread does not really matters, as Ada is acting at  
implementation level.

Re: Ada and UML

[Yannick Duchêne (Hibou57)]

Le Tue, 31 Aug 2010 12:12:43 +0200, Yannick Duchêne (Hibou57)  
<yannick_duchene@yahoo.fr> a écrit:
> I've just discovered today it seems there is a kind of package  
> visibility with UML expression of classes, which could match Ada concept  
> of package: the visibility modifier “~” (the Tilde sign) which seems to  
> means “Private at package level”.
Also, the Extend relationship, could be used to express the Ada's child  
package relationship. But I am not sure this is valid UML to use the  
extend relation between two UML packages.

And what about the Composition relationship to express Ada's nested  
package relationship ?

-- 
“Dual licensing is the Perl's way to disinfect the GNU General Public  
Virus!” (anonymous)

Re: Ada and UML

[Yannick Duchêne (Hibou57)]

Le Tue, 31 Aug 2010 13:05:43 +0200, Yannick Duchêne (Hibou57)  
<yannick_duchene@yahoo.fr> a écrit:
> Also, the Extend relationship, could be used to express the Ada's child  
> package relationship. But I am not sure this is valid UML to use the  
> extend relation between two UML packages.
>
> And what about the Composition relationship to express Ada's nested  
> package relationship ?
To be more exact, UML Name Space should be used instead of UML Package, as  
Ada's package are both package and name-space at a time. Just have to hope  
that Name Space is interpreted as a special case of Package for everyones,  
otherwise Welcome Troubles.


-- 
“Dual licensing is the Perl's way to disinfect the GNU General Public  
Virus!” (anonymous)

Re: Ada and UML

[Matteo Bordin]

On Aug 31, 1:54 pm, Yannick Duchêne (Hibou57)
<yannick_duch...@yahoo.fr> wrote:
> Le Tue, 31 Aug 2010 13:05:43 +0200, Yannick Duchêne (Hibou57)  
> <yannick_duch...@yahoo.fr> a écrit:> Also, the Extend relationship, could be used to express the Ada's child  
> > package relationship. But I am not sure this is valid UML to use the  
> > extend relation between two UML packages.
>
> > And what about the Composition relationship to express Ada's nested  
> > package relationship ?
>
> To be more exact, UML Name Space should be used instead of UML Package, as  
> Ada's package are both package and name-space at a time. Just have to hope  
> that Name Space is interpreted as a special case of Package for everyones,  
> otherwise Welcome Troubles.

Hello Yannick,

UML semantics can be found in the UML metamodel superstructure at
http://www.omg.org/spec/UML/2.3/Superstructure/PDF/. As you said, UML
has no formally specified semantics - but this is also true for most
languages we use everyday (including Ada): I think it is really unfair
to keep bashing UML for not having a "formal semantics" while
basically all languages we use suffers of the same problem. The only
exceptions I am aware of are SPARK and some languages of the
synchronous family (Lustre, Esterel, ...).

Mapping Ada on UML means treating UML as graphical coding: in my
personal opinion this defeats the main purpose of UML - i.e. being a
platform-independent language. Ada profiles for UML surely exists, but
they make UML models implicitly not implementable on any other
programming language. I personally find language-specific UML profiles
a total non-sense. Having said that, it is unfortunate that an
incestuous relationship between UML and Java/C++ exists.

Anyway, one reasonable approach to represent Ada packages in
"standard" UML is to use a non extendible (isLeaf=true) UML singleton
class. Package-level variables, constants and non-primitive operations
can be mapped as static features (isStatic=True) of the singleton
class. Types declared within the Ada package can be represented as
nested non-singleton classes contained in the singleton class above (a
UML nested classifier is equivalent to Java/C++ nested classes). Ada
child packages can be mapped as nested, non-extensible singletons. As
you can see, this representation does not sound very natural from a
UML point-of-view, but covers the Ada semantics.

The extend relationships relates to UML types only: in UML, a Package
is not a type, so it cannot be extended in the UML sense. You also
cannot directly use UML NameSpace because it is an abstract semantic
element (an abstract metaclass).

Cheers,

Matteo

Re: Ada and UML

[Martin Krischik]

Am 31.08.2010, 12:12 Uhr, schrieb Yannick Duchêne (Hibou57)  
<yannick_duchene@yahoo.fr>:


> For you who tried Ada and UML, did you noticed some others unsolvable  
> matters to express Ada package in UML ?

Actually I always thought that Ada and UML fit better then most other  
languages and  UML- especially packages as most languages don't have  
packages. Not surprising as Rational Rose was written in Ada and Garry  
Booch used Ada in his early days. I think (but can't prove) that UML got  
it package concept from Ada in the first place.

Martin

-- 
Martin Krischik
mailto://krischik@users.sourceforge.net
https://sourceforge.net/users/krischik

Re: Ada and UML

[nobody]

Matteo Bordin wrote:
> Ada profiles for UML surely exists, but
> they make UML models implicitly not implementable on any other
> programming language. 

There are also platform independent profiles with semantics. I use one 
every day called xtUML. And translate the same models to both C++ and 
Ada-95. Spark is under development.

The xtUML profile is used for ANALYSIS models. We do NOT code C++ or Ada 
in UML. We do analysis. Then the translation into code is just something 
mechanical.

Re: Ada and UML

[Yannick Duchêne (Hibou57)]

Le Tue, 31 Aug 2010 18:34:11 +0200, Matteo Bordin  
<matteo.bordin@gmail.com> a écrit:
> Hello Yannick,
Hi Matteo :)


> UML semantics can be found in the UML metamodel superstructure at
> http://www.omg.org/spec/UML/2.3/Superstructure/PDF/. As you said, UML
> has no formally specified semantics - but this is also true for most
> languages we use everyday (including Ada): I think it is really unfair
> to keep bashing UML for not having a "formal semantics" while
> basically all languages we use suffers of the same problem.
I did not want to be unfair and I had this “be fair” requirement in mind.  
While I should not have used the “formal” qualifier, you are right (formal  
may means multiple things, just like semantic, safe, etc).

I have read some UML tutorial in the paste, and found it was always  
talking about syntax, and just a few about meaning. But as I am not a  
specialist in this domain, I wanted to be sure and seek for UML semantic  
docs. Among others, I found this one:
http://www.imamu.edu.sa/DContent/IT_Topics/UML%20Semantics%20FAQ.pdf
which confirm there is a lack of semantic. As an example: they state UML  
does not even tell anything about weither or not a message queued to a  
task will be always processed or not. Ada is not formally specified in the  
mathematical sense, but at least it answers such questions well.

TBH, see also a later comment below about UML and semantic.

> The only
> exceptions I am aware of are SPARK and some languages of the
> synchronous family (Lustre, Esterel, ...).
Thanks for other references ;) Will be worth reading I feel.

> Mapping Ada on UML means treating UML as graphical coding: in my
> personal opinion this defeats the main purpose of UML.
Fully agree. I said “the purpose of UML is clearly underspecification”.

> Ada profiles for UML surely exists, but
> they make UML models implicitly not implementable on any other
> programming language.
Good point.

> I personally find language-specific UML profiles
> a total non-sense. Having said that, it is unfortunate that an
> incestuous relationship between UML and Java/C++ exists.
I have never talk about UML profile ;) I talked about meaning of  
notational elements and attempted to express them in terms of Ada  
construct meaning. There is no worry about stating UML Name Space better  
match Ada's package than UML Package does. This is not an UML profile.  
Except may be for restriction like “only use the ~ visibility modifier”.  
But this could be as well a required UML subset to match some design  
criteria, just like there are Ada subsets (Ranvenscar, SPARK, and may be  
others).

Also note that an Ada profile and UML profile does not stands for the same  
thing: UML profile means possibly adding notational components to UML via  
prototypes, while Ada profile means strict subset of Ada, don't even think  
about adding anything. These are two opposite!

I was talking about UML subset. This should match both expectations, yours  
and mine. Subset may enforce clearer meaning (as an example, avoiding to  
have multiple notation to express the same thing), while not extended the  
notation, so that it is not tied to a particular language (I love your  
comment about it). I agree with the criteria (UML should not be tied to  
any design language).

> Anyway, one reasonable approach to represent Ada packages in
> "standard" UML is to use a non extendible (isLeaf=true) UML singleton
> class.
An UML class to represent a package ? Can you tell more ? What is the  
difference with the name-space choice ?

> Package-level variables, constants and non-primitive operations
> can be mapped as static features (isStatic=True) of the singleton
> class.
I have played a bit with a textual variant of UML which generates graphs  
via GraphViz ; this is called PlantUML. And actually it does not provide  
the attributes you mentioned.
http://plantuml.sourceforge.net/

> Types declared within the Ada package can be represented as
> nested non-singleton classes contained in the singleton class above (a
> UML nested classifier is equivalent to Java/C++ nested classes). Ada
> child packages can be mapped as nested, non-extensible singletons. As
> you can see, this representation does not sound very natural from a
> UML point-of-view, but covers the Ada semantics.
So all can be done with class and no need anymore for UML package ? Class  
can be static, leaf and so on. OK. I did not read UML Superstructure,  
because it is a very long document, and that is not handy to read such  
long document on a computer screen. I wish I will do later (I just get a  
quick overview so far).

> The extend relationships relates to UML types only: in UML, a Package
> is not a type, so it cannot be extended in the UML sense.
So the schemas I "draw" was wrong. I used the Extends relation on package.

> You also
> cannot directly use UML NameSpace because it is an abstract semantic
> element (an abstract metaclass).
>
> Cheers,
>
> Matteo
OK.

Above I said will lave a comment about UML and semantic. Here is: as UML  
is notation and notation + method, its semantic was likely to be less  
precise. I had a look at Merise too, because I do not trust arguments like  
“every body wants UML, no one ask for Merise which is dead” (I do not know  
about HOOD, so I have no way to talk bout it, due to lack of online  
documents). I did not care and and try to get an overview, and feel UML  
notation was more rich and Merise's method makes me think about the V  
cycle which is famous for its flaws. I though UML = richer notations, so  
better coverage, may be better suited for repetitive reification, which  
seems common, especially for people working alone (better suited in this  
context). Then about lack of semantic, I though: if used as an  
architecture and design outliner, implicit reference to a predefined  
implementation language may not be so bad after all. Wiether one use Ada  
or C, and provided this choice is done for good reason, and the choice is  
made a the very beginning, the one could always refer to task as an  
example, the way the target language handles this. After all, when one say  
“the app will need three concurrent task”, this one will then just say  
“Ada tasking model is like this, C way to handle task is like this”.  
Talking about task this way, is design talking, not implementation  
talking. If UML is design and architecture talking, may be its fuzzy  
semantic is not so much likely to cause trouble.

Note: the semantic matter arise a detailed level, less at the big picture  
level. This is important to note.

Although contradictory to the above, if ever a mathematically defined  
semantic of UML was ever there, this would still be welcome. But then,  
this would implies the process would not be the same as the one suggested  
above.

I was a bit long with this reply, let go for a summary: give UML the  
semantic of the target language (implies this choice is maid à-priori),  
use notation restrictions as much as needed (should be documented, which  
is OK, as UML seems to have provision for so called Preface).


-- 
“Dual licensing is the Perl's way to disinfect the GNU General Public  
Virus!” (anonymous)

Re: Ada and UML

[Yannick Duchêne (Hibou57)]

Le Wed, 01 Sep 2010 01:14:21 +0200, Yannick Duchêne (Hibou57)  
<yannick_duchene@yahoo.fr> a écrit:
> Above I said will lave a comment about UML and semantic. Here is: as UML  
> is notation and notation + method,

Forget a word, please read instead

    Above I said will laave a comment about UML and semantic. Here is: as  
UML
    is notation and Mereise is notation + method,

Re: Ada and UML

[Matteo Bordin]

>
> > UML semantics can be found in the UML metamodel superstructure at
> >http://www.omg.org/spec/UML/2.3/Superstructure/PDF/. As you said, UML
> > has no formally specified semantics - but this is also true for most
> > languages we use everyday (including Ada): I think it is really unfair
> > to keep bashing UML for not having a "formal semantics" while
> > basically all languages we use suffers of the same problem.
>
> I did not want to be unfair and I had this “be fair” requirement in mind.
> While I should not have used the “formal” qualifier, you are right (formal
> may means multiple things, just like semantic, safe, etc).
>
> I have read some UML tutorial in the paste, and found it was always
> talking about syntax, and just a few about meaning. But as I am not a
> specialist in this domain, I wanted to be sure and seek for UML semantic
> docs. Among others, I found this one:http://www.imamu.edu.sa/DContent/IT_Topics/UML%20Semantics%20FAQ.pdf
> which confirm there is a lack of semantic. As an example: they state UML
> does not even tell anything about weither or not a message queued to a
> task will be always processed or not. Ada is not formally specified in the
> mathematical sense, but at least it answers such questions well.

One of the goals of UML is to permits UML models to be implemented on
several run-time platforms: for this to be possible, either you create
a language which is the union of all possible computational models, or
you leave semantic variation points to permit model transformation
(code generators) to inject platform-specific semantics following a
precise pattern. UML chose the second option. The core idea is that,
by modeling your execution platform, you can "instruct" your code
generator to generate code with a fully specified semantics for a
precise target platform starting from an abstract model. This permits
to re-use the same model for different target platforms by just
changing code generator and platform model and to perform high-level
verifications without including "pollution" from the underlying run-
time.

> > I personally find language-specific UML profiles
> > a total non-sense. Having said that, it is unfortunate that an
> > incestuous relationship between UML and Java/C++ exists.
>
> I have never talk about UML profile ;) I talked about meaning of
> notational elements and attempted to express them in terms of Ada
> construct meaning. There is no worry about stating UML Name Space better
> match Ada's package than UML Package does. This is not an UML profile.
> Except may be for restriction like “only use the ~ visibility modifier”.
> But this could be as well a required UML subset to match some design
> criteria, just like there are Ada subsets (Ranvenscar, SPARK, and may be
> others).
>
> Also note that an Ada profile and UML profile does not stands for the same
> thing: UML profile means possibly adding notational components to UML via
> prototypes, while Ada profile means strict subset of Ada, don't even think
> about adding anything. These are two opposite!

UML profile can be purely constrictive. For example, a UML profile may
state that you cannot use Interfaces. This is expressed in OCL as
Interface.allInstances()->size() = 0. No need for stereotypes. From
this point of view, a UML Profile provides the same service as an Ada
profile. UML profile can also be used to define modeling standards
(mirroring the notion of coding standard).

> > Anyway, one reasonable approach to represent Ada packages in
> > "standard" UML is to use a non extendible (isLeaf=true) UML singleton
> > class.
>
> An UML class to represent a package ? Can you tell more ? What is the
> difference with the name-space choice ?

The problem is that Ada Packages can have non-primitive operations and
variables, but UML Packages can't. The only place where you can put an
operation in UML is inside some behavioural classifiers (Class,
Interface, DataType, ...). So, if you want to represent Ada packages
with non-primitive operations, the only option is to map the Ada
Package on a UML class. On the other side, if your Ada program is
fully object-oriented (only primitive operations), you can use UML
packages to map Ada packages and UML classes to map Ada tagged/record
types.

In UML a NameSpace is an abstract metaclass (a sort of abstract
grammar rule), which is extended by concrete metaclasses. BTW, UML
Class inherits from NameSpace: in UML a Class is a NameSpace.


> > Package-level variables, constants and non-primitive operations
> > can be mapped as static features (isStatic=True) of the singleton
> > class.
>
> I have played a bit with a textual variant of UML which generates graphs
> via GraphViz ; this is called PlantUML. And actually it does not provide
> the attributes you mentioned.http://plantuml.sourceforge.net/

They are part of the UML standard and can be found in true UML
implementations such as those on the Eclipse platform (http://
www.eclipse.org/modeling/mdt/?project=uml2tools, topcased.org,
papyrusuml.org).


> I was a bit long with this reply, let go for a summary: give UML the
> semantic of the target language (implies this choice is maid à-priori),
> use notation restrictions as much as needed (should be documented, which
> is OK, as UML seems to have provision for so called Preface).

I disagree ;-) This approach means using UML at the same abstraction
level of a traditioanl programming language. A desirable modeling
approach based on languages of the UML family is to separate what is
platform-independent from what is platform-specific to permit the re-
use of platform-independent models. Let's make an example about
tasking. You can have a platform-independent UML model where you
identify "unit of concurrency". And another, platform-specific UML
model where you describe the low-level implementation in terms of
(Ada, C, ARINC-653, ...) tasks. Then you allocate the platform-
independent UML model on the platform-specific one by binding elements
of the first model on elements of the second one. This way you can
reuse the platform-independent model on several different run-time
architectures by simply providing new platform-specific models and new
bindings. You may get more information on this approach by reading
tutorials on MARTE (omgmarte.org).

Re: Ada and UML

[sjw]

On Aug 31, 7:25 pm, "Martin Krischik" <krisc...@users.sourceforge.net>
wrote:
 
>          Not surprising as Rational Rose was written in Ada and Garry  
> Booch used Ada in his early days.

Grady

Re: Ada and UML

[Simon Wright]

Matteo Bordin <matteo.bordin@gmail.com> writes:

> The core idea is that, by modeling your execution platform, you can
> "instruct" your code generator to generate code with a fully specified
> semantics for a precise target platform starting from an abstract
> model. This permits to re-use the same model for different target
> platforms by just changing code generator and platform model and to
> perform high-level verifications without including "pollution" from
> the underlying run-time.

I was going to draft a reply but Matteo has said almost all that I would
have done. I'd add that

1 I wouldn't expect every possible UML construct to be translatable
  using this model. A given vendor/toolset might well specify
  limitations, presumably as a profile.

2 I wouldn't expect to be able to tweak the UML so as to generate any
  arbitrary target language (Ada) construct.

3 The converse of 3: I wouldn't expect to be able to represent any
  arbitrary target language (Ada) program in UML so as to be able to
  regenerate it.

Re: Ada and UML

[Simon Wright]

Simon Wright <simon@pushface.org> writes:

> 3 The converse of 3: I wouldn't expect to be able to represent any
>   arbitrary target language (Ada) program in UML so as to be able to
>   regenerate it.

3 The converse of *2*:

grr

Re: Ada and UML

[Yannick Duchêne (Hibou57)]

Le Tue, 31 Aug 2010 23:20:41 +0200, nobody <nobody@nowhere.com> a écrit:
> Then the translation into code is just something mechanical.

I do not really believe in automatic source generation from UML, as there  
may be multiple possibilities. Or else, may be these systems use something  
to tell “for This, use That”. Just think that in Ada, you may have for  
example at least, where polymorphism is required, two ways to do (when  
feasible, sometime only one will applies) : static (via generics) and  
dynamic (via tagged or interface) polymorphism. How can a system know it  
should use this or that ? This requires a human analysis, to say “well,  
this can be statically known, so let's use static polymorphism” or else  
the opposite (just an example).

Your point makes me think about the so called “Executable UML”.  
Unfortunately, I do not know anything about it. I am just pretty sure this  
cannot be automated.

If you wan to tell more... just do :)

-- 
“Dual licensing is the Perl's way to disinfect the GNU General Public  
Virus!” (anonymous)

Re: Ada and UML

[Yannick Duchêne (Hibou57)]

Le Tue, 31 Aug 2010 20:25:51 +0200, Martin Krischik  
<krischik@users.sourceforge.net> a écrit:
> Actually I always thought that Ada and UML fit better then most other  
> languages and  UML- especially packages as most languages don't have  
> packages. Not surprising as Rational Rose was written in Ada and Garry  
> Booch used Ada in his early days. I think (but can't prove) that UML got  
> it package concept from Ada in the first place.
>
> Martin
Funny point. it happens I had this question too in mind : “where does this  
UML package comes from, as I have never seen something like this if not  
with Ada”.

Funny to also note UML package does not exactly match Ada package. May be  
the inspiration came in two ways : Ada package and Ada orthogonality and  
they wanted to make package and name-space orthogonal ?

I did not knew Grady Booch used Ada. Did he wrote about it also ?


-- 
“Dual licensing is the Perl's way to disinfect the GNU General Public  
Virus!” (anonymous)

Re: Ada and UML

[Yannick Duchêne (Hibou57)]

Le Wed, 01 Sep 2010 10:20:30 +0200, Matteo Bordin  
<matteo.bordin@gmail.com> a écrit:
> One of the goals of UML is to permits UML models to be implemented on
> several run-time platforms: for this to be possible, either you create
> a language which is the union of all possible computational models,
Unreachable target

> or you leave semantic variation points to permit model transformation
> (code generators) to inject platform-specific semantics following a
> precise pattern.
Look like the question I asked in a prior post : how is the source  
generator driven ?

> UML chose the second option. The core idea is that,
> by modeling your execution platform, you can "instruct" your code
> generator to generate code with a fully specified semantics for a
> precise target platform starting from an abstract model. This permits
> to re-use the same model for different target platforms by just
> changing code generator and platform model and to perform high-level
> verifications without including "pollution" from the underlying run-
> time.
I have the same view or except in one point : I do expect abstraction, but  
I do not expect automatic generation. Instead of the latter, I expect  
abstract view and outlining, which in turn lead to some other questions to  
solve, different than the one of automatic generation (will not talk about  
it here).

> The problem is that Ada Packages can have non-primitive operations and
> variables, but UML Packages can't.
So indeed, this really to not match Ada package.

As it seems some of my words was not understand (I may indeed be  
ambiguous) : when I say this is not the same as Ada package, I do not say  
I expect UML to be another way to write Ada, ... no, I wanted to  
understand things using concept which are already known.

> In UML a NameSpace is an abstract metaclass (a sort of abstract
> grammar rule), which is extended by concrete metaclasses. BTW, UML
> Class inherits from NameSpace: in UML a Class is a NameSpace.
I am not sure I understand this. Will later look for a way to understand  
it.

> They are part of the UML standard and can be found in true UML
> implementations such as those on the Eclipse platform (http://
> www.eclipse.org/modeling/mdt/?project=uml2tools, topcased.org,
> papyrusuml.org).
I have tried this. The first two did not want to lauch, only Papyrus  
could. I will try with it (I already tried it in the past, but this is  
another story I will not talk about).

>> I was a bit long with this reply, let go for a summary: give UML the
>> semantic of the target language (implies this choice is maid à-priori),
>> use notation restrictions as much as needed (should be documented, which
>> is OK, as UML seems to have provision for so called Preface).
>
> I disagree ;-) This approach means using UML at the same abstraction
> level of a traditioanl programming language.
Right, this have to be more abstract. But some stuff requires an exact  
semantic to be interpreted, and this is kind of concrete thing which you  
will typical find with a concrete language like Ada is.

> A desirable modeling
> approach based on languages of the UML family is to separate what is
> platform-independent from what is platform-specific to permit the re-
> use of platform-independent models. Let's make an example about
> tasking. You can have a platform-independent UML model where you
> identify "unit of concurrency". And another, platform-specific UML
> model where you describe the low-level implementation in terms of
> (Ada, C, ARINC-653, ...) tasks.
And how do you link these various more detailed model to the one which  
seems to be a master abstract model ?

> You may get more information on this approach by reading
> tutorials on MARTE (omgmarte.org).
I had a overiew. It is said to target Real-Time, which is not my direct  
concern, while seems it can be useful for general purpose. Thanks for this  
link.


-- 
“Dual licensing is the Perl's way to disinfect the GNU General Public  
Virus!” (anonymous)

Re: Ada and UML

[Yannick Duchêne (Hibou57)]

Le Wed, 01 Sep 2010 20:44:09 +0200, Simon Wright <simon@pushface.org> a  
écrit:
> I was going to draft a reply but Matteo has said almost all that I would
> have done. I'd add that
>
> 1 I wouldn't expect every possible UML construct to be translatable
>   using this model. A given vendor/toolset might well specify
>   limitations, presumably as a profile.
>
> 2 I wouldn't expect to be able to tweak the UML so as to generate any
>   arbitrary target language (Ada) construct.
I did not expected this, nor me.

> 3 The converse of 2: I wouldn't expect to be able to represent any
>   arbitrary target language (Ada) program in UML so as to be able to
>   regenerate it.

What I expect, may be explained with concrete cases.

I feel for long source does not came with all value and sometime, the  
“clever idea” in something comes at an abstract level which not any more  
clearly visible in a source, even if the source implements this “clever  
idea”. Because the “clever idea” is made implicit and not expressed by the  
source whose target is to express concrete implementation. That is why  
even a well designed application source can be “unreadable”.

As an example, I have an FTP application written 5 years ago. Not so much  
big, 2_000 lines. But I have to rework it, and although there are comments  
and the design was clear at the time I wrote it, it seems impossible to be  
sure to clearly understand what I had in mind at the time. I have another  
web application, 70_000 lines, which is clear to me for the time, as I  
oftenly come back to it... but will this always be like this ? I am afraid  
if I ever switch to something else for a long time or want a later date to  
collaborate with any somebody, things gonna be wrong.

Structuration, god entity naming, etc, are nice things, but this is simply  
not enough.

And what if I ever want to re-implement these things in another language ?  
(one is C, the other is Pascal and JS) A direct translation to Ada (which  
I plan for the future) would surely turn into many errors every where.

I also had some other similar though about UI design.

This is these topics I have in mind. I am not seeking for another way to  
write Ada with something else than Ada.

May be we agree in some points and I did express it the good way.

As some ones says : you do not see the face on a printed image looking at  
the little colored dots the raster printer drawn on the paper. And this is  
sadly true even with tiny pictures (it is frightening to think something  
as simple a 2_000 lines application can become so much unclear... and what  
about bigger things...).

But while I feel this may help, I still have some doubt about the UML  
approach : what about things which are not design or architecture and  
which are rather algorithmic ? Is UML well suited to express algorithm in  
an abstract manner ? In that area, I had a recent look at (S)ML, but still  
do not have a clear though (there are state machines in UML, I known, but  
this is not enough, and an algorithm too may have multiple  
implementations, so a more abstract view than a particular implementation  
could be welcome too).

Still in this area, I also explored and tested other techniques, but I'm  
afraid I would become boring... (at least I have a better picture of the  
subject than the one I had, say, 3 years ago)

Have a nice day all



-- 
“Dual licensing is the Perl's way to disinfect the GNU General Public  
Virus!” (anonymous)

Re: Ada and UML

[J-P. Rosen]

Le 02/09/2010 02:22, Yannick Duchêne (Hibou57) a écrit :
> I did not knew Grady Booch used Ada. Did he wrote about it also ?
> 
Oh yes! Here is the sad story of Gradykin Boochwalker.

Grady  Booch was part of the initial Rational team. The company started
by writing the ROLM/Data General (3rd validated compiler), then they
designed their own Ada compiler, and the R1000, a machine whose hardware
was specially tailored for Ada development.

At that time, Booch wrote "Software Engineering with Ada" (translated in
French by J-P. Rosen ;-) ), a book that laid the basis of (composition)
OOD. He then wrote "Software Components with Ada", a book that discussed
all usual data structures. The code is still available off the net as
"the Booch components".

Then, Rational gave up on the idea of a dedicated development machine.
They saw that the market was going C++, and Booch turned to the dark
side of the source...



-- 
---------------------------------------------------------
           J-P. Rosen (rosen@adalog.fr)
Visit Adalog's web site at http://www.adalog.fr

Re: Ada and UML

[Simon Wright]

"Yannick Duchêne (Hibou57)" <yannick_duchene@yahoo.fr> writes:

> Le Tue, 31 Aug 2010 23:20:41 +0200, nobody <nobody@nowhere.com> a écrit:
>> Then the translation into code is just something mechanical.
>
> I do not really believe in automatic source generation from UML, as
> there may be multiple possibilities. Or else, may be these systems use
> something  to tell “for This, use That”. Just think that in Ada, you
> may have for  example at least, where polymorphism is required, two
> ways to do (when  feasible, sometime only one will applies) : static
> (via generics) and  dynamic (via tagged or interface)
> polymorphism. How can a system know it  should use this or that ? This
> requires a human analysis, to say “well,  this can be statically
> known, so let's use static polymorphism” or else  the opposite (just
> an example).

I am (was!) reasonably familiar with the ideas behind one approach to
this, the one originating with Shlaer-Mellor OOA.

You develop a model of your problem. This model is is precise enough
that it can be translated, given a set of rules, into executable code,
but it contains nothing about any specific platform (Ada, C, Java, ... /
embedded, distributed, ...). Note, for UML specifically, this means you
need precise semantics at the model level for this to be possible.

You develop (or buy, or re-use) a translation engine which translates
from that model to the platform you're using today.

> Your point makes me think about the so called “Executable
> UML”. Unfortunately, I do not know anything about it. I am just pretty
> sure this  cannot be automated.

Bridgepoint presently from Mentor Graphics,
http://www.mentor.com/products/sm/model_development/

iUML from Kennedy-Carter, http://www.kc.com/ (see 'Products')

In both cases the actions (the part that does things) are written in a
tool-specific programming language, and one of the jobs of the
translation engine is to turn this into compilable code.

Of particular interest to you, maybe, see
http://www.kc.com/PRODUCTS/iccg/adacode.php where you are offered two
Ada code generators, one for Ada 83 and one for SPARK (I don't know how
the SPARK generator gets 'interesting' pre/post/invariant conditions in
there; obviously the analyst is going to have to provide them).

Re: Ada and UML

[Georg Bauhaus]

On 9/2/10 2:43 AM, Yannick Duchêne (Hibou57) wrote:
> Le Wed, 01 Sep 2010 10:20:30 +0200, Matteo Bordin <matteo.bordin@gmail.com> a écrit:

>> or you leave semantic variation points to permit model transformation
>> (code generators) to inject platform-specific semantics following a
>> precise pattern.
> Look like the question I asked in a prior post : how is the source generator driven ?

It depends on the tools.  Start from this question: What drives
your own design decisions when writing this or that source code?

In order to have a name, let's call this source of design
decisions a Shape_O_Mind.

How can you picture the decisions of Shape_O_Mind?

How does Shape_O_Mind operate?

What "tools" does Shape_O_Mind use in order to produce source
text?


Some UML tools come with source templates. UML constructs will
be mapped  to source with the help of these templates.

Some UML tools include a programming language with which to
generate source from the models.

Some UML tools tie source to models, allowing round trip
engineering. They read source, too, and assign model elements
to source code. Not sure if the programmer can always control
this assignment of meaning during this reverse engineering done
by the tool.

Some tools allow the addition of model elements, such as
elements representing subprograms.

The capabilities are not mutually exclusive.

Likely all of these tools permit writing source code
"into" the model entities; the generators will insert this source.
They will not touch it during reverse engineering.

Some UML tools may push integration further to be seamless: you use
one IDE and then a UML model is just another view of your program's
source text.


Other benefits of UML tools that, I think, are not
readily available with just Ada source text:

- model checking

- "specifictation tracking"

When tackling complex relations in some program,
Shape_O_Mind has to rely on our limited capacity for
following indirections, conditionals, etc.

The relation between the set of compilation units
corresponding to problem domain entities isn't an
immediate one either.


Some higher level model elements will *not* depend on the
programming language, or on the computer used to execute
the program. How do you express this in source?

Pictures can help ("worth a thousand words"...).
Assume three Ada packages Pj, each featuring a type Tj,
such that an object of type Tj needs to know about an object
of type T(j+1).

+----+      +----+      +----+
| T1 | <>-> | T2 | <>-> | T3 |
+ ---+      +--- +      +----+

Shape_O_Mind will have little difficulty understanding the  basic
relation or objects, once <> is know to mean aggregation;
a programmer reading source will have to analyze each Pj to find out.


Technical drawings are popular among engineers.
They seem to work.  Why, then, should they not be used
for software systems, too?

Software Through Pictures(TM) is a telling name...



Georg

Re: Ada and UML

[Brian Drummond]

On Thu, 02 Sep 2010 03:18:11 +0200, Yannick Duch�ne (Hibou57)
<yannick_duchene@yahoo.fr> wrote:

>Le Wed, 01 Sep 2010 20:44:09 +0200, Simon Wright <simon@pushface.org> a  
>�crit:

>What I expect, may be explained with concrete cases.
>
>I feel for long source does not came with all value and sometime, the  
>�clever idea� in something comes at an abstract level which not any more  
>clearly visible in a source, even if the source implements this �clever  
>idea�.
...
>As an example, I have an FTP application written 5 years ago. Not so much  
>big, 2_000 lines. But I have to rework it, and although there are comments  
>and the design was clear at the time I wrote it, it seems impossible to be  
>sure to clearly understand what I had in mind at the time.
...
>And what if I ever want to re-implement these things in another language ?  
>(one is C, the other is Pascal and JS) A direct translation to Ada (which  
>I plan for the future) would surely turn into many errors every where.

One question possibly worth asking - is UML the right starting point for this
discussion?

It is certainly a candidate - but if the question is, how to capture the essence
of a design independent of the implementation (either before design, or
retrospectively to aid later understanding and possibly re-implementation) - is
it the only, or even the best candidate?

Others might be formal methods - Z or B, discussed here recently. It seems to me
they can be used to capture a specification and ruthlessly test it - but maybe
they cannot be easily applied in retrospect.
 
Or even Bon (which was mentioned here about a year ago). I had never heard of
it, so hunted down the recommended book via Amazon - second hand, ex-library.
It was pristine - it had never been borrowed...

I am probably the wrong persion to ask this question, having no practical
experience of any of these tools (beyond downloading and playing with a UML tool
set), but your post sounds so much like my internal debate that I am interested
in your thoughts.

UML appears to have more momentum and support than all the other options put
together - does that alone make it the right choice?

Or does it offer the best solution on its own merits?

Or does its (relative) popularity mean that a "better" candidate (B, perhaps) is
being overlooked?

- Brian

Re: Ada and UML

[Brian Drummond]

On Thu, 02 Sep 2010 06:48:18 +0200, "J-P. Rosen" <rosen@adalog.fr> wrote:

>Le 02/09/2010 02:22, Yannick Duch�ne (Hibou57) a �crit :
>> I did not knew Grady Booch used Ada. Did he wrote about it also ?
>> 
>Oh yes! Here is the sad story of Gradykin Boochwalker.
>
>Grady  Booch was part of the initial Rational team. The company started
>by writing the ROLM/Data General (3rd validated compiler), then they
>designed their own Ada compiler, and the R1000, a machine whose hardware
>was specially tailored for Ada development.

Oooh, interesting ... "The horizontally-microprogrammed R1000 provided two
independent 64-bit data paths, permitting simultaneous computation and type
checking".

Sounds a little bit familiar, given other recent threads.

I didn't know about that one. Thanks!

>At that time, Booch wrote "Software Engineering with Ada" (translated in
>French by J-P. Rosen ;-) ), a book that laid the basis of (composition)
>OOD.

Still, IMO, an excellent book; I would love an update to Ada 95/2005...
(admittedly I haven't read the translation!)

>Then, Rational gave up on the idea of a dedicated development machine.
>They saw that the market was going C++, and Booch turned to the dark
>side of the source...

... probably to "close the semantic gap" with the then-fashionable RISC
machines.

- Brian

Re: Ada and UML

[Robert A Duff]

Brian Drummond <brian_drummond@btconnect.com> writes:

> Oooh, interesting ... "The horizontally-microprogrammed R1000 provided two
> independent 64-bit data paths, permitting simultaneous computation and type
> checking".

All attempts to put fancy high-level-language features in hardware
(or microcode -- same thing, from our (software) point of view)
are doomed to failure.  Another example is the Symbolics Lisp
Machine.

- Bob

Re: Ada and UML

[Yannick Duchêne (Hibou57)]

Le Thu, 02 Sep 2010 15:00:07 +0200, Robert A Duff  
<bobduff@shell01.theworld.com> a écrit:
> All attempts to put fancy high-level-language features in hardware
> (or microcode -- same thing, from our (software) point of view)
> are doomed to failure.  Another example is the Symbolics Lisp
> Machine.
The other dark-side of premature optimization :P

Re: Ada and UML

[nobody]

Yannick Duchêne (Hibou57) wrote:
> Le Tue, 31 Aug 2010 23:20:41 +0200, nobody <nobody@nowhere.com> a écrit:
> 
> I do not really believe in automatic source generation from UML
Neither do I because
- UML is too large, writing a model translator to cover it would take 
longer than writing the system you want to generate.
- UML makes it possible to create models with internal conflicts.

> Or else, may be these systems use 
> something  to tell “for This, use That”. 

As Simon Wright commented. The thing we use is Executeable UML (xtUML). 
I use bridgepoint. For C++ generation we use a model compiler from 
Mentor for Ada we have built one from scratch.

Regarding the for this use that, use it happens. Often. But not always. 
The model compiler is in many cases quite as capable as I to analyze the 
model and decide if instances of one class should be allocated 
dynamically or created once and for all in an array. If traditional 
pointers or some other mechanism should be used for relations and so on.

> Just think that in Ada, you may 
> have for  example at least, where polymorphism is required, two ways to 
> do (when  feasible, sometime only one will applies) : static (via 
> generics) and  dynamic (via tagged or interface) polymorphism. How can a 
> system know it  should use this or that ? This requires a human
> analysis, to say “well,  this can be statically known, so let's use 
> static polymorphism” or else  the opposite (just an example).

There are of cource such examples. But remember that when doing the 
translation from model into code you have the whole model of your system 
available in a databas and can can look at things from a much better 
perspective than when you are coding a single file.

An easy to understand example is relations. If you draw a simple line in 
the class model you state that there is a relation. But the model 
compiler can look at every single line of code in your system to see if 
you use it (navigate) or not. If it sees that you never use it, it wont 
have to generate the code to maintain it and if it finds you only 
navigate one direction it can add the code neded for it to be one way 
only. (Now many hard core coders will feel lost, what does he mean one 
way only, arn't they all? No in xtUML they are always bidirectional, 
composite, aggregate and navigability as in UML does not exist).

> Your point makes me think about the so called “Executable UML”.  
> Unfortunately, I do not know anything about it. I am just pretty sure 
> this  cannot be automated.

I think it can. We are in the process of completing a pretty large 
system. Its got ~650 classes of which probably around 200 has state 
machines. Generated system is > 3000 ada packages.

> If you wan to tell more... just do :)
Sorry, not allowed to give details. Call Mentor, ask for when John Wolfe 
or Cortland Starret can be in your area, you want to have a look at 
their system modelling products.

Simon mentioned distribution. We use that. In our system we can mark 
classes and services as distributed. Then the model compiler generates 
definition files for the broker and in the classes it generates all the 
interface code needed to distribute things when it is updated.

So, do I have anything to complain about? Yes
- Price of the tool.
- Your first project will fail. Try to combine this knowledge with the 
pricecs when you seek finansing.
- Availability of model compilers
- Constantly having to defend the method
- Performance of the model compiler. Coming from a world where a 
recompile takes perhaps as long as 15 seconds entering a world where 
regeneration/recompilation takes three hours is sometimes (read always) 
hard. The generated code is probably faster than anything I could have 
written myself.

Regarding SPARK I know just about nothing. I know there has been work on 
  modifying the Ada compiler to produce spark code. Do not know how far 
that has gone or what efforts need to be done.

There has also been work on generating VHDL. Just think about it. Model 
a system and end up with hardware specific for your problem.

One strange thing the non believers tend to bring up is that software 
development needs to be fun. My comment is that I have now done this for 
six years. It has been the most interesting years of my twenty as a 
professional software developer. The productivity you can reach is 
beyond anything I had imagined before.

Re: Ada and UML

[Yannick Duchêne (Hibou57)]

Le Thu, 02 Sep 2010 09:50:12 +0200, Georg Bauhaus  
<rm-host.bauhaus@maps.futureapps.de> a écrit:
> It depends on the tools.  Start from this question: What drives
> your own design decisions when writing this or that source code?

Short reply for the time: this “What drives your own design decisions”  
make me think about something I will have a try with. This is named  
Acceleo, and seems to be used to apply transformation of a model to end up  
into text, which to be sources. But unfortunately, when I want to setup a  
project with this Acceleo, with the hope I could write my own  
transformation, it complains the project must be a Java project. May be  
this means there is no way to use this to generate Ada. As this does not  
come with reverse engineering, I do not see a reason why this could not be  
able to generate any text, thus for any target.

Re: Ada and UML

[Yannick Duchêne (Hibou57)]

Le Fri, 03 Sep 2010 01:05:23 +0200, Yannick Duchêne (Hibou57)  
<yannick_duchene@yahoo.fr> a écrit:
> Short reply for the time: this “What drives your own design decisions”  
> make me think about something I will have a try with. This is named  
> Acceleo, and seems to be used to apply transformation of a model to end  
> up into text, which to be sources. But unfortunately, when I want to  
> setup a project with this Acceleo, with the hope I could write my own  
> transformation, it complains the project must be a Java project. May be  
> this means there is no way to use this to generate Ada.
No, that is solved. You can do Ada with it, and even anything else. Mmmhh,  
important to notice as it works, this implies a full top-down process, not  
sure that's good all the way. And I feel this will not be a peace of cake  
to have a full generator ; so I rather see a kind of template generation.  
Any way, will have a look for a few days to get an idea.

Hint: if anyone is interested in trying this too, get a fresh Eclipse to  
avoid compatibility troubles, then add Acceleo from a bundle, not from the  
Eclipse Modeling Components menu, or else you will get into troubles  
later. Also drop Papyrus if you ever preferred this one, because it will  
not work anymore, and instead, add TopCased from a bundle too. I.e. merge  
Eclipse + Acceleo + TopCased all from their own bundle (weight as much 1G,  
that is very much, but there is no other way).

I did not found any support for Ada in Eclipse, but don't bother, if you  
want to read Ada generated sources, you will just have to switch to GPS,  
as you (maybe) usually do.

For a quick tutorial about Acceleo and Model To Text transformation (this  
is an OMG standard, not a closed standard), you may have a look here :
http://www.acceleo.org/pages/quickstart/en
This example targets HTML, I know, don't worry, the technique will still  
be the same.

That is funny, you do not even have to do refactoring if ever you change  
the name of a class or of anything else: any renaming is automatically  
propagated every where in the modal (was a side note).

-- 
“Dual licensing is the Perl's way to disinfect the GNU General Public  
Virus!” (anonymous)

Re: Ada and UML

[Matteo Bordin]

>
> Hint: if anyone is interested in trying this too, get a fresh Eclipse to  
> avoid compatibility troubles, then add Acceleo from a bundle, not from the  
> Eclipse Modeling Components menu, or else you will get into troubles  
> later. Also drop Papyrus if you ever preferred this one, because it will  
> not work anymore, and instead, add TopCased from a bundle too. I.e. merge  
> Eclipse + Acceleo + TopCased all from their own bundle (weight as much 1G,  
> that is very much, but there is no other way).
>
> I did not found any support for Ada in Eclipse, but don't bother, if you  
> want to read Ada generated sources, you will just have to switch to GPS,  
> as you (maybe) usually do.

Papyrus 1.11 includes an UML2-to-Ada2005 code generator. Very
primitive, written just as a counter example for some FUD about Ada
(Ada can't do OO, Java is more expressive than Ada and other
idiocies). BTW, it is written in Acceleo, see
http://www.papyrusuml.org/scripts/home/publigen/content/templates/show.asp?P=131&L=EN&ITEMID=15

You may also want to have a look at GNATbench
http://www.adacore.com/home/products/gnatpro/toolsuite/gnatbench/

Re: Ada and UML

[Yannick Duchêne (Hibou57)]

Le Fri, 03 Sep 2010 08:54:59 +0200, Matteo Bordin  
<matteo.bordin@gmail.com> a écrit:
> You may also want to have a look at GNATbench
> http://www.adacore.com/home/products/gnatpro/toolsuite/gnatbench/
For others, ... Pro features is surely not for me :P . However for any  
ones, there is a GNAT Bench to build from source, to be used with TopCased  
:
http://gforge.enseeiht.fr/projects/gnatbench/
Appears this is not pure Acceleo, as the project info says “Ada, C, Java”.
Will study this later. For the time I have a silly trouble with Acceleo  
(hope this is not a bug). As soon as it will be solved, I will post here a  
tiny (very tiny) example of UML to Ada transformation using Acceleo  
scripting.

-- 
“Dual licensing is the Perl's way to disinfect the GNU General Public  
Virus!” (anonymous)

Re: Ada and UML

[sjw]

On Sep 3, 11:20 am, Yannick Duchêne (Hibou57)
<yannick_duch...@yahoo.fr> wrote:
> Le Fri, 03 Sep 2010 08:54:59 +0200, Matteo Bordin  
> <matteo.bor...@gmail.com> a écrit:> You may also want to have a look at GNATbench
> >http://www.adacore.com/home/products/gnatpro/toolsuite/gnatbench/
>
> For others, ... Pro features is surely not for me :P . However for any  
> ones, there is a GNAT Bench to build from source, to be used with TopCased  
> :http://gforge.enseeiht.fr/projects/gnatbench/

Or you could go to the Libre web site http://libre.adacore.com/ and
find version 2.4.0 (including sources, if wanted)

Re: Ada and UML

[Hibou57 (Yannick Duchêne)]

On 3 sep, 06:19, Yannick Duchêne (Hibou57) <yannick_duch...@yahoo.fr>
wrote:
> No, that is solved. You can do Ada with it

Here is a tiny example, just to show to people with curiosity. This
lack many and many things, this is just to show.

First, the Model to Text transformation. It is able to generate a
package with contained classes implemented as records whose full view
is private. Methods which are not of UML public visibility are
declared in the Ada package private part, the others, in the public
part. Generate the *.ads source only.


   <%metamodel http://www.eclipse.org/uml2/2.0.0/UML%>

   <%script type="uml.NamedElement" name="asTypeName" post="trim()"%>
   <%args(0).name%>_Type

   <%script type="uml.Operation" name="asParameterList"
post="trim()"%>
   Self : <%asTypeName(args(0).parent())%>
   <%if (eAllContents("Parameter")) {%>
      <%for (eAllContents("Parameter")) {%>
         <%if (!name.equalsIgnoreCase("return")) {%>
         ; <%name%> : <%asTypeName(type)%>
         <%}%>
      <%}%>
   <%}%>)

   <%script type="uml.Operation" name="asSignature" post="trim()"%>
   <%if (type == "") {%>
      procedure <%name%> (
      <%asParameterList(current)%>;
   <%}else{%>
      function <%name%> (
      <%asParameterList(current)%>
      return <%asTypeName(type)%>;
   <%}%>

   <%script type="uml.Package" name="Generator_1" file="<%name%>.ads"
%>

   package <%name%> is

      <%for (eAllContents("Class")) {%>
         type <%asTypeName(current)%> is private;

         <%for (eAllContents("Operation")) {%>
            <%if (visibility == "public") {%>
               <%asSignature(current)%>
            <%}%>
         <%}%>
      <%}%>

   private

      <%for (eAllContents("Class")) {%>
         type <%asTypeName(current)%> is record
            <%for (eAllContents("Property")) {%>
               <%name%> : <%asTypeName(type)%>;
            <%}%>
         end record; --  <%asTypeName(current)%>

         <%for (eAllContents("Operation")) {%>
            <%if (visibility != "public") {%>
               <%asSignature(current)%>
            <%}%>
         <%}%>
      <%}%>

   end <%name%>;




Then, a sample UML model it can be applied to (to access XML source of
a model, just access it as a text file):


   <?xml version="1.0" encoding="UTF-8"?>
   <uml:Model xmi:version="2.1" xmlns:xmi="http://schema.omg.org/spec/
XMI/2.1" xmlns:uml="http://www.eclipse.org/uml2/3.0.0/UML"
xmi:id="_qb8akM37EdqwVrslYOdUDA">
     <packagedElement xmi:type="uml:Package"
xmi:id="_w8IxIM37EdqwVrslYOdUDA" name="Greetings">
       <ownedComment xmi:id="_c4EW8LcvEd-uHOxBOe6bQQ"
annotatedElement="_yjuScLcsEd-uHOxBOe6bQQ">
         <body>Your three cents here.</body>
       </ownedComment>
       <packagedElement xmi:type="uml:Class" xmi:id="_yjuScLcsEd-
uHOxBOe6bQQ" name="Greeting_Box" clientDependency="_fD-ewLc4Ed-
uHOxBOe6bQQ">
         <ownedAttribute xmi:id="_gbfysrc1Ed-uHOxBOe6bQQ"
name="Greating_Counter" visibility="package" type="_ImL_4Lc0Ed-
uHOxBOe6bQQ"/>
         <ownedOperation xmi:id="_pudakLcvEd-uHOxBOe6bQQ"
name="Say_Hi"/>
         <ownedOperation xmi:id="_m3Xp8rc1Ed-uHOxBOe6bQQ"
name="Set_Greeting_Counter">
           <ownedParameter xmi:id="_AFKIELc2Ed-uHOxBOe6bQQ"
name="Value" type="_ImL_4Lc0Ed-uHOxBOe6bQQ"/>
         </ownedOperation>
         <ownedOperation xmi:id="_P3XxsLc4Ed-uHOxBOe6bQQ"
name="Get_Greeting_Counter">
           <ownedParameter xmi:id="_lddJULc4Ed-uHOxBOe6bQQ"
name="return" type="_ImL_4Lc0Ed-uHOxBOe6bQQ" direction="return"/>
         </ownedOperation>
         <ownedOperation xmi:id="_NMRYMLdKEd--x_e0zw638A"
name="Have_A_Private_Time" visibility="private"/>
       </packagedElement>
       <packagedElement xmi:type="uml:PrimitiveType"
xmi:id="_ImL_4Lc0Ed-uHOxBOe6bQQ" name="Natural"/>
       <packagedElement xmi:type="uml:Dependency" xmi:id="_fD-ewLc4Ed-
uHOxBOe6bQQ" name="Dependency1" supplier="_ImL_4Lc0Ed-uHOxBOe6bQQ"
client="_yjuScLcsEd-uHOxBOe6bQQ"/>
     </packagedElement>
   </uml:Model>




Sample output. Note that I did not work the generated source
formating ; I know it's ugly.


   package Greetings is

         type Greeting_Box_Type is private;

               procedure Say_Hi (
      Self : Greeting_Box_Type
      );
               procedure Set_Greeting_Counter (
      Self : Greeting_Box_Type
            ; Value : Natural_Type
      );
               function Get_Greeting_Counter (
      Self : Greeting_Box_Type
      )
      return Natural_Type;

   private

         type Greeting_Box_Type is record
               Greating_Counter : Natural_Type;
         end record; --  Greeting_Box_Type

               procedure Have_A_Private_Time (
      Self : Greeting_Box_Type
      );

   end Greetings;


Has a taste of both ASIS (due to semantic access of an UML "source")
and XSLT (due to transform). Never seen like this before.

There may be provision to generate full source when an implementation
is a pure state machine. At least, this is able to generate a more or
less detailed skeleton, but with a better view on the overall types +
tagged + packages architecture/cooperation and probably more.

The limitation I feel: not as much easy and clean to access UML
diagrams semantic this way as it is to access Ada sources semantic
using ASIS. May be this is partly due to the script-like language
which is involved.


Well, any one can now push Ada in UML shops (or perhaps this is UML
pushing in an Ada shop, lol)


How does it work with HOOD ? Does it work the same way ?

Re: Ada and UML

[Matteo Bordin]

> On 3 sep, 06:19, Yannick Duchêne (Hibou57) <yannick_duch...@yahoo.fr>
> wrote:
>
> > No, that is solved. You can do Ada with it
>
> Here is a tiny example, just to show to people with curiosity. This
> lack many and many things, this is just to show.

You should use Acceleo 3, which complies with the OMG model-to-text
spec.

I personally think that scripting languages such as Acceleo (or xPand
or similar) are ok just for very simple code generators because they
cannot easily handle persistent datastructures. I cannot imagine
writing a code generator for xUML or for synchronous languages in
Acceleo...

> How does it work with HOOD ? Does it work the same way ?

Supposing you have an Ecore implementation of HOOD, yes, it would work
the same way. May I ask you why you are interested in HOOD? My first
project at university was an HRT-HOOD to Ada Ravenscar code
generator ;-) (http://ieeexplore.ieee.org/xpl/freeabs_all.jsp?
arnumber=1508447).

Re: Ada and UML

[Matteo Bordin]

> On 3 sep, 06:19, Yannick Duchêne (Hibou57) <yannick_duch...@yahoo.fr>
> wrote:
>
> > No, that is solved. You can do Ada with it
>
> Here is a tiny example, just to show to people with curiosity. This
> lack many and many things, this is just to show.

You should use Acceleo 3, which complies with the OMG model-to-text
spec.

I personally think that scripting languages such as Acceleo (or xPand
or similar) are ok just for very simple code generators because they
cannot easily handle persistent datastructures. I cannot imagine
writing a code generator for xUML or for synchronous languages in
Acceleo...

> How does it work with HOOD ? Does it work the same way ?

Supposing you have an Ecore implementation of HOOD, yes, it would work
the same way. May I ask you why you are interested in HOOD? My first
project at university was an HRT-HOOD to Ada Ravenscar code
generator ;-) (http://ieeexplore.ieee.org/xpl/freeabs_all.jsp?
arnumber=1508447).

Re: Ada and UML

[Simon Wright]

Matteo Bordin <matteo.bordin@gmail.com> writes:

> I personally think that scripting languages such as Acceleo (or xPand
> or similar) are ok just for very simple code generators because they
> cannot easily handle persistent datastructures. I cannot imagine
> writing a code generator for xUML or for synchronous languages in
> Acceleo...

I don't know Acceleo (clearly something to look at!), but from
experience with XSLT I'd say that it's much easier with model-to-model
transformations.

By that I mean, XSLT will easily translate XML to code if the structure
of the XML is a close match to that of the code. But if you omit (as I
did) the transformation from the structure that matches the UML tool's
needs to this more convenient structure, you end up doing a lot of work
in a language that's not well suited to it. For example, you wouldn't
want a state machine where the same event triggered more than one
transition from a given state. This and related checks took ~100 lines
of hairy XSLT in ColdFrame (http://coldframe.sourceforge.net/).

Re: Ada and UML

[Yannick Duchêne (Hibou57)]

Le Fri, 03 Sep 2010 18:14:47 +0200, Matteo Bordin  
<matteo.bordin@gmail.com> a écrit:
> You should use Acceleo 3, which complies with the OMG model-to-text
> spec.
That was because I first get into trouble with version 3, now it is solved.

To not give erroneous picture, here is the same with the relevant version.  
Indeed, this is different. Still did not found a way to have a nicer  
output (I did the best, but still not nice).


Transormation:

    [comment encoding = UTF-8 /]
    [module Generate('http://www.eclipse.org/uml2/3.0.0/UML')/]

    [template lined(s : String)]
    [s.trim().replaceAll('\\s+', ' ')/]
    [/template]

    [template indented(s : String)]
    [s.trim().replaceAll('(\\n)\\s+', '$0 ')/]
    [/template]

    [template asTypeName(e : NamedElement) post(lined())]
       [e.name/]_Type
    [/template]

    [template asParameter(p : Parameter) post(lined())]
       [p.name/] : [p.type.asTypeName()/]
    [/template]

    [template asNextParameter(p : Parameter) post(indented())]
    ;
    [p.asParameter()/]
    [/template]

    [template asFirstParameter(p : Parameter) post(lined())]
       [p.asParameter()/]
    [/template]

    [template asSelfParameter(o : Operation) post(lined())]
       Self : [o.ancestors(Class).asTypeName()/]
    [/template]

    [template asParameterList(o: Operation) post(indented())]
       ([o.asSelfParameter()/]
       [for (p : Parameter | o.eAllContents(Parameter))]
          [if (not p.name.equalsIgnoreCase('return'))]
             [p.asNextParameter()/]
          [/if]
       [/for])
    [/template]

    [template asSignature(o: Operation) post(indented())]
       [if (o.type = null)]
          procedure [o.name/]
          [o.asParameterList()/];
       [/if]
       [if (o.type <> null)]
          function [o.name/]
          [o.asParameterList()/]
          return [o.type.asTypeName()/];
       [/if]
    [/template]

    [template publicPart(pkg: Package) post(indented())]
       [for (c : Class | pkg.eAllContents(Class))]
          type [c.asTypeName()/] is private;

          [for (o : Operation | c.eAllContents(Operation))]
             [if (o.visibility = VisibilityKind::public)]
                [o.asSignature()/]
             [/if]
          [/for]
       [/for]
    [/template]

    [template privatePart(pkg: Package) post(indented())]
       [for (c : Class | pkg.eAllContents(Class))]
          type [c.asTypeName()/] is record
             [for (p : Property | c.eAllContents(Property))]
                [p.name/] : [p.type.asTypeName()/];
             [/for]
          end record; --  [c.asTypeName()/]

          [for (o : Operation | c.eAllContents(Operation))]
             [if (o.visibility <> VisibilityKind::public)]
                [o.asSignature()/]
             [/if]
          [/for]
       [/for]
    [/template]

    [template packageSpecification(pkg : Package) post(trim())]
    package [pkg.name/] is
       [pkg.publicPart()/]
    private
       [pkg.privatePart()/]
    end [pkg.name/];
    [/template]

    [template public Generate(pkg : Package)]
       [file (pkg.name + '.ads', false, 'UTF-8')]
    [pkg.packageSpecification()/]
       [/file]
    [/template]



Sample output, using the same UML model as for the prior example (the  
“indented” method does not seem to be enough).

    package Greetings is
       type Greeting_Box_Type is private;

                    procedure Say_Hi
                           (Self : Greeting_Box_Type
                           );
                    procedure Set_Greeting_Counter
                           (Self : Greeting_Box_Type
                                     ;
                                     Value : Natural_Type
                           );
                    function Get_Greeting_Counter
                           (Self : Greeting_Box_Type
                           )
                           return Natural_Type;
    private
       type Greeting_Box_Type is record
                    Greating_Counter : Natural_Type;
              end record; --  Greeting_Box_Type

                    procedure Have_A_Private_Time
                           (Self : Greeting_Box_Type
                           );
    end Greetings;


Useful link in this context:

    http://www.omg.org/spec/MOFM2T/1.0/
    for references about MTL (you will see indeed Acceleo 3 conforms to  
this, while 2.7 was not)

-- 
“Dual licensing is the Perl's way to disinfect the GNU General Public  
Virus!” (anonymous)

Re: Ada and UML

[Matteo Bordin]

> That was because I first get into trouble with version 3, now it is solved.
>
> To not give erroneous picture, here is the same with the relevant version.  
> Indeed, this is different. Still did not found a way to have a nicer  
> output (I did the best, but still not nice).

Why don't you simply post process files with gnat pretty after
generation?

>
> Transormation:
>

A few comments, but you should go on the Acceleo web site for this:

> [for (p : Parameter | o.eAllContents(Parameter))]

This is highly un-optimized: you are looping over all elements
contained in an uml::Operation and checking for each of them if their
metatype is a (subtype of) uml::Parameter. What you really want to do
is:

[for (p : Paramenter | o.ownedParameter)]

that is, using the UML metamodel as a sort of grammar. The same
applies for looping over operations from a Class (ownedOperation) and
so on

Also note that Acceleo has a separator facility to separate the
printing of the elements of a sequence with a string but on the last
position (useful to print the ";" after all parameters but the last
one).

Re: Ada and UML

[Yannick Duchêne (Hibou57)]

Le Sat, 04 Sep 2010 16:51:51 +0200, Yannick Duchêne (Hibou57)  
<yannick_duchene@yahoo.fr> a écrit:
> Useful link in this context:
>
>     http://www.omg.org/spec/MOFM2T/1.0/
>     for references about MTL (you will see indeed Acceleo 3 conforms to  
> this, while 2.7 was not)
And another, which is funny, as it show usage of Ada like comments ;)
http://www.omg.org/spec/OCL/2.2/
There are plenty of “--” in this doc
Seems they know about something and they were inspired after this.

Also time to reply a question posted in this thread about UML and SPARK :  
I would say there is a way to generate SPARK annotations from UML's OCL  
constraints.


-- 
“Dual licensing is the Perl's way to disinfect the GNU General Public  
Virus!” (anonymous)

Re: Ada and UML

[Yannick Duchêne (Hibou57)]

Le Tue, 31 Aug 2010 12:12:43 +0200, Yannick Duchêne (Hibou57)  
<yannick_duchene@yahoo.fr> a écrit:
Look there, AdaCore is part of the TopCased partners :)
http://www.topcased.org/index.php/content/view/32/49/
look, it's right at the top of the page (just seems there is a trouble  
with their logo).


-- 
“Dual licensing is the Perl's way to disinfect the GNU General Public  
Virus!” (anonymous)