on iterative constructs  the wheel is repeatedly reinvented because it is a good idea. perhaps anson's "a generalized iterative construct and its semantics" [1] confirms that "a generalized control structure and its formal definition" [2], and the earlier "an alternative control structure and its formal definition" [3] presented good ideas. however, there are several misstatements in [1] that should be corrected.  as anson points out, [2] contained definitions of constructs equivalent to both do term and do upon. however, he is incorrect when he suggests that it emphasized do term because of efficiency considerations. by writing "there is a pragmatic justification for either definition! ", i made it clear that that was not the reason for my choice. do term has two, quite different, advantages.  (a) do term is more general. an implementation of do term may, in fact, be do upon if desired. further, a programmer using do term can achieve the effects of do upon by choosing his guards accordingly.  (b) do term, like dijkstra's do od, eases the verification of programs by maintaining independence of guarded commands. the verification procedure for such constructs as do od and do term is (1) verify that the union of the guards is true in all states where the program will be invoked; (2) verify that each guarded command, on its own, will do no wrong. for do upon the second step is complicated by the need to consider the terminating commands in the list when considering an iterating command.  anson argues that the semantics of do term are more complex. the minor syntactic difference between his two definitions is a consequence of the clumsiness of wp semantics. in the relational semantics used in [2], the change from do upon to do term meant the addition of one simple definition.  as mills' [4] has explained, programmers should not be deriving the semantics of their programs from the text as anson's analysis suggests. we do not write programs arbitrarily and then try to determine their semantics. instead, programmers should be verifying that the program they have written has the semantics that they set out to achieve. fortunately, this verification is much easier than the inductive derivation of semantics described in [1]. as explained above, verification is easier for do term than do upon.  anson suggests that a stronger weakest-precondition "seems to imply a weaker construct." on the contrary, do term can describe algorithms that cannot be described with do upon.  anson also suggests that in do term termination is more difficult to obtain. programmers can obtain the behavior that they want in either. with do term the guards may be longer. for those that want to reduce the length of the guards, [2] offered a third alternative, a deterministic construct. this construct forced left-to-right consideration of the commands. this alternative has the verification disadvantages of do upon (the guarded command semantics are not independent), but, by putting the terminating commands first, one can achieve everything that anson values in do upon. in fact, with the deterministic construct, one can often achieve guards that are shorter than they would be with do upon. do upon seems to be a compromise between do term and the deterministic construct, a compromise with some of the disadvantages of both extremes and the advantages of neither.  anson has not provided the full semantics of the constructs in question. it has been known for many years (e.g., majster [5]) that wp alone does not define the semantics of a program. two programs with the same wp can differ in their behavior in important ways. to provide a complete semantics of the constructs one must define both wp and wlp. that was one of the reasons for using a relational semantics in [2] and [3]. when i wrote [2] i deliberately chose do term over do upon because i felt that the simplicity of verification compensated for the longer guards. i also valued the ability to describe the algorithms that cannot be described with do upon. i continue to prefer the syntax used in [2]. i believe that readers who consider the facts above will make the same choice.  the discussion of these issues is made a bit academic by the four-year delay between anson's submission of his paper (which apparently coincided with the publication of [2]) and the publication of [1]. in that time a generalization of both schemes has been published as a technical report [6] and has been submitted for publication. in this generalization the decision about whether a command is iterating or terminating can be made during execution, and the semantics must be that of do term. further generalizations make the seman tics of the constructs more practical, since side-effects are accurately treated in all cases. a method for reducing the length of guards and avoiding duplicated subexpressions is also provided.  david lorge parnas