FLOW (programming language)

{{about|an educational programming language|other types of flow|Flow (disambiguation)}}

{{Infobox programming language

| name = FLOW

| screenshot =

| screenshot caption =

| paradigm = Non-structured, imperative

| designers = Jef Raskin

| released = {{Start date and age|1970}}

| dialects =

| influenced by = BASIC

}}

FLOW is an educational programming language designed by Jef Raskin in 1970 and implemented on several minicomputers in the early 1970s. The goal of the language is to make it easy to explore algorithms through a highly interactive environment. The overall language is very similar in syntax and structure to the BASIC programming language, but has a number of changes in order to make typing code easier. Most notable among these was the concept of "typing amplification", in which short strings, often a single character, were expanded by the language into the complete "unamplified" source code. Modern integrated development environments and code-oriented text editors often include a similar feature, now normally referred to as autocomplete. The beginning programmer would first create a flow chart to solve the problem. Since all of the problems involved words (rather than mathematical problems) the solution was intuitive. The flow chart would be translated into the flow programming language using a top-down, mechanical method.

History

In 1970, the English Department of the University of Kansas hosted a meeting on the use of computers in the humanities. The conference was followed by a training session that ran from June 13 to August 18, where Jef Raskin was one of several teachers involved in training other teachers basic computer skills. During this period, Raskin developed the FLOW language concept.{{sfn|Raskin|1974|p=231}}

A key design element of FLOW was the attempt to avoid syntax errors by automating the entry of the language as much as possible. For instance, if one wanted to enter the statement {{code|PRINT "10"}}, the user simply had to type {{code|P10}} and the interactive editor would expand it out as they typed. If the user entered an illegal command, it would flash on the terminal and then be automatically erased so the user was "none the worse for hitting a wrong key". They referred to this concept as "typing amplification", and noted that it had the added advantage of removing an impediment for slow typers or those with physical problems using a terminal.{{sfn|Raskin|1974|p=232}}

Lewis and Norman later referred to this concept as "gag", in that it gagged the user's input until they typed something useful. They illustrated this by recounting one of Raskin's favorite demonstrations of FLOW, where he would close his eyes and hit random keys on the terminal, building a syntactically correct, albeit meaningless, program.{{sfn|Lewis|Norman|2014|p=691}}

Another aspect of the FLOW system's approach to user interaction was its debugger. This included the command {{code|WALK}}, an analog to BASIC's {{code|RUN}} that delayed after executing each statement in a fashion similar to modern single-step systems.{{sfn|Raskin|1974|p=233}}{{sfn|Lewis|Norman|2014|p=691}}

On his return to University of California, San Diego (UCSD), Raskin was able to arrange funding from UCSD and matching funds from the National Science Foundation to purchase equipment to develop the FLOW system, a total of $76,000 ({{inflation|US|76000|1970|fmt=eq}}).{{sfn|Raskin|1974|p=234}} The initial system consisted of three Data General Nova minicomputers with 12k words of memory, several VST 1200 terminals, a Tektronix 4002 graphics terminal, and an HP 7200 plotter. In September 1973 the CPUs were updated to 32k words of memory.{{sfn|Raskin|1974|p=237}}

The first version of FLOW was programmed by Jonathan "Jon" Collins in FORTRAN for use at the summer institute. To facilitate a quick implementation (1 week), Jonathan restricted input to the first character of the command with the computer supplying the balance of the command letters. Hence, typing amplification was invented. Flow was later ported by two UCSD graduate students to Nova assembler language. Later ports included MICRO

800 assembler, BASIC and Algol.{{sfn|Raskin|1974|p=237}}

Description

=Overall organization=

Like BASIC, FLOW uses line numbers both as an editing aid as well as statement labels. Unlike most BASICs, FLOW automatically numbers programs starting at line 10 and incrementing by 10 as new lines are entered. The line numbers are formatted as three digits, so line 10 is displayed as 010. Users can also enter line numbers manually, and renumber the entire program with the {{code|NUMBER}} command.{{sfn|Raskin|1974|p=234}}

In contrast to BASIC, the {{code|RUN}} command can be instructed to stop once a given line was reached, for instance, {{code|RUN FROM FIRST LINE TO 200}}. To enter this command, the user simply types {{code|RF200}}, with the rest being "amplified" into the command line.{{sfn|Raskin|1974|p=234}}

=Syntax and capabilities=

The most obvious difference between FLOW and BASIC was that FLOW has only one variable, {{code|IT}}, and lacks mathematical operators. The language has only seven statements, all of which apply basic logic or string manipulation. There is no equivalent of the for loop either, looping is handled entirely through {{code|IF}} tests and {{code|JUMP TO}} statements.{{sfn|Raskin|1974|p=235}}

The language does not have direct user interaction like BASIC's {{code|INPUT}}, data is instead defined in FLOW's analog of BASIC's {{code|DATA}} statement, {{code|TEXT}}. {{code|TEXT IS}} defines a quote-delimited string, like {{code|TEXT IS "HELLO,WORLD"}}, which is then read character-at-a-time using the {{code|GET IT}}. {{code|IT}} is a meta-variable that contains the last read character, and can then be used in other statements, like {{code|PRINT IT}}. {{code|IT}} becomes a blank -not an empty string but a single space- when the {{code|TEXT}} is completely read.{{sfn|Raskin|1974|p=234}}

Programs can contain multiple {{code|TEXT}} statements, but unlike BASIC's {{code|DATA}} where all of the lines are considered to be one continuous block of data, only one {{code|TEXT}} statement is active at a time as they are encountered by the interpreter. In other words, if there are two {{code|TEXT}} statements in a program, they are not treated as one longer statement as is the case with {{code|DATA}}, {{code|IT}} will return a blank when it runs off the end of the active {{code|TEXT}} statement and will not return more data until the next {{code|TEXT}} statement is encountered in the code.{{sfn|Raskin|1974|p=234}}

=Statements=

From Jef Raskin's paper describing FLOW, the following statements are available in the programming language and the interactive environment:{{sfn|Raskin|1974}}

==Program statements==

:{{code|COMMENT}} - equivalent to BASIC's {{code|REM}}

:{{code|PRINT}} - as in BASIC, takes literal strings between double quotes, the {{code|IT}} variable, or {{code|ON A NEW LINE}} to print a carriage return.

:{{code|TEXT IS}} - similar to {{code|DATA}} in BASIC, but used for strings only

:{{code|GET IT}} - reads the next character from the current TEXT statement

:{{code|JUMP TO}} - equivalent to {{code|GOTO}}, always expands target lines to three digits

:{{code|IF IT IS ... JUMP TO}} - equivalent to {{code|IF...THEN}} but can perform only equality tests against {{code|IT}}

:{{code|STOP}} - used to end a program, but not required

==Interactive commands==

:{{code|RUN}} - as in BASIC but can define both the start and end lines and use meta-lines {{code|FIRST LINE}} and {{code|END}}

:{{code|WALK}} - executes the program slowly

:{{code|DISPLAY}} - equivalent to {{code|LIST}}. To list the entire program, one uses {{code|DISPLAY FROM FIRST LINE TO END}}

:{{code|ERASE}} - remove lines from a program, {{code|ERASE FROM 038 TO 140}}

:{{code|NUMBER}} - renumber the lines in the program

Example

010 COMMENT FIND IF A WORD HAS EITHER AN "F" OR A "G" IN IT

020 COMMENT BY LYRA FORET 19 OCTOBER 1971

030 COMMENT

040 COMMENT SOME TEST CASES ARE FOX, GOPHER, RAT, DOG, CAT

050 COMMENT THE RESPECTIVE ANSWERS SHOULD BE YES, YES, NO, YES, NO.

060 COMMENT

070 TEXT IS "DOG"

080 COMMENT OBTAIN A LETTER OF THE TEXT

090 GET IT

100 COMMENT CHECK FOR A BLANK WHICH INDICATES END OF WORD

110 IF IT IS " " JUMP TO 500

120 COMMENT CHECK FOR F'S OR G'S

130 IF IT IS "F" JUMP TO 200

140 IF IT IS "G" JUMP TO 200

150 COMMENT IT WAS SOME OTHER LETTER, SO GO ON TO THE NEXT CHAR. IN THE TEXT

160 JUMP TO 080

200 PRINT "THE WORD HAD AN 'F' OR A 'G' IN IT."

210 COMMENT WE ARE DONE

220 STOP

500 PRINT "THE WORD DID NOT HAVE AN 'F' OR A 'G' IN IT."

References

=Citations=

=Bibliography=

{{cite journal |first=Jef |last=Raskin |journal=Computers and the Humanities |title=FLOW: A Teaching Language for Computer Programming in the Humanities |pages=231–237 |volume=8 |number=4 |date=July 1974 |doi=10.1007/BF02402344 |s2cid=62648997 }}
{{cite encyclopedia |encyclopedia=Readings in Human-Computer Interaction: Toward the Year 2000 |editor-first=Ronald |editor-last=Baecker |title=Designing for Error |first1=Clayton |last1=Lewis |first2=Donald |last2=Norman |publisher=Elsevier |date=2014 |pages=686–697 |isbn=9780080515748 |url=https://books.google.com/books?id=KA2jBQAAQBAJ }}

External links

[https://bitbucket.org/oofoe/flow/src/default/ Flow] {{Webarchive|url=https://web.archive.org/web/20191105155433/https://bitbucket.org/oofoe/flow/src/default/ |date=2019-11-05 }}, a modern implementation of FLOW in LISP

Category:Educational programming languages

Category:BASIC programming language family