Body: <p>Bit of history: The <a href="https://www.cs.bris.ac.uk/~dave/basic.pdf" rel="nofollow noreferrer">Darmouth Basic Manual (1964)</a> follows a common order of exposition: expressions, variables, constants, assignment, tests/loops; calling subprograms being considered an "advanced topic" (well, the last thing, after using tables).</p>
  
  <p>This reminds me of the first version of Fortran, (see <a href="http://www-03.ibm.com/ibm/history/ibm100/us/en/icons/fortran/breakthroughs/" rel="nofollow noreferrer">preliminary report of 1954</a>) which had no user-defined subroutines/functions at all.</p>
  
  <p>So teaching the importance of decomposing code into smaller (reusable) units was not considered a major priority.  And as a consequence we had generations of students who wrote functions/subprograms only under coercion.</p>
  
  <p>There's a <a href="http://www.iaras.org/iaras/home/caijels/a-procedural-way-of-teaching-procedural-programming-language" rel="nofollow noreferrer">recent paper</a> (2016) about a procedure-oriented approach to teaching programming in C ; the question is, were there similar approaches in the sixties ot seventies?</p>
  
  <p><strong>Question</strong>: Was this order of topics standard in the 1960s for imperative programming?  Bonus points if you can directly link to textbooks that demonstrate your answer.</p>
  
  <p><strong>Remark</strong>: Counter-examples will certainly by found in the presentation of functional and LOGO programming. </p>
  
  <ul>
  <li><p>In <a href="http://dspace.mit.edu/handle/1721.1/5835" rel="nofollow noreferrer">Teaching Children Thinking</a>, by S. Papers, 1971, page 5-2 it is shown that after demonstration of <code>FORWARD 100</code> and <code>ROTATELEFT 90</code>, the student can write the first (endless recursive) procedure</p>
  
  <pre><code>TO CIRCLE
     FORWARD 100
     ROTATELEFT 90
     CIRCLE
  END
  </code></pre></li>
  </ul>
  
  <p>Here the procedural aspect comes even before variables, expressions etc.</p>
  
  <ul>
  <li>In the famous <a href="https://www.web.mit.edu/alexmv/6.037/sicp.pdf" rel="nofollow noreferrer">SICP book</a> (not for innocent children) using Scheme, definition of functions come after expressions and before IF etc.  But it comes much later (1985).</li>
  </ul>
  
  <p><strong>Partial answer:</strong>  the <a href="http://www.dahlan.web.id/files/ebooks/ACM%20Curricula%20Recom%20for%20CS%201983.pdf" rel="nofollow noreferrer">ACM Curricula Recommendations for Computer Science, vol 1</a> (1983) contains the 1968's course contents and outlines. In course B1 (page 21) Introduction to Computing :</p>
  
  <ul>
  <li>"This outline reflects an order in which the material might be presented [...]"</li>
  <li><p>"2. Basic Programming. Constants identifiers, variables, subscripts, operations, functions, and expressions. Declarations, substitution statements, input-output statements, conditional statements, and complete programs"</p></li>
  <li><p>"3. Program structure. Procedures, functions, subroutine calling, and formal-actual parameter association. Statement grouping, nested structure of expressions and statements, local versus global variables [....]"</p></li>
  </ul>
  
  <p>The book <a href="https://archive.org/stream/fortranprimer00orga#page/88/mode/2up" rel="nofollow noreferrer">A Fortran Primer</a> (1963) by E.I. Organick starts explaining subroutines and functions at page 89. Last section before  "12. Preparation of Punch Card Program Decks". Can be considered as a good textbook for beginners, not a Fortran reference manual. Read it if you miss good old time flowcharts.</p>
  
Comments.ContentLicense: CC BY-SA 3.0
Comments.CreationDate: 2017-08-10T12:48:00.743Z
Comments.Text: I'm voting to close this question as off-topic because the teaching practice of the 60's has little bearing on teaching today. The question can be answered by the OP with a google search.
Comments.UserDisplayName: Buffy
Comments.ContentLicense: CC BY-SA 3.0
Comments.CreationDate: 2017-08-10T12:51:43.957Z
Comments.Text: Note that much of what appears in "early" textbooks using some language are heavily influenced by the practice of programmers using _earlier_ languages. For example, early Fortran books were very much assembly language like. Subroutines weren't used for problem decomposition but only to capture "common computations." This was likely due to the relative difficulty of setting up subroutines in the assembly languages of the day. Early Pascal textbooks were very "Fortran-like". It took a while to learn the new way of thinking.
Comments.UserDisplayName: Buffy
Comments.ContentLicense: CC BY-SA 3.0
Comments.CreationDate: 2017-08-10T13:32:05.583Z
Comments.Text: @Michel, I have modified your question to pull it within the rules of SE (*list questions* must contain criteria to differentiate stronger from weaker answers).  I tried to make sure that it would still answer your original question; feel free to roll back the edit if I have misunderstood your intentions.
Comments.UserDisplayName: Ben I.
Comments.ContentLicense: CC BY-SA 3.0
Comments.CreationDate: 2017-08-11T06:05:35.903Z
Comments.Text: @buffy what seems the logical order of exposition in today's textbooks is heavily influenced by the quantity of textbooks published before on a similar subject.
Comments.UserDisplayName: Michel Billaud
Comments.ContentLicense: CC BY-SA 3.0
Comments.CreationDate: 2017-08-13T16:51:42.387Z
Comments.Text: An adequate answer would be scan images of old textbook tables of contents, for example.  Definitely not easy to find by a google search for obsolete books of the 60's, if you ever tried...
Comments.UserDisplayName: Michel Billaud
Comments.ContentLicense: CC BY-SA 3.0
Comments.CreationDate: 2017-08-13T19:28:49.913Z
Comments.Text: The way it's written now, you've answered your own question.  If that's not the case, then it's unclear what you're asking.
Comments.UserDisplayName: Ben I.
Comments.ContentLicense: CC BY-SA 3.0
Comments.CreationDate: 2017-08-14T08:42:48.873Z
Comments.Text: Sorry if  it's not clear enough : my answer states that I've  not found any example of "procedural first" approach in imperative programming in "good old times" (say before 1980) yet.  
  Before I conclude there is none, I'd like to check from textbooks from that period how they ordered the concepts. In the late seventies I read all the programming books (fortran) in french from the university library, probably representative for what was published at the time (not very good books), they were all on the same model. 
  So I'd like to check for textbooks in english.
Comments.UserDisplayName: Michel Billaud
Comments.ContentLicense: CC BY-SA 3.0
Comments.CreationDate: 2017-08-14T13:09:52.030Z
Comments.Text: @MichelBillaud Absent scanning _every_ textbook ever written in that time frame, it is impossible to prove it didn't exist. That's a classic problem in many area: proving the non-existence of something.
Comments.UserDisplayName: Gypsy Spellweaver
Comments.ContentLicense: CC BY-SA 3.0
Comments.CreationDate: 2017-08-14T17:26:36.857Z
Comments.Text: @GypsySpellweaver Of course I'm not interested at *every* textbook. Only some which would attest the existence of a real procedural approach. It doesn't seem impossible that someone still remembers what they learned/taught at the time. And maybe keeped the books.
Comments.UserDisplayName: Michel Billaud
Comments.ContentLicense: CC BY-SA 3.0
Comments.CreationDate: 2017-08-14T17:39:09.217Z
Comments.Text: I'm guessing that _procedural first_ approach is intended to mean teaching how to use procedures before learning how to use a `while` loop, for example. If such is the case, it seems impossible as the procedures need the smaller building blocks just as much as the main program does.
Comments.UserDisplayName: Gypsy Spellweaver
Comments.ContentLicense: CC BY-SA 3.0
Comments.CreationDate: 2017-08-14T17:48:48.057Z
Comments.Text: You dont even need variables. Consider the task of drawing a picture from a number of calls (rect, ellipse, etc) to primitive functions. You will probably appreciate a linguistic support to the idea of splitting the work into parts : functions. Even void and without parameters, at the beginning. Is'nt it more appropriate  than groups of statements separated by comments ?
Comments.UserDisplayName: Michel Billaud
Tags: <resource-request><resource-information><programming-paradigms>
Title: Historical standard order of topics in imperative programming textbooks
ThreadText: # Historical standard order of topics in imperative programming textbooks
  
  (Asked by: username_0 on 2017-08-10)
  
  Bit of history: The [Darmouth Basic Manual (1964)](https://www.cs.bris.ac.uk/~dave/basic.pdf) follows a common order of exposition: expressions, variables, constants, assignment, tests/loops; calling subprograms being considered an "advanced topic" (well, the last thing, after using tables).
  
  This reminds me of the first version of Fortran, (see [preliminary report of 1954](http://www-03.ibm.com/ibm/history/ibm100/us/en/icons/fortran/breakthroughs/)) which had no user-defined subroutines/functions at all.
  
  So teaching the importance of decomposing code into smaller (reusable) units was not considered a major priority. And as a consequence we had generations of students who wrote functions/subprograms only under coercion.
  
  There's a [recent paper](http://www.iaras.org/iaras/home/caijels/a-procedural-way-of-teaching-procedural-programming-language) (2016) about a procedure-oriented approach to teaching programming in C ; the question is, were there similar approaches in the sixties ot seventies?
  
  **Question**: Was this order of topics standard in the 1960s for imperative programming? Bonus points if you can directly link to textbooks that demonstrate your answer.
  
  **Remark**: Counter-examples will certainly by found in the presentation of functional and LOGO programming.
  
  * In [Teaching Children Thinking](http://dspace.mit.edu/handle/1721.1/5835), by S. Papers, 1971, page 5-2 it is shown that after demonstration of `FORWARD 100` and `ROTATELEFT 90`, the student can write the first (endless recursive) procedure
  
    ```
    TO CIRCLE
       FORWARD 100
       ROTATELEFT 90
       CIRCLE
    END
  
    ```
  
  Here the procedural aspect comes even before variables, expressions etc.
  
  * In the famous [SICP book](https://www.web.mit.edu/alexmv/6.037/sicp.pdf) (not for innocent children) using Scheme, definition of functions come after expressions and before IF etc. But it comes much later (1985).
  
  **Partial answer:** the [ACM Curricula Recommendations for Computer Science, vol 1](http://www.dahlan.web.id/files/ebooks/ACM%20Curricula%20Recom%20for%20CS%201983.pdf) (1983) contains the 1968's course contents and outlines. In course B1 (page 21) Introduction to Computing :
  
  * "This outline reflects an order in which the material might be presented [...]"
  * "2. Basic Programming. Constants identifiers, variables, subscripts, operations, functions, and expressions. Declarations, substitution statements, input-output statements, conditional statements, and complete programs"
  * "3. Program structure. Procedures, functions, subroutine calling, and formal-actual parameter association. Statement grouping, nested structure of expressions and statements, local versus global variables [....]"
  
  The book [A Fortran Primer](https://archive.org/stream/fortranprimer00orga#page/88/mode/2up) (1963) by E.I. Organick starts explaining subroutines and functions at page 89. Last section before "12. Preparation of Punch Card Program Decks". Can be considered as a good textbook for beginners, not a Fortran reference manual. Read it if you miss good old time flowcharts.
  
  **Tags:** resource-request, resource-information, programming-paradigms
  
  > **Comments:**
  > **username_1**: I'm voting to close this question as off-topic because the teaching practice of the 60's has little bearing on teaching today. The question can be answered by the OP with a google search.  
  > **username_1**: Note that much of what appears in "early" textbooks using some language are heavily influenced by the practice of programmers using _earlier_ languages. For example, early Fortran books were very much assembly language like. Subroutines weren't used for problem decomposition but only to capture "common computations." This was likely due to the relative difficulty of setting up subroutines in the assembly languages of the day. Early Pascal textbooks were very "Fortran-like". It took a while to learn the new way of thinking.  
  > **username_2**: @username_0, I have modified your question to pull it within the rules of SE (*list questions* must contain criteria to differentiate stronger from weaker answers).  I tried to make sure that it would still answer your original question; feel free to roll back the edit if I have misunderstood your intentions.  
  > **username_0**: @username_1 what seems the logical order of exposition in today's textbooks is heavily influenced by the quantity of textbooks published before on a similar subject.  
  > **username_0**: An adequate answer would be scan images of old textbook tables of contents, for example.  Definitely not easy to find by a google search for obsolete books of the 60's, if you ever tried...  
  > **username_2**: The way it's written now, you've answered your own question.  If that's not the case, then it's unclear what you're asking.  
  > **username_0**: Sorry if  it's not clear enough : my answer states that I've  not found any example of "procedural first" approach in imperative programming in "good old times" (say before 1980) yet.   Before I conclude there is none, I'd like to check from textbooks from that period how they ordered the concepts. In the late seventies I read all the programming books (fortran) in french from the university library, probably representative for what was published at the time (not very good books), they were all on the same model.  So I'd like to check for textbooks in english.  
  > **username_3**: @username_0 Absent scanning _every_ textbook ever written in that time frame, it is impossible to prove it didn't exist. That's a classic problem in many area: proving the non-existence of something.  
  > **username_0**: @username_3 Of course I'm not interested at *every* textbook. Only some which would attest the existence of a real procedural approach. It doesn't seem impossible that someone still remembers what they learned/taught at the time. And maybe keeped the books.  
  > **username_3**: I'm guessing that _procedural first_ approach is intended to mean teaching how to use procedures before learning how to use a `while` loop, for example. If such is the case, it seems impossible as the procedures need the smaller building blocks just as much as the main program does.  
  > **username_0**: You dont even need variables. Consider the task of drawing a picture from a number of calls (rect, ellipse, etc) to primitive functions. You will probably appreciate a linguistic support to the idea of splitting the work into parts : functions. Even void and without parameters, at the beginning. Is'nt it more appropriate  than groups of statements separated by comments ?  
  
  ---
  
  ## 0 answers
  
  