Lesson 8

The evolution from IBM 370 assembly language to Fortran 77 marked a significant shift from low-level, machine-specific programming to high-level, structured programming. IBM 370 assembly language, used in the 1960s and 1970s, required programmers to write instructions directly tied to the hardware, managing registers and memory explicitly. This made coding tedious, error-prone, and non-portable across systems. Fortran 77, an advancement of earlier Fortran versions, introduced a higher abstraction level with features like structured control statements (e.g., DO loops and IF-THEN-ELSE), subroutines, and formatted I/O. These allowed programmers to focus on problem-solving rather than hardware details, improving productivity and code portability across different machines, which was critical for scientific and engineering applications.
The transition from Modula-2 to Pascal reflects a refinement in structured programming paradigms during the 1970s and 1980s. Pascal, developed by Niklaus Wirth in 1970, emphasized clarity and strong typing to teach good programming practices, with features like records, enumerated types, and a clear block structure. However, it lacked modularity for large-scale systems. Modula-2, introduced by Wirth in 1978, built on Pascal by adding modules for better code organization, separate compilation, and data encapsulation, addressing Pascal’s limitations in managing complex projects. While Modula-2 offered superior modularity, Pascal remained more widely used in education due to its simplicity and established presence, showing a trade-off between innovation and adoption.
The shift from C++ to Java in the 1990s represented a move toward platform independence and simplified memory management. C++, developed by Bjarne Stroustrup in the 1980s, extended C with object-oriented features like classes and inheritance, enabling complex, high-performance software development. However, its manual memory management and platform-specific code posed challenges. Java, introduced by Sun Microsystems in 1995, prioritized portability with its "write once, run anywhere" philosophy, achieved through the Java Virtual Machine (JVM). Java eliminated pointers, introduced automatic garbage collection, and provided a robust standard library, making development faster and less error-prone. While C++ remained dominant for performance-critical applications, Java became the standard for enterprise and web-based systems due to its simplicity and cross-platform capabilities.

Here is a structured overview of the evolution of computer programs across the specified language transitions:

Aspect	IBM 370 Assembly Language	Fortran 77
Era	1970s	1978 (Standardized)
Abstraction Level	Low-level (machine-oriented)	High-level (scientific and numerical computation)
Programming Paradigm	Imperative, unstructured	Procedural
Developer Effort	High: required manual management of registers, memory addresses, and instruction sequencing	Lower: allowed focus on algorithm and numeric logic without hardware micromanagement
Typical Use Case	System-level programming (e.g., OS internals, I/O control, device drivers)	Scientific, engineering, and mathematical computations
Portability	Hardware-specific (tied to IBM System/370)	Much more portable across platforms
Key Advancement	Introduction of symbolic programming using mnemonics and macros	Standardization of structured programming and support for common block-based memory organization

2. From Modula-2 to Pascal
Note: Technically, Pascal preceded Modula-2 (Pascal: 1970, Modula-2: 1978), but their relationship is better explained as evolution in design philosophy from Pascal to Modula-2. We can also interpret the reverse migrating back to Pascal for academic simplicity.

Aspect	Modula-2	Pascal
Designed By	Niklaus Wirth (1978)	Niklaus Wirth (1970)
Primary Focus	Modular programming, systems programming	Teaching structured programming
Modularity	Strong support for modules and interfaces	Lacked true module concept
Concurrency	Supports coroutines (lightweight concurrency)	Not built-in
Error Handling	Designed with system reliability in mind	Basic control structures only
Syntax and Structure	More modern and modular	More rigid and procedural
Use Case	Embedded systems, compilers, systems software	Education, introductory programming courses

Evolution Insight: Although Modula-2 was more powerful and modular, Pascal retained popularity in academia due to its simplicity. The transition from Modula-2 to Pascal (as seen in educational institutions) was more about pedagogical goals than technical superiority.
3. From C++ to Java

Aspect	C++	Java
Era	1985 (official release)	1995
Paradigm	Multi-paradigm (procedural + object-oriented)	Pure object-oriented (with exceptions like primitives)
Memory Management	Manual (with new/delete)	Automatic (Garbage Collection)
Platform Dependency	Compiled to native binaries (platform-specific)	Compiled to bytecode and executed by JVM (platform-independent)
Pointers	Direct pointer manipulation allowed	No direct access to memory addresses
Multiple Inheritance	Supported for classes (with complexity)	Removed (replaced with interfaces)
Standard Libraries	STL and OS-specific	Rich built-in libraries (collections, GUI, networking)
Security	No intrinsic sandboxing	Strong security model (sandboxing, class loaders, bytecode verification)

Evolution Insight: Java was designed to overcome C++'s complexity and error-prone features (like manual memory management and multiple inheritance), aiming for safer, more portable, and web-enabled application development. It introduced the concept of “Write Once, Run Anywhere.”
Summary

Transition	Key Evolutionary Themes
IBM 370 Assembly → Fortran 77	Shift from hardware control to algorithm focus
Modula-2 → Pascal	Simplification and focus on teaching fundamentals
C++ → Java	Safer memory management, platform independence, and web readiness

This module discussed what a computer program is and the environment in which it performs its work.
This included an exploration of the hardware components of a computer and the role of a computer's operating system.
You've also learned about the process of translating a computer program into the machine language that a computer understands.

• Module Summary
  Having completed this module, you are now able to
  1. Define computer programs
  2. List and describe the components of a computer
  3. Describe the role of an operating system
  4. Describe what happens when a computer program is executed
  5. Explain what machine language is
  6. Explain what compilers and interpreters do

The Harvard architecture is a computer architecture with physically separate storage and signal pathways for instructions and data. The term originated from the Harvard Mark I relay-based computer, which stored instructions on punched tape (24 bits wide) and data in electro-mechanical counters. These early machines had data storage entirely contained within the central processing unit, and provided no access to the instruction storage as data. Programs needed to be loaded by an operator; the processor could not initialize itself.
In the next module you will learn how a computer stores the numbers and text that are processed in a computer program.