#[1]Sidey [2]Sidey

    * [3]Writing
    * [4]About
    * [5]Home

Why would you want more than machine language?

(a short history of the birth of assembly)

  The use of assembly language and an assembler was an idea that evolved
  at the dawn of early digital stored program computers, in the decade
  following the Second World War. [6]Richard Hamming reports an estimate
  that the use of assembly language represented a 2x improvement on
  programmer productivity [7][p. 31].

  Nonetheless, it took awhile to catch on amongst experienced
  programmers, many of whom continued to program in the earlier machine
  code. Hamming reports of these programmers dismissing assembly as
  ‘sissy stuff’ and there are legends of towering figures in computing
  being quite dismissive of it. This piece is a short historical survey
  of the early development behind initial assembly languages and samples
  some of these early reactions to it.

Programming Before Assembly

  At the dawn of assembly, the model of computing which was taking shape
  was that of the stored program computer. The ideas for the stored
  program computer sprang out of the [8]ENIAC Project and its
  shortcomings. One of the early shortcomings of the ENIAC was that it
  required significant hardware modifications each time a new program was
  run [9][p.75]. [10]John von Neumann did consulting work on this project
  and outlined the ideas for improvement from this collaboration with the
  ENIAC team in the [11]initial report on the EDVAC, though there are
  questions about who should get credit for the ideas [12][p. 24][13][p.
  77].

  One of the most important of these ideas was to organize the computer
  such that the program being executed is itself also stored in the
  computer’s memory–this way, the computer itself did not need to be
  tediously reconfigured for each new program [14][p. 75-76].

What is Assembly?

  Stored program computers understand and can execute machine code, code
  expressed in numerical form (many of the earliest computers in pure
  binary). Below is a very short snippet of a more modern version of such
  machine code:

  6689C3

  From a human’s perspective, it’s not very intuitive, and if you are not
  incredibly immersed in a specific set of machine code, it is
  meaningless (it is also not meant to be the hex code for a [15]seaish
  looking blue).

  In contrast, the below code is something a human with knowledge of
  English can get some type of idea about, even with little background.

  mov bx, ax

  The second snippet is assembly code, which is read by an assembler and
  translated into the first snippet for execution by a computer.

  In Assemblers and Loaders, an assembler is described as [16][p. 1]:

    … a translator that translates source instructions (in symbolic
    language) into target instructions (in machine language), on a one
    to one basis.

  For early stored program computers, humans had to first do this
  translation themselves before they could execute the programs. The idea
  behind assembly was to use the machine itself to translate between a
  more programmer friendly notation and the code the machine could
  understand, because computers are great at manipulating symbols at a
  high speed and precision [17][p. 168]. [18]Richard Hamming reports an
  estimate that the use of assembly language represented a 2x improvement
  on programmer productivity [19][p. 31].

The Development of Assembly on Early Stored Program Computers

  Inspired by von Neumann and the ideas in the EDVAC report, two British
  research camps started working on stored program computers at the end
  of the 1940s, leading to some of the earliest assemblers.

  [20]Andrew Booth led the ARC project out of Birbeck College, with
  [21]Kathleen Booth (born as Britten) as an assistant — Kathleen is
  credited with creating an assembler for the ‘ARC2’. Meanwhile,
  [22]Maurice Wilkes led the EDSAC project out of Cambridge with David
  Wheeler as an assistant — Wheeler is credited with creating the EDSAC’s
  assembler [23][p. 81].

  The tedium of translating human symbolic understandings of programs
  into machine-readable programs led to the early assemblers.

 The ARC Project & Kathleen Booth

  Kathleen was working with Andrew on the ARC, a specialized computer for
  calculating Fourier synteses 12-24x faster than a research student
  could do using traditional methods [24][p. 102]. After visiting von
  Neumann in Princeton, they constructed the ARC2, which was a
  [25]‘stored program computer’.

  She and her husband released a few publications about this machine in
  1947, one of which is [26]General Considerations in the Design of an
  All Purpose Electronic Digital Computer. The second, Coding For A.R.C,
  is believed to contain her [27]assembly language for the ARC2. There is
  little documented about this second report and, as far as we know,
  there is no digital copy of Coding For A.R.C.. Birbeck College only
  goes as far as to say she [28]‘developed a very early assembly
  language’.

 EDSAC & David Wheeler

  The story of David Wheeler and the EDSAC is more widely documented.

  As it goes, Maurice Wilkes led the EDSAC project (after visiting the
  United States and learning about the EDVAC) to launch a stored program
  computer at Cambridge University. The EDSAC became operational in May
  1949 [29][85]. During this project Wilkes noticed that ‘assembling’ is
  something computers are well equipped to do; he put David Wheeler on
  this job for a doctorate project [30][168-169].

  The result of this project was the Initial Orders program, completed in
  May 1949, which would translate more human friendly punched codes into
  binary, and was loaded into memory as a [31]‘bootstrap program’.

  Wikipedia cites the earlier source crediting Kathleen Booth as the
  inventor of assembly. Her Coding for A.R.C. piece was released in 1947,
  while Wheeler’s Initial orders came online later in 1949. He is
  credited by the IEEE Computer Society as having created the first
  [32]‘assembly language’. As far as we are aware, there is no digital
  copy of Coding for A.R.C., and it is something we would love to see
  come online.

 IBMs Early Commercial Assemblers

  In the early 1950s, IBM’s first commercial computers also had
  assemblers running. These assemblers took another step forwards from
  the early academics who developed assemblers. The earlier assemblers
  used more human friendly symbols for ‘operations’, but computer
  addresses were still fixed in a program’s code. This had the downside
  that programmers who encountered and corrected bugs needed to re-assign
  a chain of subsequent addresses by hand or use an alternate method and
  end up with ‘spaghetti code’ [33][p. 25].

  With IBM’s assemblers, symbolic addresses were introduced, where the
  assembler did the work of address assignment for the programmer [34][p.
  116]. Both IBM’s first commercial scientific ([35]the 701) and business
  ([36]the 650) computers had assembly languages with symbolic addresses.
  For the 701, Nathaniel Rochester developed the [37]Symbolic Assembly
  Program (SAP) in 1953. For the 650, Stan Poley [38]developed SOAP in
  1955, which improved the performance of programs by the intelligent
  assignment of addresses [39][p. 16].

Early Responses to Assembly

  Though most of the following perspectives are largely anecdotal, they
  suggest there is evidence that using assembly language, or anything
  higher than machine code, took time to catch on among practicing
  programmers and faced tremendous skepticism, even from earlier figures
  of our story, like Von Neumann (credit to [40]this presentation for the
  sources).

  [41]John Lee reports anecdotes from von Neumann himself questioning the
  use of anything higher than machine code :

    In the 1950’s von Neumann … was confronted with the FORTRAN concept;
    John Backus remembered von Neumann being unimpressed and that he
    asked “why would you want more than machine language?” …

    … Donald Gillies, one of von Neumann’s students at Princeton, and
    later a faculty member at the University of Illinois, recalled in
    the mid-1970’s that the graduates students were being “used” to hand
    assemble programs into binary for their early machine (probably the
    IAS machine). He took time out to build an assembler, but when von
    Neumann found out about he was very angry, saying (paraphrased), “It
    is a waste of a valuable scientific computing instrument to use it
    to do clerical work.”

  Richard Hamming, writing about programming on the IBM 701 (the same
  machine Rochester developed the assembler for) [42][p. 25]:

    I once spent a full year, with the help of a lady programmer from
    Bell Telephone Libraries, on one big problem coding in absolute
    binary for the IBM 701, which used all the 32K registers then
    available. After that experience I vowed never again would I ask
    anyone to do such labor. Having heard about a symbolic system from
    Poughkeepsie, IBM, I ask[ed] her to send for it and to use it on the
    next problem…As I expected, she reported it was much easier…

    So we told everyone about the new method, meaning about 100 people …

    … To my knowledge only one person —yes, only one—of all 100 showed
    any interest!

  He also writes (most probably about [43]Rochester’s system for the 701)
  [44][p. 26]:

    Finally a more complete, and more useful, Symbolic Assembly Program
    (SAP) was devised after more years than you are apt to believe …
    most programmers continued their heroic absolute binary programming.
    At the time SAP first appeared I would guess about 1% of the older
    programmers were interested in it—using SAP was “sissy stuff” and a
    real programmer would not stoop to wasting machine capacity to do
    the assembly.

  As Rochester developed SAP out of Poughkeepsie for IBM, it raises the
  question if Hamming’s two anecdotes were referring to one and the same
  event, and the earlier ‘symbolic system’ was also Rochester’s
  assembler.

  Nonetheless, Hamming estimates an initial interest level of about 1%
  amongst experienced programmers, despite his report of an estimated 2x
  productivity improvement.

Conclusion

  The anecdotal evidence suggests assembly language was far from an
  overnight success, despite the advantages it offered. Nonetheless
  zooming forwards, it’s clear that the idea behind assembly took hold.
  At a more abstract level, the idea of ‘buffering the user from the
  machine itself’, most likely using the computers themselves to do so,
  has carried forwards with many new layers added on after assembly;
  Hamming cites a report that assembly and technologies after have
  boosted programmer productivity by a factor of 90 over a 30 year period
  [45][p. 26, 31].

Continued

  If you read this and have better knowledge than we do, we would love to
  see:
   1. A copy of ‘Programming for A.R.C.’ online.
   2. More studies (esp. quantitative) or anecdotes on the adoption of
      assembly language.
   3. Your story or opinion on why programmers initially kept programming
      in machine code.
   4. Reports on the increase in programmer productivity since the
      internet.

  Please share with us!

References Cited Multiple Times

    * Campbell-Kelly, Martin, William Aspray, Nathan Ensmenger and
      Jeffrey Yost. 2014. Computer: A History of the Information Machine.
      Westview Press.

    * Hamming, Richard. 2005. The Art and Science of Doing Engineering:
      Learning to Learn Gordon and Breach Science Publishers.

    * Salomon, David. 1993. Assemblers and Loaders. Ellis Horwood Ltd.
      http://www.davidsalomon.name/assem.advertis/asl.pdf

  March 4, 2020 · [46]programming languages

References

  1. https://blog.deta.sh/atom.xml
  2. https://localhost:4000/feed.json
  3. https://blog.deta.sh/
  4. https://blog.deta.sh/about
  5. https://deta.sh/
  6. https://en.wikipedia.org/wiki/Richard_Hamming
  7. https://blog.deta.sh/assembly/#hamming
  8. https://en.wikipedia.org/wiki/ENIAC
  9. https://blog.deta.sh/assembly/#campbell
 10. https://en.wikipedia.org/wiki/John_von_Neumann
 11. http://web.eah-jena.de/~kleine/history/machines/VonNeumann-1stDraftReportEDVAC.pdf
 12. https://blog.deta.sh/assembly/#hamming
 13. https://blog.deta.sh/assembly/#campbell
 14. https://blog.deta.sh/assembly/#campbell
 15. https://www.color-hex.com/color/6689c3
 16. https://blog.deta.sh/assembly/#saloman
 17. https://blog.deta.sh/assembly/#campbell
 18. https://en.wikipedia.org/wiki/Richard_Hamming
 19. https://blog.deta.sh/assembly/#hamming
 20. https://en.wikipedia.org/wiki/Andrew_Donald_Booth
 21. https://en.wikipedia.org/wiki/Kathleen_Booth
 22. https://en.wikipedia.org/wiki/Maurice_Wilkes
 23. https://blog.deta.sh/assembly/#campbell
 24. https://www.ams.org/journals/mcom/1954-08-046/S0025-5718-54-99336-9/S0025-5718-54-99336-9.pdf
 25. https://www.i-programmer.info/history/people/1253-andrew-booth.html
 26. http://www.mt-archive.info/Booth-1947.pdf
 27. https://hackaday.com/2018/08/21/kathleen-booth-assembling-early-computers-while-inventing-assembly/
 28. https://www.dcs.bbk.ac.uk/about/history/
 29. https://blog.deta.sh/assembly/#campbell
 30. https://blog.deta.sh/assembly/#campbell
 31. https://www.cl.cam.ac.uk/~mr10/Edsac/edsacposter.pdf
 32. https://www.computer.org/profiles/david-wheeler
 33. https://blog.deta.sh/assembly/#hamming
 34. (https://ieeexplore.ieee.org/stamp/stamp.jsp?arnumber=4640454)
 35. https://en.wikipedia.org/wiki/IBM_701
 36. https://en.wikipedia.org/wiki/IBM_650
 37. https://ia600101.us.archive.org/25/items/symbolic-programming/Image111817152723.facing_text.pdf
 38. http://www.columbia.edu/cu/computinghistory/650.html
 39. https://blog.deta.sh/assembly/#saloman
 40. http://worrydream.com/dbx/
 41. http://ei.cs.vt.edu/~history/VonNeumann.html
 42. https://blog.deta.sh/assembly/#hamming
 43. https://blog.deta.sh/assembly/#ibms-early-commercial-assemblers
 44. https://blog.deta.sh/assembly/#hamming
 45. https://blog.deta.sh/assembly/#hamming
 46. https://blog.deta.sh/tag/programming languages

You are viewing proxied material from 1436.ninja. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.