step, as in or , and for subroutine calls, as in to perform the entire part, or to run that single step and then return. The later syntax was useful when there were many small subroutines as they could be implemented on a single line without an associated or similar concept. Conditional branching and assignment One of the more notable syntactic features of JOSS was the concept of "statement modifiers" which controlled the operation of other statements. JOSS used this for conditional branching. In most languages, one would write something to the effect of "if this expression is true, then do this...". In JOSS, this order was reversed, and such statements took the form "do this if this is true", for instance, . CAL added some syntactic sugar to this basic concept by adding the new modifier , which, depending on context, led to more obvious code; . In JOSS, to assign the value 5 to a variable A if the value of B was larger than 10, and 0 otherwise, the code would be: Set A=5 if B>10. Set A=0 if B<=10. CAL also supported conditional expressions: A=IF B>10 THEN 5 ELSE 0 A similar modification was the statement, used to set variables as part of an if or for. It was similar in concept to the if/then/else structure, but could have any number of items. For instance,. Loops Looping in JOSS was also controlled by a modifier, the . This used somewhat obscure syntax from FORTRAN; runs a loop from 1 to 10 stepping by 2, so it would print 1,3,5,7,9. One could also supply explicit values, , or mix the two, CAL improved on JOSS' syntax by introducing the and keywords, so the equivalent code in CAL would be . In JOSS, the parenthesis around the step value was the separator for the two limits, so it could not be made optional. By separating out the limits became explicit and the was made optional as assumed to be 1; . As with JOSS, explicit values and ranges could be used; . CAL further modified the for loop by adding conditional exits, using and . For instance, or . User-defined functions JOSS allowed the user to define functions using the statement. The syntax allowed local variables to be named in the function signature; Programs could then call these functions as if they were built-in, CAL changed to ,