Group member

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

DEPARTMENT OF
COMPUTER ENGINEERING
ADVANCED PROGRAMMING
GROUP ASSIGNMNET
Submitted to: Mr.Wondimu.b
Submission date:
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 | A | B | C |
ü Historical and Educational Value | V0 | V0 | V0 |

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.
ü Early 1950s:
Short Code was primarily used on the UNIVAC I computer, which was being
developed and became available
commercially around this time (1951).
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 development
team at Remington Rand.
ü Mid to late 1950s:
Short Code started to decline as other more powerful programming languages
and compilation systems were developed.
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 01 // 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,
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 create high level language for
scientific computing and ease the tasks of programming
 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.
ü In Influence on COBOL: Many of Flow-Matic's ideas,
especially the use of English-like statements, directly
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

Foundation for COBOL Not widely adopted

Early compiler Complex compiler

Abstraction Limited control structure

Sample code
INPUT FILE IS SALES-DATA.
OUTPUT FILE IS SALES-REPORT.
MOVE SALES-AMOUNT TO REPORT-AMOUNT.
MOVE SALES-DATE TO REPORT-DATE.
ADD SALES-AMOUNT TO TOTAL-SALES.
COMPARE SALES-AMOUNT WITH QUOTA.
IF SALES-AMOUNT > QUOTA, JUMP TO PRINT-OVER-QUOTA.
PRINT REPORT-LINE.
JUMP TO PROCESS-NEXT-RECORD.
PRINT-OVER-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

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.
• In 1970s onwards decline of ALGOL in direct use, but its concepts strongly
influence
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 gave rise to many other programming Complexity (Especially ALGOL 68)

languages,
including CPL, Simula, BCPL, B, Pascal 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.
Ø From 1990s-2000s continued evolution, specialization and refinement of
the Lisp dialect languages.
Ø From 2010s-Present: Renewed interest in Lisp, particularly for
functional
programming, emergence of Clojure, and continued use in AI and symbolic
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
Advantage and disadvantages of LISP
Advantage Disadvantage

Powerful Metaprogramming Unusual Syntax (S-expressions)

Flexibility and Expressiveness Dynamic Typing

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.
ü In 1960 the initial specifications for COBOL are finalized.
ü In 1961 the first COBOL compiler is released.
ü In 1960s-1970s COBOL gains widespread adoption in the business world
..cont
ü 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 minimal

modification.
 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