Comprehensive Study Notes on Algorithms, Programming Languages, and Computer History

Fundamentals of Programming Languages

  • Definition of a Programming Language (Programmiersprache):
    • A system composed of words, numbers, symbols, and operators that, when combined, convey a specific, structured meaning.
    • A formal language defined by strict formation rules (syntax) used to specify computational structures and algorithms.
    • An artificial language designed to facilitate communication and execution between human beings and machines.

Historical Foundations and Technological Precursors (1843–1930s)

  • 1843 – Ada Lovelace:

    • Conceptualized the first machine intended for executing sequential operations and logical sequences of algorithms.
    • Laid the theoretical foundation for the principle of computing machines and established the core EVA principle (Eingabe-Verarbeitung-Ausgabe / Input-Processing-Output).

  • 1880 – Thomas Alva Edison:

    • Made the construction of widespread electrical power distribution networks possible.
    • Developed the first practical incandescent light bulb operating on direct current (DC / Gleichstrom).

  • 1891 – Nikola Tesla and George Westinghouse:

    • Enabled long-distance electrical power transmission, driving global electrification.
    • Introduced alternating current (AC / Wechselstrom) systems.

  • ~1930 – Konrad Zuse:

    • Designed and built the world's first modern computer architectures (e.g., Z1, Z2, Z3 series).

Evolution of Programming Language Generations

First Generation: Binary Languages and Early Computing (1944)

  • 1944 – Plankalkül:

    • Recognized as the first formal programming language.
    • Belongs to the 1st Generation of Programming Languages (Binary Language / Binärsprache).
    • Commands and data are represented strictly through binary sequences consisting solely of 00 and 11.
    • Disadvantages: Extremely labor-intensive (sehr aufwendig) and completely dependent on specific hardware configurations.
    • Binary Evaluation Example:
    • Binary input: 010120101_2
    • Positional binary weights: 20,21,22,232^0, 2^1, 2^2, 2^3
    • Positional decimal equivalents: 1,2,4,81, 2, 4, 8
    • Calculation: (0×20)+(1×21)+(0×22)+(1×23)=2+8=1010(0 \times 2^0) + (1 \times 2^1) + (0 \times 2^2) + (1 \times 2^3) = 2 + 8 = 10_{10}

  • 1944 – ENIAC (Electronic Numerical Integrator and Computer):

    • The world's first freely programmable electronic computer.
    • Designed and built by John Mauchly and J. Presper Eckert at the University of Pennsylvania, USA.
    • Performance: Capable of performing complex numerical calculations in millisecond speed (ms\text{ms}-speed).
    • Physical Limitations: Enormous physical size weighing 2727\text{ tonnes} (27 t27\,\text{t}); required complete manual programming via switches and cables; possessed no internal memory storage.

Second Generation: Assembly Languages and Mnemonics (from 1949)

  • Introduced starting in 1949 as 2nd Generation Programming Languages.
  • Utilized Assembly Language (Assemblersprache) featuring Mnemonics:
    • Mnemonics: Simplified abbreviations or text-based short codes representing specific hardware operations.
    • Mnemonics were assembled alongside raw binary code to form programs.
  • Advantages: Markedly improved code readability compared to pure binary numbers.
  • Limitations:
    • Still highly labor-intensive and tedious to write.
    • Incapable of solving complex, highly abstract software problems.
    • Lacked integrated internal memory mechanisms.
    • Remained tightly coupled to specific hardware architectures.
    • Restricted almost exclusively to specialized scientists and engineers.

Third Generation: Imperative Languages and High-Level Abstraction (Late 1950s–1970s)

  • Developed beginning in the late 1950s and ~1960 as 3rd Generation Programming Languages (Imperative Languages / Imperative Sprache).
  • Key Features:
    • Syntax constructed using full human-readable words, dramatically enhancing code readability.
    • Substantially improved code maintenance and software servicing (Verbesserte Wartung).
    • Allowed non-hardware specialists and external programmers (Außenstehende) to understand and edit source code.
    • Sparked the emergence of dedicated software development by decoupling software from specific hardware processors.

Fourth Generation: User-Friendly, Domain-Specific, and Modern Paradigms (1980s–Present)

  • Emerging from 1980 onwards as 4th Generation Programming Languages.
  • Characterized by user-friendly imperative and object-oriented paradigms focused on refinement and accessibility.
  • Primary Objectives (Ziele):
    • Enhance code understanding and user-friendliness for all developers.
    • Simplify code formulation to generate higher quality, optimized algorithmic results.
    • Improve software evaluation, maintainability, and quality assurance.
    • Expand networking capabilities (Möglichkeiten der Vernetzung).

Detailed Chronology of Key Languages and Innovations

  • 1957 – FORTRAN:

    • Early high-level imperative language widely adopted for scientific and engineering applications, such as structural design at Boeing.

  • 1958 – LISP:

    • Created by John McCarthy at MIT; became the foundation for artificial intelligence research and symbolic computation.

  • 1959 – COBOL:

    • Developed under the leadership of Dr. Grace Hopper; tailored for business and financial applications, becoming the standard for banking systems and ATMs (Geldautomaten).

  • 1964 – BASIC:

    • Created for MIT students and non-specialists to learn programming; later commercialized and adapted by Bill Gates and Paul Allen at Microsoft.

  • 1970 – PASCAL:

    • Designed with high user-friendliness, modularity, and structured programming principles in mind.

  • 1972 – C:

    • Developed by Dennis Ritchie; became the fundamental language for system software, operating systems, and massive scale software infrastructure (such as Google backend architectures).

  • 1980 – ADA:

    • Commissioned and standardized by the United States Department of Defense (US-Verteidigungsministerium) for mission-critical embedded systems.

  • 1983 – C++:

    • Developed for general software engineering; adopted extensively by Adobe and Microsoft; fundamental in writing operating systems such as macOS and iOS.

  • 1987 – Perl:

    • Designed specifically for advanced text processing, database management, and system administration.

  • 1991 – Python:

    • Created with the core philosophy of being readable, practical, and fun ("soll Spaß machen"); extensively used today by industry leaders such as Google and Spotify.

  • 1995 – Java:

    • Built to be fully cross-platform (plattformübergreifend); became the predominant primary programming language for enterprise software and web applications.

  • 1995 – PHP:

    • Specialized server-side scripting language created for building dynamic web sites.

  • 1995 – JavaScript:

    • Client-side scripting language designed for interactive web browsers and dynamic document processing (e.g., PDF manipulation).

  • 1997 Milestone:

    • Synergistic growth of Java, PHP, and Python driven by internet expansion, enabling major web startups like Google to launch and scale online.

  • 2000 – C#:

    • Introduced by Microsoft to maximize user-friendliness, safety, and developer efficiency across all application software development.

  • 2009 – Go:

    • Developed to resolve structural concurrency, compile-time, and complexity issues inherent in large-scale modern software systems.