jagomart
digital resources
picture1_Programming Pdf 183598 | 02history


 199x       Filetype PDF       File size 0.39 MB       Source: www.csee.umbc.edu


File: Programming Pdf 183598 | 02history
umbc cmsc 331 history early history the first programmers history of the 1940s von neumann and zuse the 1950s the first programming language the 1960s an explosion in programming programming ...

icon picture PDF Filetype PDF | Posted on 31 Jan 2023 | 2 years ago
Partial capture of text on file.
                             UMBC CMSC 331 
                                                                                                                                                                                                                       History 
                                                                                                                                                                                        • Early History : The first programmers 
                                                                 History of                                                                                                             • The 1940s: Von Neumann and Zuse 
                                                                                                                                                                                        • The 1950s: The First Programming Language  
                                                                                                                                                                                        • The 1960s: An Explosion in Programming  
                                                         Programming                                                                                                                       languages 
                                                                                                                                                                                        • The 1970s: Simplicity, Abstraction, Study 
                                                                 Languages                                                                                                              • The 1980s: Consolidation and New Directions 
                                                                                                                                                                                        • The 1990s: Internet and web 
                                                                                                                                                                                        • The 2000s: ? scripting, parallel, Web 2.0, …?   
                                            CMSC 331.  Some material  © 1998 by Addison Wesley Longman, Inc.                                     1                           CMSC 331.  Some material  © 1998 by Addison Wesley Longman, Inc.                                      2 
                                                Early History: First Programmers                                                                                                         Konrad Zuse and Plankalkul 
                                                 • Jacquard loom of early 1800s                                                                                                                                               Konrad Zuse began work on 
                                                                                                                                                                                                                              Plankalkul (plan calculus), the first 
                                                     – Translated card patterns into cloth designs                                                                                                                            algorithmic programming                                      
                                                 • Charles Babbage’s analytical engine                                                                                                                                        language, with an aim of creating the 
                                                                                                                                                                                                                              theoretical preconditions for the 
                                                   (1830s & 40s)                                                                                                                                                              formulation of problems of a general 
                                                     Programs were cards with data and operations.                                                                                                                            nature.  
                                                        Steam powered!                                                                                                                                                        Seven years earlier, Zuse had devel-
                                                 • Ada Lovelace – first programmer                                                                                                                                            oped and built the world's first 
                                                                                                                                                                                                                              binary digital computer, the Z1. He 
                                                     “The engine can arrange and combine its                                                                                                                                  completed the first fully functional 
                                                                                                                                                                                                                              program-controlled electromechan-
                                                        numerical quantities exactly as if they                                                                                                                               ical digital computer, the Z3, in 
                                                        were letters or any other general                                                                                                                                     1941.  
                                                        symbols; And in fact might bring out its                                                                                                                              Only the Z4 – the most sophisticated 
                                                        results in algebraic notation, were                                                                                                                                   of his creations -- survived World 
                                                        provision made.”                                                                                                                                                      War II.  
                                            CMSC 331.  Some material  © 1998 by Addison Wesley Longman, Inc.                                     3                           CMSC 331.  Some material  © 1998 by Addison Wesley Longman, Inc.                                      4 
                    CMSC 331.  Some material  © 1998 by Addison Wesley Longman, Inc.                                                                                                                                                                                                                   1 
                             UMBC CMSC 331 
                                              The 1940s: Von Neumann and Zuse                                                                                                                       Plankalkul notation 
                                                     • Konrad Zuse (Plankalkul) 
                                                         – in Germany - in isolation because of the war  
                                                         – defined Plankalkul (program calculus) circa 1945 but                                                                           A(7) := 5 * B(6) 
                                                            never implemented it.  
                                                         – Wrote algorithms in the language, including a program to 
                                                            play chess.                                                                                                                         |   5  *  B  =>  A 
                                                         – His work finally published in 1972.                                                                                             V   |          6         7            (subscripts) 
                                                         – Included some advanced data type features such as                                                                               S   |         1.n     1.n           (data types) 
                                                             » Floating point, used twos complement and hidden bits 
                                                             » Arrays 
                                                             » records (that could be nested) 
                                            CMSC 331.  Some material  © 1998 by Addison Wesley Longman, Inc.                                     5                           CMSC 331.  Some material  © 1998 by Addison Wesley Longman, Inc.                                      6 
                                              The 1940s: Von Neumann and Zuse                                                                                                                     Machine Codes (40’s) 
                                              Von Neumann 
                                              led a team that                                                                                                                             • Initial computers were programmed in raw 
                                              built computers                                                                                                                                machine codes. 
                                              with stored                                                                                                                                 • These were entirely numeric. 
                                              programs and a                                                                                                                              • What was wrong with using machine code?  
                                              central pro-                                                                                                                                   Everything! 
                                              cessor                                                                                                                                            • Poor readability 
                                              ENIAC was                                                                                                                                         • Poor modifiability 
                                              programmed                                                                                                                                        • Expression coding was tedious 
                                              with patch                                                                                                                                        • Inherit deficiencies of hardware, e.g., no 
                                              cords                                                                                                                                               indexing or floating point numbers 
                                                                                                 Von Neuman with ENIAC 
                                            CMSC 331.  Some material  © 1998 by Addison Wesley Longman, Inc.                                     7                           CMSC 331.  Some material  © 1998 by Addison Wesley Longman, Inc.                                      8 
                    CMSC 331.  Some material  © 1998 by Addison Wesley Longman, Inc.                                                                                                                                                                                                                   2 
                          UMBC CMSC 331 
                                                            The 1950s: The First                                                                                                 Pseudocodes (1949) 
                                                        Programming Language 
                                                                                                                                                                • Short Code or SHORTCODE - John Mauchly, 1949.  
                                              • Pseudocodes: interpreters for assembly language                                                                 • Pseudocode interpreter for math problems, on Eckert 
                                              • Fortran: the first higher level programming                                                                       and Mauchly’s BINAC and later on UNIVAC I and II.  
                                                 language                                                                                                       • Possibly the first attempt at a higher level language.  
                                              • COBOL: he first business oriented language                                                                      • Expressions were coded, left to right, e.g.: 
                                                                                                                                                                      X0 = sqrt(abs(Y0)) 
                                              • Algol: one of the most influential programming                                                                        00 X0 03 20 06 Y0 
                                                 languages ever designed                                                                                        • Some operations: 
                                              • LISP: the first language outside the von Neumann                                                                      01 –         06 abs             1n (n+2)nd power 
                                                 model                                                                                                                02 )         07 +               2n (n+2)nd root 
                                                                                                                                                                      03 =         08 pause           4n if <= n 
                                              • APL: A Programming Language                                                                                           04 /         09 (               58 print & tab 
                                       CMSC 331.  Some material  © 1998 by Addison Wesley Longman, Inc.                            9                        CMSC 331.  Some material  © 1998 by Addison Wesley Longman, Inc.                           10 
                                                               More Pseudocodes                                                                                                     Fortran  (1954-57) 
                                                   Speedcoding; 1953-4                                                                                        • FORmula TRANslator 
                                                   • A pseudocode interpreter for math on IBM701, IBM650.                                                     • Developed at IBM under the  
                                                   • Developed by John Backus                                                                                    guidance of John Backus  
                                                   • Pseudo ops for arithmetic and math functions                                                                primarily for scientific,  
                                                   • Conditional and unconditional branching                                                                     computational programming 
                                                   • Autoincrement registers for array access 
                                                   • Slow but still dominated by slowness of s/w math                                                         • Dramatically changed forever the  
                                                   • Interpreter left only 700 words left for user program                                                       way computers  used 
                                                   Laning and Zierler System - 1953                                                                           • Has continued to evolve, adding new features & concepts.  
                                                   • Implemented on the MIT Whirlwind computer                                                                    – FORTRAN II, FORTRAN IV, FORTRAN66, FORTRAN77, FORTRAN90 
                                                   • First "algebraic" compiler system                                                                        • Always among the most efficient compilers, producing fast 
                                                   • Subscripted variables, function calls, expression translation                                               code 
                                                   • Never ported to any other machine  
                                       CMSC 331.  Some material  © 1998 by Addison Wesley Longman, Inc.                            11                       CMSC 331.  Some material  © 1998 by Addison Wesley Longman, Inc.                           12 
                  CMSC 331.  Some material  © 1998 by Addison Wesley Longman, Inc.                                                                                                                                                                                        3 
                            UMBC CMSC 331 
                                                                Fortran 77 Examples                                                                                                               Fortran 0 and 1 
                                                                                                                                                                                       FORTRAN 0 – 1954  (not implemented) 
                                                 C Hello World in Fortran 77

                                                 C (lines must be 6 characters indented)
                                                                                              FORTRAN I - 1957 
                                                       PROGRAM HELLOW
                                                                                                                 Designed for the new IBM 704, which had index registers and 
                                                       WRITE(UNIT=*, FMT=*) 'Hello World'
                                                                                                floating point hardware 
                                                       END
                                                                                                                            Environment of development: 
                                                                                                                                                                                          Computers were small and unreliable 
                                                  PROGRAM SQUARE
                                                                                                                         Applications were scientific 
                                                                                                                                                                                          No programming methodology or tools 
                                                    DO 15,I = 1,10
                                                                                                                       Machine efficiency was most important 
                                                    WRITE(*, *) I*I
                                                                                                                   Impact of environment on design 
                                                 15 CONTINUE
                                                                                                                              •  No need for dynamic storage 
                                                    END
                                                                                                                                   •  Need good array handling and counting loops 
                                                                                                                                                                                           •  No string handling, decimal arithmetic, or powerful input/
                                                                                                                                                                                              output (commercial stuff) 
                                          CMSC 331.  Some material  © 1998 by Addison Wesley Longman, Inc.                                  13                         CMSC 331.  Some material  © 1998 by Addison Wesley Longman, Inc.                                  14 
                                                                   Fortran I Features                                                                                                       Fortran II, IV and 77 
                                                        • Names could have up to six characters                                                                                              FORTRAN II - 1958 
                                                        • Post-test counting loop (DO I=1, 100) 
                                                        • Formatted I/O                                                                                                                      •    Independent compilation 
                                                        • User-defined subprograms                                                                                                           •    Fix the bugs 
                                                        • Three-way selection statement (arithmetic IF with GOTO) 
                                                             IF (ICOUNT-1) 100 200 300                                                                                                       FORTRAN IV - 1960-62 
                                                        • Implicit data typing statements                                                                                                    •     Explicit type declarations 
                                                             variables beginning with i, j, k, l, m or n were integers,                                                                      •     Logical selection statement 
                                                             all else floating point                                                                                                         •     Subprogram names could be parameters 
                                                        • No separate compilation                                                                                                            •     ANSI standard in 1966 
                                                        • Programs larger than 400 lines rarely compiled correctly, 
                                                          mainly due to poor reliability of the 704                                                                                          FORTRAN 77 - 1978 
                                                        • Code was very fast                                                                                                                 •     Character string handling 
                                                        • Quickly became widely used                                                                                                         •     Logical loop control statement 
                                                                                                                                                                                             •     IF-THEN-ELSE statement 
                                          CMSC 331.  Some material  © 1998 by Addison Wesley Longman, Inc.                                  15                         CMSC 331.  Some material  © 1998 by Addison Wesley Longman, Inc.                                  16 
                   CMSC 331.  Some material  © 1998 by Addison Wesley Longman, Inc.                                                                                                                                                                                                          4 
The words contained in this file might help you see if this file matches what you are looking for:

...Umbc cmsc history early the first programmers of s von neumann and zuse programming language an explosion in languages simplicity abstraction study consolidation new directions internet web scripting parallel some material by addison wesley longman inc konrad plankalkul jacquard loom began work on plan calculus translated card patterns into cloth designs algorithmic charles babbage analytical engine with aim creating theoretical preconditions for formulation problems a general programs were cards data operations nature steam powered seven years earlier had devel ada lovelace programmer oped built world binary digital computer z he can arrange combine its completed fully functional program controlled electromechan numerical quantities exactly as if they ical letters or any other symbols fact might bring out only most sophisticated results algebraic notation his creations survived provision made war ii germany isolation because defined circa but b never implemented it wrote algorithms in...

no reviews yet
Please Login to review.