Development Process: Overview & History of Programming

Development Process: Overview & History of Programming

This page introduces the origins of programming and explains how programming evolved from hardware manipulation to high-level languages.

What is programming?

Programming means instructing a computer what to do. This is usually done using high-level programming languages such as Kotlin, C#, or Python. High-level languages abstract away the hardware and make code easier to read and write.

However, understanding the underlying mechanisms is crucial for performance, debugging, and efficient design. To understand modern programming, we start from its beginnings.

Early computers: hardwired programs

The earliest computers, such as ENIAC (1945), were programmed by manually changing cables between hardware units.

• Each task required rewiring the machine.
• Changing the program was slow and tedious.
• For fixed-purpose machines (like industrial controllers), this was acceptable, but for general use, it was inefficient.

From hardware to stored programs

As memory capacity grew, programs could be stored in memory instead of physical switches or cables.

• A program consisted of 1s and 0s—the direct instructions the CPU executes.
• Early computers such as the PDP-11 could be programmed using front panels with switches and lights.

 Each bit had to be entered manually.  

This approach was extremely slow and error-prone but represented the first step toward software-based programming.

Input abstraction and mnemonics

To simplify input:

• Programmers began using octal or hexadecimal notation to represent binary data more compactly.
• They also introduced mnemonics—short, meaningful names like ADD or MOV—to represent machine instructions.

These steps made programming easier but were still closely tied to the machine’s instruction set.

Assembly language

Assembly language represents a symbolic form of machine code.

• Each instruction corresponds directly to a CPU operation (1:1 mapping).
• It allows constants, labels, and macros to simplify coding.
• It remains CPU-specific, depending on the instruction set architecture (ISA).

Assembly brought readability and structure but remained a low-level language close to the hardware.

Emergence of high-level languages

By the late 1950s, higher levels of abstraction emerged:

• FORTRAN (1957) for numerical computation.
• COBOL (1959) for business applications.
• LISP (1958) for functional programming.
• ALGOL (1958) introduced structured syntax and type systems.
• Simula (1962) introduced object-oriented programming.
• Prolog (1972) introduced logic programming.
• CLU (1975) introduced exception handling.

These languages allowed programs to run on different hardware and required much less code.

Why still learn assembler and C?

Modern languages (Rust, Kotlin, Swift, Python, etc.) provide high productivity, but:

• Understanding low-level execution helps in optimizing performance.
• Knowledge of memory layout and instruction flow is essential for debugging.
• Many modern concepts—like stacks, heaps, and concurrency—are rooted in assembly-level understanding.

High-level programming is built upon these low-level principles.