Comparison : Ada and UML (comparison… indeed)

Comparison : Ada and UML (comparison… indeed)

[Yannick Duchêne (Hibou57)]

Hello all,

Back to a famous topic of OO with Ada vs OO with other languages; just  
that here, let's replace “other languages” by UML.

Recall of the case (exposed in many places to show how Ada in more cleanly  
OO than so called pure-OO languages) : Let A and B be two classes. A  
defines a method “bool A::compare (A other);” (is that OK for the syntax ?  
… I forget so much about C-plus-plus). Then, B  
inherits/extends/specializes A, and thus get a method which is “bool  
B::compare (B other);”. But the concrete corresponding ones would be from  
Ada's point of view : “function Compare (Left, Righ : A) return Boolean;”  
in A class, and “function Compare (Left : B, Right : A) return Boolean;”  
in B class. Indeed, the receiver of the message in the case of B, is of  
type B, while the parameter is still of type A, as defined in A (Eiffel  
solved this with the “like” keyword if my mind is right).

OK, very nice, this shows how much Ada is superior at OO (and Eiffel two)  
than other pure-OO languages; but that is not the topic : UML seems to do  
the same! And I just wonder if it can do another way. I wonder about it  
for a personal purpose : I am actually trying to design a personal  
transformation from UML to Ada. But I am not so much sure UML is good  
enough for the purpose of modeling, while it has some interesting traits  
(like popularity, availability of editors, and so on).

This use to be a topic here, when we talked about class and package in Ada  
vs UML. This one question is another one, which troubles me even a degree  
above the one of packages and classes.

By the way, if some ones can tell about HOOD here… (I am talking about  
abstract model so far, not method). How HOOD would represent this ? With  
the same flaws or not ? (there are provision with Eclipse's Meta Language  
framework, to create something based on HOOD I believe, if ever it prove  
to be better here).

This is a symptomatic question to me.

Re: Comparison : Ada and UML (comparison… indeed)

[Simon Wright]

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

> Back to a famous topic of OO with Ada vs OO with other languages; just
> that here, let's replace “other languages” by UML.

I've just looked at the UML 2.0 Superstructure Specification 05-07-04,
and in section 7.3.6, Operation, under Semantics (on page 117 of 709!)
it says

  "An operation may be redefined in a specialization of the featured
  classifier. This redefinition may specialize the types of the owned
  parameters, add new preconditions or postconditions, add new raised
  exceptions, or otherwise refine the specification of the operation."

So now you know (well, in my case, now I _don't_ know!)

Re: Comparison : Ada and UML (comparison… indeed)

[Yannick Duchêne (Hibou57)]

Le Sun, 31 Oct 2010 08:11:35 +0100, Simon Wright <simon@pushface.org> a  
écrit:

> "Yannick Duchêne (Hibou57)" <yannick_duchene@yahoo.fr> writes:
>
>> Back to a famous topic of OO with Ada vs OO with other languages; just
>> that here, let's replace “other languages” by UML.
>
> I've just looked at the UML 2.0 Superstructure Specification 05-07-04,
> and in section 7.3.6, Operation, under Semantics (on page 117 of 709!)
You're brave

> it says
>
>   "An operation may be redefined in a specialization of the featured
>   classifier. This redefinition may specialize the types of the owned
>   parameters, add new preconditions or postconditions, add new raised
>   exceptions, or otherwise refine the specification of the operation."

“Owned parameters” it says so, and the receiver is not part of owned  
parameters. So the flaw is unavoidable. I'm afraid many other flaw are  
hidden the same way (at least, this does not witness for something good).

Does HOOD include diagrams for State Machines, Collaborations and  
Scenarios ? That is mainly what is of interest to me in UML (that is not  
just for class diagrams which does not offer anything useful compared to  
source, but class diagrams are just required to define elements of other  
diagrams). If someone can confirms HOOD has something similar, I may say  
its time now to look at HOOD a bit also (the modeling language, not the  
method).


-- 
Si les chats miaulent et font autant de vocalises bizarres, c’est pas pour  
les chiens.

Re: Comparison : Ada and UML (comparison… indeed)

[Vinzent Hoefler]

On Sun, 31 Oct 2010 09:01:34 +0100, Yannick Duchêne (Hibou57) <yannick_duchene@yahoo.fr> wrote:

> Does HOOD include diagrams for State Machines, Collaborations and
> Scenarios ?

HOOD emphasizes the use of state transition diagrams, data flow diagrams,
and context diagrams.

> That is mainly what is of interest to me in UML (that is not
> just for class diagrams which does not offer anything useful compared to
> source, but class diagrams are just required to define elements of other
> diagrams). If someone can confirms HOOD has something similar, I may say
> its time now to look at HOOD a bit also (the modeling language, not the
> method).

I think that's the wrong way of looking at HOOD.

HOOD still is a design _method_ applying certain rules and restrictions.
It just uses a specific notation (merely for historical reasons, I'd say).

UML on the other hand is a meta-language, so nobody stops you from
expressing a HOOD design in UML notation with the appropriate stereotypes.

See HRT-HOOD -> HRT-UML.


Vinzent.

-- 
There is no signature.

Re: Comparison : Ada and UML (comparison… indeed)

[Yannick Duchêne (Hibou57)]

Le Sun, 31 Oct 2010 09:33:15 +0100, Vinzent Hoefler  
<nntp-2010-10@t-domaingrabbing.de> a écrit:
> HOOD emphasizes the use of state transition diagrams, data flow diagrams,
> and context diagrams.
That's nice, there is no Data-Flow diagram in UML. But Scenario seems  
required, and you did not mentioned it.

>> That is mainly what is of interest to me in UML (that is not
>> just for class diagrams which does not offer anything useful compared to
>> source, but class diagrams are just required to define elements of other
>> diagrams). If someone can confirms HOOD has something similar, I may say
>> its time now to look at HOOD a bit also (the modeling language, not the
>> method).
>
> I think that's the wrong way of looking at HOOD.
>
> HOOD still is a design _method_ applying certain rules and restrictions.
> It just uses a specific notation (merely for historical reasons, I'd  
> say).
>
> UML on the other hand is a meta-language, so nobody stops you from
> expressing a HOOD design in UML notation with the appropriate  
> stereotypes.
I see both point, and here is : what is involved is not only notation,  
also semantic. Even if semantic is not a process as directed by a method,  
there is in semantic, a seed of something fundamental (so my view does not  
entirely ignore part of the spirit of a possible method). As the initial  
message suggested, I do not bother about representation (this is not about  
picture). Then about using stereotypes, this is something I would like to  
avoid, precisely for semantic matters, as it seems many people already  
draw diagrams without exact semantic in mind (an example, would be to Draw  
a package, and give that package the Ada semantic instead of the UML  
semantic). No need to add more possible source of miss-understanding.

For the smalltalk, all the above is also why I consider popularity. I  
simply expect “more popular = more understood”. I know one of them win  
here, but want to balance however.

-- 
Si les chats miaulent et font autant de vocalises bizarres, c’est pas pour  
les chiens.

Re: Comparison : Ada and UML (comparison… indeed)

[Yannick Duchêne (Hibou57)]

Le Sun, 31 Oct 2010 09:33:15 +0100, Vinzent Hoefler  
<nntp-2010-10@t-domaingrabbing.de> a écrit:
> HOOD still is a design _method_ applying certain rules and restrictions.
> It just uses a specific notation (merely for historical reasons, I'd  
> say).
Good place for this link :
http://students.cs.byu.edu/~pbiggs/survey.html
An overview of most famous notation-methods : HOOD, OMT, OOA, etc (still  
not the full of HOOD).

-- 
Si les chats miaulent et font autant de vocalises bizarres, c’est pas pour  
les chiens.

Re: Comparison : Ada and UML (comparison… indeed)

[J-P. Rosen]

Le 31/10/2010 07:22, Yannick Duchêne (Hibou57) a écrit :
> By the way, if some ones can tell about HOOD here… (I am talking about
> abstract model so far, not method). How HOOD would represent this ? With
> the same flaws or not ? (there are provision with Eclipse's Meta
> Language framework, to create something based on HOOD I believe, if ever
> it prove to be better here).
> 
The precise rules of inheritance are not defined by the method, it's
just "as the implementation language does".

-- 
---------------------------------------------------------
           J-P. Rosen (rosen@adalog.fr)
Adalog a déménagé / Adalog has moved:
2 rue du Docteur Lombard, 92441 Issy-les-Moulineaux CEDEX
Tel: +33 1 45 29 21 52, Fax: +33 1 45 29 25 00

Re: Comparison : Ada and UML (comparison… indeed)

[J-P. Rosen]

Le 31/10/2010 09:01, Yannick Duchêne (Hibou57) a écrit :
> Does HOOD include diagrams for State Machines, Collaborations and
> Scenarios ? That is mainly what is of interest to me in UML (that is not
> just for class diagrams which does not offer anything useful compared to
> source, but class diagrams are just required to define elements of other
> diagrams). If someone can confirms HOOD has something similar, I may say
> its time now to look at HOOD a bit also (the modeling language, not the
> method).
> 
 At this point, the best for you is to read the book and decide by
yourself. I'll send it by private mail. (For obscure copyright reasons I
haven't published it on the web, but I can send it (PDF) to anyone who
wants it).

-- 
---------------------------------------------------------
           J-P. Rosen (rosen@adalog.fr)
Adalog a déménagé / Adalog has moved:
2 rue du Docteur Lombard, 92441 Issy-les-Moulineaux CEDEX
Tel: +33 1 45 29 21 52, Fax: +33 1 45 29 25 00

Re: Comparison : Ada and UML (comparison… indeed)

[Vinzent Hoefler]

On Sun, 31 Oct 2010 11:18:05 +0100, Yannick Duchêne (Hibou57) <yannick_duchene@yahoo.fr> wrote:

> Le Sun, 31 Oct 2010 09:33:15 +0100, Vinzent Hoefler
> <nntp-2010-10@t-domaingrabbing.de> a écrit:
>> HOOD emphasizes the use of state transition diagrams, data flow diagrams,
>> and context diagrams.
> That's nice, there is no Data-Flow diagram in UML. But Scenario seems
> required, and you did not mentioned it.

I would probably express them with context diagrams.

Apart from that HOOD is very text-oriented.
You just say what you need to say. ;)

>> I think that's the wrong way of looking at HOOD.
>>
>> HOOD still is a design _method_ applying certain rules and restrictions.
>> It just uses a specific notation (merely for historical reasons, I'd
>> say).
>>
>> UML on the other hand is a meta-language, so nobody stops you from
>> expressing a HOOD design in UML notation with the appropriate
>> stereotypes.
>
> I see both point, and here is : what is involved is not only notation,
> also semantic.

Yes. I would even say, the semantic is all that matters. Notation is just
an agreement, so that everybody else understands the same semantic.

> picture). Then about using stereotypes, this is something I would like to
> avoid, precisely for semantic matters, as it seems many people already
> draw diagrams without exact semantic in mind (an example, would be to Draw
> a package, and give that package the Ada semantic instead of the UML
> semantic). No need to add more possible source of miss-understanding.

Well, when I said "appropriate stereotypes" this was meant to be "stereotypes
with the properly defined semantic". Agreement about it (see above) plays the
most important part here.

Just drawing pictures where everybody else understands something different,
doesn't help, of course. But mis-using UML like you describe above seems a
common way of doing design these days. ;)

> For the smalltalk, all the above is also why I consider popularity. I
> simply expect “more popular = more understood”.

Well, yes. The other possibility could be to restrict the possible
notation to a very small set so that even a novice can understand the
semantic in a couple of days.

One is UML which is popular, so it is supposed to be understood, but has a
very large set of notations which are not even easy to grasp (at least not
in a couple of days), the other one is HOOD which is not popular, but the
set of symbols is rather small, so it's relatively easy to learn.

So, if you restrict the UML notation to the HOOD subset, you can get both. ;)


Vinzent.

-- 
There is no signature.

Re: Comparison : Ada and UML (comparison… indeed)

[J-P. Rosen]

Le 31/10/2010 09:33, Vinzent Hoefler a écrit :
> HOOD still is a design _method_ applying certain rules and restrictions.
> It just uses a specific notation (merely for historical reasons, I'd say).
> 
> UML on the other hand is a meta-language, so nobody stops you from
> expressing a HOOD design in UML notation with the appropriate stereotypes.
> 
True. The STOOD tool (restricted version freely downloadable) can
represent your design with traditional HOOD diagrams or UML diagrams.

-- 
---------------------------------------------------------
           J-P. Rosen (rosen@adalog.fr)
Adalog a déménagé / Adalog has moved:
2 rue du Docteur Lombard, 92441 Issy-les-Moulineaux CEDEX
Tel: +33 1 45 29 21 52, Fax: +33 1 45 29 25 00

Re: Comparison : Ada and UML (comparison… indeed)

[Yannick Duchêne (Hibou57)]

Le Sun, 31 Oct 2010 11:18:05 +0100, Yannick Duchêne (Hibou57)  
<yannick_duchene@yahoo.fr> a écrit:

> Le Sun, 31 Oct 2010 09:33:15 +0100, Vinzent Hoefler  
> <nntp-2010-10@t-domaingrabbing.de> a écrit:
>> HOOD emphasizes the use of state transition diagrams, data flow  
>> diagrams,
>> and context diagrams.
> That's nice, there is no Data-Flow diagram in UML. But Scenario seems  
> required, and you did not mentioned it.
There is : Activity Diagrams (which I do not already know enough) are used  
for that :
http://www.pst.ifi.lmu.de/~stoerrle/V/AD2b-DataFlow.pdf
This document even talks about verification… Dedication to Dmitry

-- 
Si les chats miaulent et font autant de vocalises bizarres, c’est pas pour  
les chiens.

Re: Comparison : Ada and UML (comparison… indeed)

[Yannick Duchêne (Hibou57)]

Le Sun, 31 Oct 2010 11:47:46 +0100, J-P. Rosen <rosen@adalog.fr> a écrit:
>> UML on the other hand is a meta-language, so nobody stops you from
>> expressing a HOOD design in UML notation with the appropriate  
>> stereotypes.
>>
> True. The STOOD tool (restricted version freely downloadable) can
> represent your design with traditional HOOD diagrams or UML diagrams.

Elydis Software
http://www.ellidiss.com/products.asp
There is indeed a download page here
http://www.ellidiss.com/downloads.asp
but no mention of any trial version. Will register anyway.

They seems involved in the aforementioned HRT-UML by the way (see first  
link).


-- 
Si les chats miaulent et font autant de vocalises bizarres, c’est pas pour  
les chiens.

Re: Comparison : Ada and UML (comparison… indeed)

[Matteo Bordin]

On Oct 31, 12:00 pm, Yannick Duchêne (Hibou57)
<yannick_duch...@yahoo.fr> wrote:
> Le Sun, 31 Oct 2010 11:47:46 +0100, J-P. Rosen <ro...@adalog.fr> a écrit:
>
> >> UML on the other hand is a meta-language, so nobody stops you from
> >> expressing a HOOD design in UML notation with the appropriate  
> >> stereotypes.
>
> > True. The STOOD tool (restricted version freely downloadable) can
> > represent your design with traditional HOOD diagrams or UML diagrams.
>
> Elydis Softwarehttp://www.ellidiss.com/products.asp
> There is indeed a download page herehttp://www.ellidiss.com/downloads.asp
> but no mention of any trial version. Will register anyway.
>
> They seems involved in the aforementioned HRT-UML by the way (see first  
> link).
>

I personally don't see much sense in trying to semantically merge the
HOOD modeling approach (based on the notion of static "class"
instance) with the UML one (based on the dichotomy between classifiers
[classes] and typed elements [objects and class members]). Decorating
a UML class with an <<HOOD_Active_Object>> stereotype (or whatever)
does not mean much: a UML class needs to be instantiated to have a run-
time executable semantics, while a HOOD object doesn't. This
inconsistency has a lot of repercussions on several model elements and
on several levels.

Of course, you can always come up with a GUI intelligent enough to
hide the semantic inconsistency between the two languages, but the
underlying UML model (supposing models are serialized to UML and not
to proprietary formats) will still contain such inconsistencies -
forcing you to have dedicated model validator, analysis tools and code
generators.

Re: Comparison : Ada and UML (comparison… indeed)

[J-P. Rosen]

Le 09/11/2010 12:04, Matteo Bordin a �crit :

> I personally don't see much sense in trying to semantically merge the
> HOOD modeling approach (based on the notion of static "class"
> instance) with the UML one (based on the dichotomy between classifiers
> [classes] and typed elements [objects and class members]).
There is no UML modeling approach. UML is a language (used by various
modelling approaches, granted). If the purpose of UML is to reduce the
confusion by standardizing boxes and arrows, why not use it on HOOD? It
will make a HOOD design more understandable to people who are not used
to HOOD diagrams.

> Decorating
> a UML class with an <<HOOD_Active_Object>> stereotype (or whatever)
> does not mean much: a UML class needs to be instantiated to have a run-
> time executable semantics, while a HOOD object doesn't. This
> inconsistency has a lot of repercussions on several model elements and
> on several levels.
UML claims that it can represent any design method, thanks to stereotypes...

> Of course, you can always come up with a GUI intelligent enough to
> hide the semantic inconsistency between the two languages,
HOOD is not a language, but primarily a design method. Diagrams are just
used as a representation of the result of a design.

> but the
> underlying UML model (supposing models are serialized to UML and not
> to proprietary formats)
Note that HOOD defines a portable, open format for representing HOOD
designs - and it did that long before UML.

-- 
---------------------------------------------------------
           J-P. Rosen (rosen@adalog.fr)
Adalog a d�m�nag� / Adalog has moved:
2 rue du Docteur Lombard, 92441 Issy-les-Moulineaux CEDEX
Tel: +33 1 45 29 21 52, Fax: +33 1 45 29 25 00

Re: Comparison : Ada and UML (comparison… indeed)

[Matteo Bordin]

> > I personally don't see much sense in trying to semantically merge the
> > HOOD modeling approach (based on the notion of static "class"
> > instance) with the UML one (based on the dichotomy between classifiers
> > [classes] and typed elements [objects and class members]).
>
> There is no UML modeling approach. UML is a language (used by various
> modelling approaches, granted). If the purpose of UML is to reduce the
> confusion by standardizing boxes and arrows, why not use it on HOOD? It
> will make a HOOD design more understandable to people who are not used
> to HOOD diagrams.
>
> > Decorating
> > a UML class with an <<HOOD_Active_Object>> stereotype (or whatever)
> > does not mean much: a UML class needs to be instantiated to have a run-
> > time executable semantics, while a HOOD object doesn't. This
> > inconsistency has a lot of repercussions on several model elements and
> > on several levels.
>
> UML claims that it can represent any design method, thanks to stereotypes...

I think that what you really mean is to support the HOOD method using
UML. But to do so you would need to define a mapping between the
elements which the HOOD method requires to manipulate and UML
elements. This is not necessary straightforward/natural.

Also note that UML profiles allow to extend/constraint the UML
metamodel, but cannot contradict it.

> > Of course, you can always come up with a GUI intelligent enough to
> > hide the semantic inconsistency between the two languages,
>
> HOOD is not a language, but primarily a design method. Diagrams are just
> used as a representation of the result of a design.

You're right, sometimes I forgot that HOOD "models" does not have any
semantics... whatever UML box and arrow you pick, it will work...

> > but the
> > underlying UML model (supposing models are serialized to UML and not
> > to proprietary formats)
>
> Note that HOOD defines a portable, open format for representing HOOD
> designs - and it did that long before UML.

I was referring to the fact that a UML-like graphical front-end does
not imply a UML-compliant back-end semantics. Visio or PowerPoint may
be used to provide as UML front-end, but they do not produce any
usable model. BTW, HRT-UML (like HRT-UML/RCM) was not compliant with
UML neither in the graphical front-end nor back-end.

Re: Comparison : Ada and UML (comparison… indeed)

[Simon Wright]

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

> a UML class needs to be instantiated to have a run-time executable
> semantics

I don't understand this?

There has to be some sort of profile (both in allowable UML constructs
and what they mean in terms of program execution). "If you model like
_this_ and generate code using _our generator_, the result will work
like _that_".

Re: Comparison : Ada and UML (comparison… indeed)

[J-P. Rosen]

Le 09/11/2010 18:44, Matteo Bordin a �crit :

>> UML claims that it can represent any design method, thanks to stereotypes...
> 
> I think that what you really mean is to support the HOOD method using
> UML. But to do so you would need to define a mapping between the
> elements which the HOOD method requires to manipulate and UML
> elements. This is not necessary straightforward/natural.
You seem to think about using a UML tool to design in HOOD. I was more
thinking of using UML notation in a HOOD tool (as STOOD does optionnaly)

> You're right, sometimes I forgot that HOOD "models" does not have any
> semantics... whatever UML box and arrow you pick, it will work...
I guess you mean UML models use with HOOD... HOOD objects definitely
have semantics!

-- 
---------------------------------------------------------
           J-P. Rosen (rosen@adalog.fr)
Adalog a d�m�nag� / Adalog has moved:
2 rue du Docteur Lombard, 92441 Issy-les-Moulineaux CEDEX
Tel: +33 1 45 29 21 52, Fax: +33 1 45 29 25 00

Re: Comparison : Ada and UML (comparison… indeed)

[Matteo Bordin]

On Nov 9, 10:17 pm, "J-P. Rosen" <ro...@adalog.fr> wrote:
> Le 09/11/2010 18:44, Matteo Bordin a écrit :
>
> >> UML claims that it can represent any design method, thanks to stereotypes...
>
> > I think that what you really mean is to support the HOOD method using
> > UML. But to do so you would need to define a mapping between the
> > elements which the HOOD method requires to manipulate and UML
> > elements. This is not necessary straightforward/natural.
>
> You seem to think about using a UML tool to design in HOOD. I was more
> thinking of using UML notation in a HOOD tool (as STOOD does optionnaly)
>
> > You're right, sometimes I forgot that HOOD "models" does not have any
> > semantics... whatever UML box and arrow you pick, it will work...
>
> I guess you mean UML models use with HOOD... HOOD objects definitely
> have semantics!

Either HOOD is a language with an abstract syntax (a metamodel), or it
is not. It was you the one who said "HOOD is not a language".

Let's assume for a moment that HOOD has a semantics. If you want to
use a UML tool to apply the HOOD design methods, then you need to map
the HOOD abstract syntax (the metamodel) to the UML abstract syntax
(the UML metamodel). The mapping to the UML concrete syntax comes for
free because in UML the abstract and concrete syntax are coupled.

You suggest to use the UML notation on a HOOD tool to exploit the HOOD
method with a UML notation. This implies mapping the UML concrete (and
thus abstract) syntax to HOOD concepts. Again, this requires a
semantic mapping between the two languages. It is on the
appropriateness of this mapping that I have doubts. For whatever
reason you seem to perceive this as a critique to HOOD.

Anyway, you cite STOOD as an exemplary tool. Please go here (http://
www.hurray.isep.ipp.pt/ae2006/pdfs/Tuesday/Vendor_Sessions/ellidiss.pdf)
at look at slide 8. Do you understand that someone made a decision of
mapping the notion of HOOD object to UML.Property? Do you understand
that this is a semantic mapping meaning implying that a HOOD object
and a UML.Property are equivalent? What is the rationale behind this
decision? For example, HRT-UML originally made a different choice.
This is the point: in STOOD the use of UML/AADL/HOOD/HRT-HOOD is
purely a skin with no semantic meaning at all. The abstract syntax is
always the same; what changes is just the concrete syntax. Note that
the same comments can be made for the AADL view...

Re: Comparison : Ada and UML (comparison… indeed)

[Matteo Bordin]

On Nov 9, 9:02 pm, Simon Wright <si...@pushface.org> wrote:
> Matteo Bordin <matteo.bor...@gmail.com> writes:
> > a UML class needs to be instantiated to have a run-time executable
> > semantics
>
> I don't understand this?

What I meant to say is that a UML class is not an instance. This was
related to the discussion about HOOD and the problem of mapping the
notion of HOOD object to a UML element. Mapping it to a class is
controversial because the two elements are really different: a UML
class needs to be instantiated, a HOOD object is already a "runnable"
element.

> There has to be some sort of profile (both in allowable UML constructs
> and what they mean in terms of program execution). "If you model like
> _this_ and generate code using _our generator_, the result will work
> like _that_".

Sure, but this way you may risk to model your application based on a
precise code generation strategy, possibly loosing portability and
platform-independence of models.

Re: Comparison : Ada and UML (comparison… indeed)

[J-P. Rosen]

Le 10/11/2010 10:23, Matteo Bordin a �crit :
>> I guess you mean UML models use with HOOD... HOOD objects definitely
>> have semantics!
> 
> Either HOOD is a language with an abstract syntax (a metamodel), or it
> is not. It was you the one who said "HOOD is not a language".
Yes. HOOD is a design method; it defines precise steps that guide you
from a specification to an implementation.

Your design decisions and refinments are captured in what is called the
"textual form"; this is a standardized language, defined by a syntax.
There is also a graphical form, which is basically an abstraction of the
textual form, to help the reader to understand more easily the general
organization of the design.

HOOD defines its own shapes for the graphical form; using UML "shapes"
can make a HOOD design more readable for those who already know UML, and
that's what STOOD can do. I didn't mean anything else.
[...]

> It is on the
> appropriateness of this mapping that I have doubts. For whatever
> reason you seem to perceive this as a critique to HOOD.
No, just that stating that HOOD had no semantic. You may not have meant
it, but it is always dangerous to leave that kind of statement publicly
on the internet...

> [...]
> This is the point: in STOOD the use of UML/AADL/HOOD/HRT-HOOD is
> purely a skin with no semantic meaning at all. The abstract syntax is
> always the same; what changes is just the concrete syntax. Note that
> the same comments can be made for the AADL view...
For sure. HOOD in UML notation is still HOOD...

-- 
---------------------------------------------------------
           J-P. Rosen (rosen@adalog.fr)
Adalog a d�m�nag� / Adalog has moved:
2 rue du Docteur Lombard, 92441 Issy-les-Moulineaux CEDEX
Tel: +33 1 45 29 21 52, Fax: +33 1 45 29 25 00

Re: Comparison : Ada and UML (comparison… indeed)

[Simon Wright]

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

> On Nov 9, 9:02 pm, Simon Wright <si...@pushface.org> wrote:
>> Matteo Bordin <matteo.bor...@gmail.com> writes:
>> > a UML class needs to be instantiated to have a run-time executable
>> > semantics
>>
>> I don't understand this?
>
> What I meant to say is that a UML class is not an instance. This was
> related to the discussion about HOOD and the problem of mapping the
> notion of HOOD object to a UML element. Mapping it to a class is
> controversial because the two elements are really different: a UML
> class needs to be instantiated, a HOOD object is already a "runnable"
> element.

So a UML class is something similar to an Ada type, in that you need to
create an object of the type in order for anything to happen. Not sure
that 'instantiate' is the right word for this process, maybe it has this
specific meaning in the UML world?

Would a HOOD model of an aircraft with 4 engines have one HOOD object
for each engine?

>> There has to be some sort of profile (both in allowable UML constructs
>> and what they mean in terms of program execution). "If you model like
>> _this_ and generate code using _our generator_, the result will work
>> like _that_".
>
> Sure, but this way you may risk to model your application based on a
> precise code generation strategy, possibly loosing portability and
> platform-independence of models.

Even a PIM has to have pretty precise semantics. I suppose I should have
said, "If you model like _this_ and generate code using _our
*standard-conformng* generator_, the result will work like _that_".

If that's not so, the platform-independence isn't worth much.

Re: Comparison : Ada and UML (comparison… indeed)

[Vinzent Hoefler]

On Wed, 10 Nov 2010 22:31:06 +0100, Simon Wright <simon@pushface.org> wrote:

> Would a HOOD model of an aircraft with 4 engines have one HOOD object
> for each engine?

If they are of the same type (which I suppose they would be), they
would become four instantiations of a "Generic_Engine", I'd say.

So, yes, there will be one HOOD object for each engine.


Vinzent.

-- 
There is no signature.

Re: Comparison : Ada and UML (comparison… indeed)

[J-P. Rosen]

Le 10/11/2010 22:43, Vinzent Hoefler a écrit :
> On Wed, 10 Nov 2010 22:31:06 +0100, Simon Wright <simon@pushface.org>
> wrote:
> 
>> Would a HOOD model of an aircraft with 4 engines have one HOOD object
>> for each engine?
> 
> If they are of the same type (which I suppose they would be), they
> would become four instantiations of a "Generic_Engine", I'd say.
> 
> So, yes, there will be one HOOD object for each engine.
> 
1) In HOOD 3.1, yes. There was support for generics and similar objects,
unfortunately called "classes". This comes from the fact that HOOD
started from an abstract state machines approach.

2) HOOD 4 added support for abstract data types and classes (with
inheritance).

-- 
---------------------------------------------------------
           J-P. Rosen (rosen@adalog.fr)
Adalog a déménagé / Adalog has moved:
2 rue du Docteur Lombard, 92441 Issy-les-Moulineaux CEDEX
Tel: +33 1 45 29 21 52, Fax: +33 1 45 29 25 00

Re: Comparison : Ada and UML (comparison… indeed)

[Matteo Bordin]

> >> There has to be some sort of profile (both in allowable UML constructs
> >> and what they mean in terms of program execution). "If you model like
> >> _this_ and generate code using _our generator_, the result will work
> >> like _that_".
>
> > Sure, but this way you may risk to model your application based on a
> > precise code generation strategy, possibly loosing portability and
> > platform-independence of models.
>
> Even a PIM has to have pretty precise semantics. I suppose I should have
> said, "If you model like _this_ and generate code using _our
> *standard-conformng* generator_, the result will work like _that_".
>
> If that's not so, the platform-independence isn't worth much.

Right: model semantics shall not be dependent on the code generator
otherwise model-based verification results may not be valid anymore if
you change code generator.

Example: HRT-HOOD (an extension of HOOD 3.1 for real-time systems) was
conceived as a language/method to design *Ada* systems - i.e. its
dynamic semantics was defined in terms of Ada constructs. The language/
method and its mapping to Ada were in fact inseparable. Now, suppose
you perform some kind of real-time analysis on your HRT-HOOD model: is
it still valid if you change code generator and/or target language?
Possibly not, meaning that you may need to update your model-based
verification tool to cope with your new code generator. This is the
main risk of coupling modeling language semantics with code gen
strategy.

The dynamic semantics of HRT-UML/RCM, the successor of HRT-UML, was
based on the abstract notion of Ravenscar Computational Model in the
hope that the model-based real-time analysis would be independent of
the code generator - of course assuming the code generator was able to
generate code conforming to the HRT-UML/RCM semantics.

Re: Comparison : Ada and UML (comparison… indeed)

[Matteo Bordin]

On Nov 11, 8:40 am, "J-P. Rosen" <ro...@adalog.fr> wrote:
> Le 10/11/2010 22:43, Vinzent Hoefler a écrit :> On Wed, 10 Nov 2010 22:31:06 +0100, Simon Wright <si...@pushface.org>
> > wrote:
>
> >> Would a HOOD model of an aircraft with 4 engines have one HOOD object
> >> for each engine?
>
> > If they are of the same type (which I suppose they would be), they
> > would become four instantiations of a "Generic_Engine", I'd say.
>
> > So, yes, there will be one HOOD object for each engine.
>
> 1) In HOOD 3.1, yes. There was support for generics and similar objects,
> unfortunately called "classes". This comes from the fact that HOOD
> started from an abstract state machines approach.
>
> 2) HOOD 4 added support for abstract data types and classes (with
> inheritance).

Do you mean that the HOOD semantics says that:
- HOOD active objects (like an "Engine") may have multiple instancies
and
- if you modify the prototype instance (to use a UML term: the class)
of "Engine", then all of its instancies are modified accordingly
?

I think this is what Simon is asking.

Re: Comparison : Ada and UML (comparison… indeed)

[Matteo Bordin]

On Nov 11, 8:40 am, "J-P. Rosen" <ro...@adalog.fr> wrote:
> Le 10/11/2010 22:43, Vinzent Hoefler a écrit :> On Wed, 10 Nov 2010 22:31:06 +0100, Simon Wright <si...@pushface.org>
> > wrote:
>
> >> Would a HOOD model of an aircraft with 4 engines have one HOOD object
> >> for each engine?
>
> > If they are of the same type (which I suppose they would be), they
> > would become four instantiations of a "Generic_Engine", I'd say.
>
> > So, yes, there will be one HOOD object for each engine.
>
> 1) In HOOD 3.1, yes. There was support for generics and similar objects,
> unfortunately called "classes". This comes from the fact that HOOD
> started from an abstract state machines approach.
>
> 2) HOOD 4 added support for abstract data types and classes (with
> inheritance).

Do you mean that the HOOD semantics says that:
- HOOD active objects (like an "Engine") may have multiple instancies
and
- if you modify the prototype instance (to use a UML term: the class)
of "Engine", then all of its instancies are modified accordingly
?

I think this is what Simon is asking.

Re: Comparison : Ada and UML (comparison… indeed)

[J-P. Rosen]

Le 12/11/2010 17:37, Matteo Bordin a �crit :

> Do you mean that the HOOD semantics says that:
> - HOOD active objects (like an "Engine") may have multiple instancies
> and
> - if you modify the prototype instance (to use a UML term: the class)
> of "Engine", then all of its instancies are modified accordingly
> ?
> 
> I think this is what Simon is asking.
Even in HOOD 3.1, you could declare an object with a name like
Engine(1..4), meaning there are actually 4 instances of it. No named
type though.

Full fledged HADT and classes were added in HOOD 4, with the usual
semantics.

-- 
---------------------------------------------------------
           J-P. Rosen (rosen@adalog.fr)
Adalog a d�m�nag� / Adalog has moved:
2 rue du Docteur Lombard, 92441 Issy-les-Moulineaux CEDEX
Tel: +33 1 45 29 21 52, Fax: +33 1 45 29 25 00