Group member

Id no
1. Wubshet Ayellew
GUR/03113/14
2. Samuel Ayalew
GUR/02934/14
UNIVERSITY OF GONDAR 3. Tewodros Kassanew
GUR/02070/14
INSTITUTE OF 4. Samuel Teshale
TECHNOLOGY GUR/03077/14

DEPARTMENT OF
COMPUTER ENGINEERING
ADVANCED PROGRAMMING
GROUP ASSIGNMNET
Submitted to: Mr.Wondimu.b
Submission date:
 Introduction
This presentation will take us on a
journey through the evolution of
programming, examining key early
languages like Plankalkül, Lisp, COBOL,
and others. These languages were
groundbreaking in their time and laid
the groundwork for modern programming.
 Objective
Our objective is to analyze the
developers, purposes, advantages,
disadvantages, and timelines of these
pioneering languages, highlighting
their historical significance and
lasting influence on the software world.
Plankalkul programming language
 Plankalkül, developed by Konrad Zuse. Plankalkül is likely the first high
level programming language ever designed.
 Plankalkul means “plan calculus” in German.

Development time line plankalkul

• 1942-1945: Conceptualization and drafting by Konrad Zuse.
• 1945: Formal draft of Plankalkül completed.
• 1945 - 1970s: Lack of active development and widespread use.
• 1972: First partial implementation by Joachim Hohmann.
• 1980s Onward: Continued study for historical and theoretical purposes;
limited further implementation.
The purpose of development
ü To Specify Algorithms Abstractly:
ü To Simplify Program Design:
ü To Be Machine-Independent
ü To Enable Formal Reasoning about Programs
ü To Support Data Structures
ü To Explore Theoretical Aspects of Programming
 To conclude that Zuse developed Plankalkül because he
wanted a language that was both useful for writing
programs and also helped in understanding how computers
work.
Advantage of plankalkul Sample code of plankalku
ü  Adding two numbers
Foundation for Programming Theory
ü Emphasis on Data Structures andP1: A+B => C
Algorithms
ü Language Agnostic Reasoning(focus | A | B | C |
on logical structure)
| V0 | V0 | V0 |
ü Historical and Educational Value
------------------------------------------

Disadvantage of | 10 | 20 | A+B |
------------------------------------------
Plankalkül
ü Lack of practical
Implementation
ü Difficult Syntax and
Notation
ü Limited Functionality
2. Short code
 Short Code was proposed by John Mauchly in 1949 and originally known as
Brief Code.
 It is interpreted language.

Development Timeline
 In the late 1940s the concept and initial development of Short Code
began in the late 1940s (around 1949) by
John Mauchly.
 Implemented by William schmitt for BINAC computer at the same year.
ü Early 1950s:
Short Code was later being developed for the UNIVAC I computer, which
was being developed and became available
commercially around this time (1950).
It became an official feature of the UNIVAC I system software in early
to mid 1950s.
Short Code was refined and used internally within the UNIVAC I
Purpose of Development
 Simplification : To simplify the tasks of programming for the UNIVAC I ,
making it easier to write, debug, and manage software
 Abstraction: To abstract away the complexities of machine code.
 Accessibility: to make programming more accessible to non hardware
engineers
 Increase productivity: to increase the efficiency of program creation by
using higher-level symbolic commands compared to machine code.
 Advantage and disadvantage of shortcode
Features Advantage Disadvantage
Abstraction Higher level than machine code, hides Not as efficient as direct machine code
hardware complexities, easier to understand
Syntax Symbolic codes, simplified syntax, easier to Limited features and data types compared
learn to more advanced languages
Productivity Quicker code writing, faster debugging Performance was often slow, owing to
increased efficiency of program creation interpretation
Execution Interpreter concept, software translation, Interpreter overhead, memory constraints
abstraction of hardware due to the interpreter and larger lookup
table
Portability Some code management advantages, allows Highly platform-specific, only for UNIVAC I ,
modification/patching not portable to different hardware, limited
application scope
Code example

 // Conceptual Short Code

 // Input two values (A and B) and calculate C=A+B and output C
 00 06 // Input A and store in Memory location 00
 01 06 // Input B and store in Memory location 01
 02 03 // Add A (from memory location 00) and B (from memory location 01),
store result in an accumulator
 03 00 // store accumulator to memory location 02 (variable C)
 04 02 // Output C (from Memory location 02)
3. Autocode
 Autocode is a series of early high-level programming languages that
aimed to simplify programming for early computers.
 The term "Autocode" itself reflects their purpose: to automatically
generate machine code from a more abstract and human-readable source
code.
 Autocode languages used symbolic representations for operations and
memory addresses.
 Alick Glennie developed the first autocode for Manchester Mark1 computer,
development time 1952- 1953.
 Tony Brooker developed mark 2 Autocode, Atlas Autocode, and other
variations, development time mid- 1950s through early 1960s .
Purpose of development
 Simplify Programming: to make programming less complex and more
manageable compared to machine code.
 Abstraction from Machine Code: To some extent, Autocode languages tried
to abstract the hardware specifics of the target machine.
 Increase Programmer Productivity: quick development,faster debugging.
 Facilitate Scientific Computing: Floating-point support and mathematical
notion.
 Advantage and disadvantage of autocode
advantage disadvantage
High level abstraction Machine-specific
Simplified syntax Performance overhead
Increased programmer productivity Limited feature set
It uses both compilers or interpreters to Development and maintenance overhead
automatically translate the symbolic instruction
into machine code
Support for scientific computing Limited practical application
Subroutine support( allowing for programs to be
broken down in to more manageable chunks with
improved code organization and reuse )
Code example
 // Conceptual Autocode

 start: // A label to indicate start of the program

 input a // Read a value from input and store in memory location associated with variable ‘a’
 input b // Read a value from input and store in memory location associated with variable ‘b’
 add a, b, c // add values at locations a and b, and store the result at memory location
associated with ‘c’.
 output c // Output the value of variable ‘c’
 halt // Stop execution
4. FORTRAN
 FORTRAN(formula translation) is a general
purpose, imperative programming language
that’s particularly well suited for
numerical computation and scientific
computing.
 Its static typed language means that the
data types of variables are declared
explicitly and are checked at compile time.
 It’s compiled language
 It was developed by John backus.
 In the mid 1950s the work on FORTRAN began
and in 1957 the first version of FORTRAN
was released for the IBM 704 computer
 The aims of creating this language was to
 The purpose of development
Ø Ease of Programming for Scientific Computing: reduce
complexity, mathematical notation.
Ø Improve Programmer Productivity: fast code
development, reduce error.
Ø Efficiency and Performance.
Ø Provide support for numerical algorithms and
array/matrix operations.
Ø Support development of large-scale numerical
simulations
 Advantage and disadvantage of FORTRAN

Advantage disadvantage
High Performance for Numerical Computations Verbosity and Older Syntax
Excellent Support for Arrays and Matrices, built Limited Data Structure Capabilities
in math and scientific libraries
Good Support for Parallel Computing (features in Less Strong Community and New Development
multithreading and distributed memory)
Direct Access to Low Level Resources (a degree Object oriented future not robust as other
of low-level control over memory access and language
management)
Large selections of well-developed mature Difficult maintenance of legacy code
libraries, strong legacy support
Code example
 program arithmetic_example
 implicit none // Recommended to avoid implicit declarations
 real :: a, b, sum, difference, product, quotient
 a = 10.0
 b = 3.0
 sum = a + b
 difference = a - b
 product = a * b
 quotient = a / b
 print *, "Sum:", sum
 print *, "Difference:", difference
 print *, "Product:", product
 print *, "Quotient:", quotient
 end program arithmetic_example
5. FLOW-MATIC
 Flow-Matic was an early high-level programming language developed
by Grace Hopper and her team at Remington Rand in the late 1950s.

Development Timeline
ü In the Late 1950s Grace Hopper and her team at
Remington Rand started developing the concepts for
Flow-Matic.
ü In 1957 The initial version of Flow-Matic was
developed for the UNIVAC I and UNIVAC II computers.
ü In 1958 Flow-Matic was publicly demonstrated,
showcasing its business data processing capabilities.
ü In Early 1960s: Flow-Matic was further developed and
used by some business users, but it gradually fell out
of widespread use.
Purpose of development
 Simplify Business Programming: to make programming more accessible and efficient for business
applications.
 Automate Data Processing Tasks: designed to automate common business tasks such as sorting, merging,
reporting, and other data manipulation tasks.
 Early Compiler Development: The development of Flow-Matic included the development of one of the
first compilers that could translate its high-level source code into machine code automatically.
Advantage and disadvantage of flow-matic
Advantage Disadvantage

English-Like Syntax Machine-specific

Simplified programming Limited features

Business data focus Reactively inefficient compared to the code

written in assembly language
Foundation for COBOL Not widely adopted

Early compiler development Complex compiler

Abstraction Limited control structure

Sample code
INPUT FILE IS SALES-DATA. //input data comes from the file named sales-data
OUTPUT FILE IS SALES-REPORT. //output will be written to the file named sales-report
MOVE SALES-AMOUNT TO REPORT-AMOUNT. //copies the sales amount from the input data to the R-data
MOVE SALES-DATE TO REPORT-DATE. // copies the sales date from the input data to the report data.
ADD SALES-AMOUNT TO TOTAL-SALES. //it updates total-sales amount by adding the current sales amount
COMPARE SALES-AMOUNT WITH QUOTA. //it compares sales-amount with previous quota
IF SALES-AMOUNT > QUOTA, JUMP TO PRINT-OVER-QUOTA.
PRINT REPORT-LINE.// print current report line ,includes sales amount and date
JUMP TO PROCESS-NEXT-RECORD. //process next record section in the next record in the input file
PRINT-OVER-QUOTA.//the beginning of the section that handles sales amounts over the quota.

PRINT OVER-QUOTA-LINE.
PROCESS-NEXT-RECORD.
STOP.
6. ALGOL
 It stands for algorithmic language.
 ALGOL is a computer programming language that was created in
1958–60 by an international committee of the Association of
Computing Machinery (ACM) chaired by Alan J. Perlis of Carnegie
Mellon University for publishing algorithms and performing
calculation
 It’s imperative programming language
Development Timeline
 In late 1950s Initial discussions and meetings, growing awareness
of need for a common algorithmic language.
 In 1958 publication of ALGOL 58.
 In 1960 publication of the ALGOL 60 report.
 In 1960s Implementations and adoption of ALGOL 60, emergence of
criticisms and proposals for improvements.
 In 1968 Publication of the ALGOL 68 report.
Purpose of development
Ø Machine Independence and Portability
Ø Clear and Unambiguous Algorithm Description:-
to create a standardized, universal language
for describing algorithms, particularly for
scientific and mathematical computations
Ø Improve Code Structure and Readability
Ø Provide a Foundation for Compiler Development
Advantage and disadvantage of algol
Advantage Disadvantage

It encourages the production of well-structured Since ALGOL 60 had no I/O facilities, there is no
programs over preceding languages portable hello world program.

It led to the invention of a new metalanguage Implementation Challenges

based on notation which is known as the Backus
Normal Form or Backus Naur Form(BNF), it
provides the foundation for compiler
development
It gave rise to many other programming Complexity (Especially ALGOL 68)
languages,including CPL, Simula, BCPL, B, Pasca
l and C.
It was also the first language Late Emergence in the Commercial World
implementing nested function definitions
with lexical scope
Sample of code
Finding the maximum value in an array
procedure findMax(arr, size); begin
array arr; array myArr[1:5]; // Declare an array with
indices 1 to 5
integer size;
myArr[1] := 10;
integer maxVal, i;
myArr[2] := 5;
begin
myArr[3] := 25;
maxVal := arr[1];
myArr[4] := 8;
for i := 2 step 1 until size do
myArr[5] := 15;
if arr[i] > maxVal then
printResult(findMax(myArr, 5));
maxVal := arr[i];
end.
findMax := maxVal;
end;
7. LISP
 Lisp stands for LISt Processor.
 The developer of Lisp is John McCarthy.
 He created Lisp while working at the Massachusetts
Institute of Technology (MIT) in the late 1950s

Development Timeline
Ø In the late 1950s Conceptualization and initial
design by John McCarthy.
Ø In 1960 Publication of the foundational paper, birth
of Lisp.
Ø From 1960s-1970s early implementations and the
emergence of dialects.
Ø In 1980s Standardization with Common Lisp and the
rise of Scheme.
Purpose of development
 Symbolic Computation
 Artificial Intelligence Research
 Recursion and Functional Programming
 List Processing as a Fundamental
Operation
 Metaprogramming and Code-as-Data
 Interactive Development, it include
REPL(read-eval-print loop)
Advantage and disadvantages of LISP
Advantage Disadvantage

Powerful Metaprogramming Unusual Syntax (S-expressions)

Flexibility and Expressiveness Dynamic Typing(leads to run-time error)

Functional Programming Paradigm Steep Learning Curve

List Processing Capabilities Lisp developers have a scarcity of work

opportunities.
Samples of code
Basic arithmetic
;; Define a function to add two numbers
(defun add-two-numbers (x y)
(+ x y))

;; Call the function and print the result

(print (add-two-numbers 5 7)) ; Output: 12

;; Basic arithmetic operations

(print (+ 10 2)) ; Output: 12 (addition)
(print (- 10 2)) ; Output: 8 (subtraction)
(print (* 10 2)) ; Output: 20 (multiplication)
(print (/ 10 2)) ; Output: 5 (division)
8. COBOL
 COBOL stands for COmmon Business-Oriented Language, is
a high-level programming language designed for
business applications.
 It’s procedural, imperative, object-oriented
programming language
 COBOL was designed in 1959 by CODASYL and was partly
based on the programming language FLOW-MATIC.
Development Timeline
ü In the late 1950s the need for a more business-
oriented programming language becomes evident, as
existing languages weren't well-suited for handling
the complexities of business data processing.
ü In 1959 The CODASYL committee is formed to develop a
common business language.
..con
ü 1960s-1970s: COBOL gains widespread adoption in the
business world.
ü From 1980s-Present COBOL continues to be used,
particularly in legacy systems in the financial and
government sectors.

purpose of development
§ business oriented: To handle the specific
needs of business data processing tasks, such as
accounting, inventory management, and payroll.
§ Easy to read and understand: Designed to be
more readable than assembly language or FORTRAN.

§ Portable: to run on different computer system with

 Advantage and disadvantage of COBOL

Advantage Disadvantage

It can readily manage large amounts of A strong understanding of machine

data. languages is required to become a
COBOL programmer
It is written in an ENGLISH-like style, Because the language is similar to
making it simple to grasp and read English, it necessitates a lot of typing,
which makes the code thick.

Built-in features for handling business A COBOL programmer takes longer to

data types (like currency and dates) compile than other machine
and specific processing tasks make it programming languages.
efficient for business applications.
Samples of COBOL code example
IDENTIFICATION DIVISION.
PROGRAM-ID. STRING-EXAMPLE.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 FIRST-NAME PIC X(10) VALUE "John ".
01 LAST-NAME PIC X(10) VALUE "Doe ".
01 FULL-NAME PIC X(20).

PROCEDURE DIVISION.
STRING FIRST-NAME " " LAST-NAME DELIMITED BY SIZE INTO FULL-NAME.
DISPLAY "Full name: " FULL-NAME.
STOP RUN.
 u!
yo
nk
ha
T