[W/K] :: COME FROM

  COME FROM n. A semi-mythical language construct dual to the `go to';
     `COME FROM'  would cause the referenced label to act as a sort of
     trapdoor, so that if the program ever reached it control would quietly
     and automagically be transferred to the statement following the `COME
     FROM'. `COME FROM' was first proposed in R. Lawrence Clark's "A
     Linguistic Contribution to GOTO-less programming", which appeared in a
     1973 Datamation issue (and was reprinted in the April 1984 issue of
     "Communications of the ACM"). This parodied the then-raging `structured
     programming' holy wars (see considered harmful). Mythically, some
     variants are the `assigned COME FROM' and the `computed COME FROM'
     (parodying some nasty control constructs in FORTRAN and some extended
     BASICs). Of course, multi-tasking (or non-determinism) could be
     implemented by having more than one `COME FROM' statement coming from
     the same label.
  
     In some ways the FORTRAN `DO' looks like a `COME FROM' statement.
     After the terminating statement number/`CONTINUE' is reached, control
     continues at the statement following the DO. Some generous FORTRANs
     would allow arbitrary statements (other than `CONTINUE') for the
     statement, leading to examples like:
  
          DO 10 I=1,LIMIT
    C imagine many lines of code here, leaving the
    C original DO statement lost in the spaghetti...
          WRITE(6,10) I,FROB(I)
     10   FORMAT(1X,I5,G10.4)
    
     in which the trapdoor is just after the statement labeled 10. (This is
     particularly surprising because the label doesn't appear to have
     anything to do with the flow of control at all!)
  
     While sufficiently astonishing to the unsuspecting reader, this form
     of `COME FROM' statement isn't completely general. After all, control
     will eventually pass to the following statement. The implementation of
     the general form was left to Univac FORTRAN, ca. 1975 (though a roughly
     similar feature existed on the IBM 7040 ten years earlier). The
     statement `AT 100' would perform a `COME FROM 100'. It was intended
     strictly as a debugging aid, with dire consequences promised to anyone
     so deranged as to use it in production code. More horrible things had
     already been perpetrated in production languages, however; doubters need
     only contemplate the `ALTER' verb in COBOL.
  
     `COME FROM' was supported under its own name for the first time 15
     years later, in C-INTERCAL (see INTERCAL, retrocomputing);
     knowledgeable observers are still reeling from the shock.
  
  

  COME FROM
       
           A semi-mythical language construct dual to the
          "go to"; "COME FROM"  would cause the referenced label
          to act as a sort of trapdoor, so that if the program ever
          reached it, control would quietly and automagically be
          transferred to the statement following the "COME FROM".
       
          "COME FROM" was first proposed in R.L. Clark's "A Linguistic
          Contribution to GOTO-less programming", which appeared in a
          1973 Datamation issue (and was reprinted in the April 1984
          issue of "{Communications of the ACM").  This parodied the
          then-raging "{structured programming" holy wars (see
          considered harmful).
       
          Mythically, some variants are the "assigned COME FROM" and the
          "computed COME FROM" (parodying some nasty control constructs
          in Fortran and some extended BASICs).  Of course,
          multitasking (or nondeterminism) could be implemented by
          having more than one "COME FROM" statement coming from the
          same label.
       
          In some ways the Fortran "DO" looks like a "COME FROM"
          statement.  After the terminating statement number/"CONTINUE"
          is reached, control continues at the statement following the
          DO.  Some generous Fortrans would allow arbitrary statements
          (other than "CONTINUE") for the statement, leading to examples
          like:
       
                DO 10 I=1,LIMIT
           C imagine many lines of code here, leaving the
           C original DO statement lost in the spaghetti...
                WRITE(6,10) I,FROB(I)
           10   FORMAT(1X,I5,G10.4)
       
          in which the trapdoor is just after the statement labelled 10.
          (This is particularly surprising because the label doesn't
          appear to have anything to do with the flow of control at
          all!)
       
          While sufficiently astonishing to the unsuspecting reader,
          this form of "COME FROM" statement isn't completely general.
          After all, control will eventually pass to the following
          statement.  The implementation of the general form was left to
          Univac Fortran, ca. 1975 (though a roughly similar feature
          existed on the IBM 7040 ten years earlier).  The statement
          "AT 100" would perform a "COME FROM 100".  It was intended
          strictly as a debugging aid, with dire consequences promised
          to anyone so deranged as to use it in production code.  More
          horrible things had already been perpetrated in production
          languages, however; doubters need only contemplate the
          "{ALTER" verb in COBOL.
       
          SCL on VME mainframes has a similar language construct
          called "whenever", used like this:
       
          	 whenever x=123345 then S;
       
          Meaning whenever variable x reached the value 123345 then
          execute statement S.
       
          "COME FROM" was supported under its own name for the first
          time 15 years later, in C-INTERCAL (see INTERCAL,
          retrocomputing); knowledgeable observers are still reeling
          from the shock.
       
          [{Jargon File]
       
          (1998-04-19)