Hi Prasad,
:-) ... Let me clarify again ... :-)
- The original "until" activity do NOT match the passed semantics
description. That problem escape from eyes of most of us, including my
eyes. I am so glad that Venky caught this problem. :-) .... [ Venky
... thanks again ... :-) ]
- Regardless whether the activity is called "until" or
"repeatUntil", the
mis-matched problem still exists and the resolution still needed to be
re-discussed and re-passed ... either changing the activity name
to "doWhile" or change the description to match "until" or
"repeatUntil".
- When I changed the activity name from "until" to "repeatUntil",
it is strictly for disambiguating the syntax for XSD. The mismatched
problem was not detected at that time. And, hence, we certainly wanted
to keep "until" word in the new disambiguated activity name. And, the
"until" activity name is intepreted as "repeat ... until ..." naturally
by most of programmers and programming languages. (See more ref links
below, when I searched for "until loop").
http://www.elated.com/tutorials/programming/asp/loops/
(See "Do Until")
http://www.tldp.org/LDP/Bash-Beginners-Guide/html/sect_09_03.html
So, the true "misnomer" happened while we passed the resolution and
most of us did not read the description carefully enough (including
me).
Thanks!
Regards,
Alex Yiu
Prasad Yendluri wrote:
Alex,
Alex Yiu wrote:
Hi all,
[1]
*** Prasad: Just to clarify it is is not a misnomer.
The name of the activity was intentionally changed from <until>
to <repeatUntil>. Because, there is another optional
<until> under <onAlarm> which may appears before any
activity. That will trigger an ambiguous XSD issue. For example:
<onAlarm>
<until ... />
</onAlarm>
The ambigous schema cannot tell us whether that <until> is
supposed to match the until-expression ? or until activity.
Hence, the name of activity is changed to avoid this problem.
I understand your reason for choosing a different name than "until" to
avoid the conflict. Unfortunately it still makes it a misnomer.
"repeatUntil" does not carry the semantics of <Do..While> as the
issue 140 really called for. So as was proposed, making an "editorial"
change to replace "repeatUntil" with <doWhile> is straightforward
solution to this. This can be handled at the editorial team level IMO.
Below you are proposing that we change the semantics of the activity to
match "repeatUntil". That is not the sort of activity we agreed to add
via the resolution of issue 140. If repeatUntil is what it should be
from your perspective it needs to be a new issue.
Regards,
Prasad
I sent
out email to the editor-group and cc'ing Yaron (the proposal) to
notify about this syntax change. And, Yaron gave his silent consent
eventually, after explainning to him about this situation. You guys
digged up the editor group email list archive to verify.
[2]
Regardless whether the activity is called <repeatUntil> or
<until>, I feel comfortable with changes proposed by Venky in
general. That is: we flip the boolean condition usage as we should to
match the semantics of "until".
-----------------------
<assign>
<copy> <from> 1 </from> <to> $invVar
</to> </copy>
</assign>
<repeatUntil>
<assign>
<copy> <from> $invVar+1 </from> <to>
$invVar </to> </copy>
</assign>
<condition> $invVar >=3 </condition>
</repeatUntil>
-----------------------
The above loop will be executed twice to increase the value from 1 to 2
and then from 2 to 3.
[3]
Yes, the boolean condition is not used correctly in the original issue
resolution description to match the natural language meaning of
"until". Apart from that, it was not explicitly enough to express its
"posttest" loop semantics, even though its intention is implied in both
the issue description and the relative position of <condition>
within the activity.
To avoid any further misunderstand: I would suggest to add one more
sentence to Venky's proposal:
------------------------------------------------------------------------
Current description:
The <repeatUntil> constructs allows you to indicate the repeated
performance of a specified iterative activity. The iterative activity
will continue to be performed so long as after it executes the given
Boolean <repeatUntil> condition holds true.
Proposed Description:
The <repeatUntil> construct allows you to indicate the repeated
performance of a specified iterative activity. The iterative activity
will continue to be performed until the given Boolean
<repeatUntil> condition becomes true and the condition is
tested after the body of the loop executes. The <repeatUntil>
activity is used when ones wants the loop to execute at least once.
------------------------------------------------------------------------
*** Chris, my interpretation is: yes, executing the loop at least once
is still the semantics.
[4]
Reference Link:
"repeat .... until ... " in Pascal
http://www.taoyue.com/tutorials/pascal/pas3dc.html
I hope my suggestions and explanation makes sense to you guys.
Regards,
Alex Yiu
Khanderao Kand wrote:
"The proposed resolution called the
activity "until" but when it got incorporated into the spec it
got changed to "repeatUntil" which is a definite misnomer. "
Would it be appropriate to go back to the
recommended semantics using <while> ? Any reason for changing it?
Khanderao
We added this activity as a resolution for issue 140. The issue called
for adding an activity with the following semantics:
<scope>
activity1
<while>
<condition>bool-expr</condition>
activity1
</while>
</scope>
The intent was to permit executing at least once and repeat as long as
the condition holds true.
The proposed resolution called the activity "until" but when it got
incorporated into the spec it
got changed to "repeatUntil" which is a definite misnomer.
The intent of the issue was *not* to add an activity with "repeatUntil"
semantics.
So I suggest we fix the name of the activity to capture the semantics
appropriately than change the semantics of the activity to match
"repeatUntil".
How about <repeat> or <repeatWhile>? Either of which I
don't particularly like and the original name <until> in the
issue resolution is not good either IMO.
How about <atleastOnce>?
Regards,
Prasad
------- Original Message --------
Which is usually called do.. while. We should either rename this, or
redefine it. The current definition doesn't match the name.
Danny
Chris Keller wrote:
Hi Vinky,
I think the
idea was to create a loop that executes at least once with a test after
execution of the loop. As opposed to <while> which tests before
the loop is executed and thereby the loop code may not execute at all.
Is that still the semantics?
- Chris
From: Mehta, Vinkesh (US - Austin) [mailto:vmehta@DELOITTE.com]
Sent:
Thursday,
November 03, 2005 11:30 PM
To: ws bpel tc
Subject:
[wsbpel]
repeatUntil description issue
As we discussed
during the Nov 2nd conf. call. I would like to request opening the
following new issue:
In 6.2 the
description of <repeatUntil> is incorrect. It is opposite of the
traditional meaning of a REPEAT UNTIL construct. The expected meaning
is for the iterator to repeat *until* the boolean condition is
met(becomes true). But the description says otherwise.
------------------------------------------------------------------------
Current
description:
The
<repeatUntil> constructs allows you to indicate the repeated
performance of a specified iterative activity. The iterative activity
will continue to be performed so long as after it executes the given
Boolean <repeatUntil> condition holds true.
Proposed
Description:
The
<repeatUntil> construct allows you to indicate the repeated
performance of a specified iterative activity. The iterative activity
will continue to be performed until the given Boolean
<repeatUntil> condition becomes true.
------------------------------------------------------------------------
Regards,
-Vinky
Vinkesh O. Mehta
Deloitte
Consulting LLP
Fax: +1 512
480 1261
Mobile: + 1 512 750 2006
vmehta@deloitte.com
www.deloitte.com
400
West 15th Street, Suite 1700
Austin,
TX 78701-1648
USA
|