# History of Programming Languages

Canonical URL: https://shipslides.com/d/technology-programming-languages
Raw viewer URL: https://content.shipslides.com/d/technology-programming-languages/raw
Category: Technology
Slides: 32
Updated: 2026-05-17T20:51:06.189Z
Tags: technology, programming, languages

## Summary

From Punch Cards to AI Assistants: 70 Years of Human-Machine Communication Key sections include: History of Programming Languages; Table of Contents; Before Programming Languages; Assembly & Machine Code; FORTRAN (1957); LISP (1958); COBOL (1959); The 1960s Explosion; Structured Programming Revolution; C (1972).

## Slide Outline

1. History of Programming Languages
2. Table of Contents
3. Before Programming Languages
4. Assembly & Machine Code
5. FORTRAN (1957)
6. LISP (1958)
7. COBOL (1959)
8. The 1960s Explosion
9. Structured Programming Revolution
10. C (1972)
11. Smalltalk & OOP Origins
12. SQL & Declarative Languages
13. Ada, Pascal & Software Safety
14. C++ (1979/1985)
15. The Functional Renaissance
16. Perl & the Scripting Revolution (1987)
17. Python (1991)
18. Java (1995)
19. JavaScript (1995)
20. Ruby & PHP: Web's Workhorses
21. C# & .NET (2000)
22. Go (2009)
23. Rust (2010/2015)
24. Swift & Kotlin: Modern Platform Languages
25. TypeScript (2012)
26. Programming Paradigms
27. Type Systems
28. Concurrency Models
29. Domain-Specific Languages
30. AI & the Future of Programming Languages
31. Language Popularity Over Time
32. Further Reading

## Slide Transcript

### Slide 1: History of Programming Languages

- From Punch Cards to AI Assistants: 70 Years of Human-Machine Communication
- How humanity learned to speak to machines, and how each generation of languages reshaped what was possible to build.
- 1 / 32

### Slide 2: Table of Contents

- 01 Before Programming Languages
- 02 Assembly & Machine Code
- 03 FORTRAN (1957)
- 04 LISP (1958)
- 05 COBOL (1959)
- 06 The 1960s Explosion
- 07 Structured Programming
- 08 C (1972)
- 09 Smalltalk & OOP Origins
- 10 SQL & Declarative Languages
- 11 Ada, Pascal & Safety
- 12 C++ (1985)
- 13 Functional Renaissance
- 14 Perl & Scripting (1987)
- 15 Python (1991)
- 16 Java (1995)
- 17 JavaScript (1995)
- 18 Ruby & PHP
- 19 C# & .NET (2000)
- 20 The Web Revolution
- 21 Go (2009)
- 22 Rust (2010)
- 23 Swift & Kotlin
- 24 TypeScript (2012)
- 25 Language Paradigms
- 26 Type Systems
- 27 Concurrency Models
- 28 Domain-Specific Languages
- 29 AI & the Future
- 30 Further Reading
- 2 / 32

### Slide 3: Before Programming Languages

- Before high-level languages existed, programming meant physically encoding instructions: punched cards, wired plugboards, and toggle switches. The conceptual groundwork was laid by mathematicians decades before electronic computers existed.
- 1843Ada Lovelace writes first algorithm (for Babbage's Analytical Engine) -- Bernoulli numbers
- 1936Turing's universal machine; Church's lambda calculus -- theoretical foundations
- 1945von Neumann architecture: stored-program concept (code and data in same memory)
- 1948Konrad Zuse designs Plankalkul (first high-level language concept, never implemented)
- 1949Short Code (first actually executed higher-level language for BINAC)
- 1951Grace Hopper's A-0 compiler -- first to translate symbolic code to machine code
- Key Insight: The revolutionary idea was that programs themselves could translate programs. A compiler is a program that transforms human-readable code into machine instructions -- software that creates software. This abstraction made all subsequent language development possible.
- 3 / 32

### Slide 4: Assembly & Machine Code

- Machine code is the raw binary instructions a CPU executes. Assembly language provides human-readable mnemonics for these instructions: a thin symbolic layer over hardware, still used today for performance-critical and embedded systems.
- Machine Code
- Binary opcodes specific to each CPU architecture
- Direct manipulation of registers, memory, and I/O
- No abstraction: programmer manages everything
- Different for every processor (x86, ARM, MIPS, RISC-V)
- Still what every program ultimately becomes
- Assembly Language
- One-to-one mapping to machine instructions (MOV, ADD, JMP)
- Symbolic labels replace raw memory addresses
- Assembler translates to machine code (simple 1:1 translation)
- Still used: OS kernels, drivers, cryptography, game engines (inner loops)
- Essential for understanding how computers actually work
- ; x86 Assembly example: add two numbers
- MOV EAX, 5 ; load 5 into register EAX
- ADD EAX, 3 ; add 3 to EAX
- MOV [result], EAX ; store result (8) in memory
- 4 / 32

### Slide 5: FORTRAN (1957)

- FORmula TRANslation, developed by John Backus at IBM, was the first widely used high-level programming language. It proved that compilers could generate code nearly as efficient as hand-written assembly, a claim many doubted at the time.
- Why FORTRAN Mattered
- First language where you could write mathematical formulas directly
- Reduced programming time by factor of 5-10x
- Compiler produced code within 10% of hand-optimized assembly
- Made programming accessible to scientists and engineers
- Introduced: variables, loops (DO), conditionals (IF), subroutines
- Legacy (Still Alive!)
- Dominated scientific computing for 60+ years
- Still used: climate models, particle physics, computational chemistry
- Modern Fortran (2018 standard) has modules, OOP, coarrays
- Fastest matrix math libraries (BLAS, LAPACK) still in Fortran
- Estimated $100B+ of Fortran code still running worldwide
- C FORTRAN IV example
- PROGRAM HELLO
- REAL X, Y, Z
- X = 3.14159
- Y = 2.71828
- Z = X * Y
- WRITE(6,10) Z
- 10 FORMAT(' Result = ', F8.4)
- STOP
- END
- 5 / 32

### Slide 6: LISP (1958)

- LISt Processing, invented by John McCarthy at MIT, introduced a radically different approach to programming. Based on lambda calculus, it treated code and data as the same structure (lists), enabling metaprogramming, AI research, and ideas that took decades to reach mainstream languages.
- Revolutionary Ideas
- Homoiconicity: Code is data, data is code (both are lists)
- Garbage collection: First automatic memory management (1959)
- Recursion: First language built around recursive function calls
- Higher-order functions: Functions that take/return functions
- REPL: Read-Eval-Print Loop -- interactive development
- Macros: Programs that write programs (metaprogramming)
- Influence & Descendants
- Scheme (1975): minimalist Lisp; used in education (SICP)
- Common Lisp (1984): standardized industrial Lisp
- Emacs Lisp: powers the legendary text editor
- Clojure (2007): modern Lisp on JVM; immutable data structures
- Influenced: Python, Ruby, JavaScript, Haskell, Scala
- ;; LISP: factorial function
- (defun factorial (n)
- (if ("Lisp is worth learning for the profound enlightenment experience you will have when you finally get it." -- Eric Raymond
- 6 / 32

### Slide 7: COBOL (1959)

- COmmon Business-Oriented Language was designed for business data processing by a committee including Grace Hopper. Despite being much maligned by academics, COBOL processes an estimated 95% of ATM transactions and 80% of in-person transactions today.
- Design Philosophy
- English-like syntax: readable by managers and auditors
- Built for data processing: records, files, report generation
- Platform-independent from the start (ran on different vendors' hardware)
- Fixed-point decimal arithmetic (no floating-point rounding errors)
- Self-documenting: PERFORM VARYING COUNTER FROM 1 BY 1 UNTIL...
- The COBOL Problem
- 220 billion lines of COBOL still in production
- Banks, insurance, government, airlines depend on it
- Average COBOL programmer age: 55+ (and retiring)
- COVID unemployment systems crashed (2020) due to COBOL overload
- Too expensive to rewrite; too risky to replace; too critical to ignore
- 220B
- Lines in production
- 95%
- ATM transactions
- $3T
- Daily commerce processed
- Years and counting
- 7 / 32

### Slide 8: The 1960s Explosion

- The 1960s saw an explosion of language innovation. Computer science emerged as a discipline, and researchers explored radically different approaches to expressing computation.
- ALGOL 60
- The "ALGOL family" ancestor. Introduced block structure, lexical scoping, BNF grammar notation. Never widely used commercially but influenced nearly every subsequent language.
- BASIC (1964)
- Kemeny and Kurtz at Dartmouth made programming accessible to non-scientists. Later: Microsoft BASIC launched Gates/Allen empire; Visual Basic dominated 1990s business apps.
- SIMULA (1967)
- First object-oriented language (Dahl & Nygaard, Norway). Introduced classes, objects, inheritance, and virtual methods. Direct ancestor of C++, Java, C#.
- APL (1966)
- Iverson's "A Programming Language" -- incredibly terse, symbol-heavy notation for array processing. Influenced MATLAB, NumPy, J, K (used in finance).
- Logo (1967)
- Papert's educational language with "turtle graphics." Taught programming to millions of children. Influenced Scratch and modern CS education.
- BCPL (1967)
- Martin Richards' typeless systems language. Led to B (Thompson, 1969) and then C. The curly-brace tradition starts here: { }.
- 8 / 32

### Slide 9: Structured Programming Revolution

- In 1968, Edsger Dijkstra published "Go To Statement Considered Harmful," igniting a revolution in how programs were organized. Structured programming replaced spaghetti code with disciplined control flow.
- Core Principles
- Only three control structures needed: sequence, selection (if/else), iteration (while/for)
- GOTO considered harmful -- leads to unreadable, unmaintainable code
- Top-down design: decompose problems into procedures/functions
- Single entry, single exit for each block
- Bohm-Jacopini theorem: any algorithm expressible with these three structures
- Impact on Languages
- Pascal (1970): Wirth's teaching language embodying structured programming
- C (1972): Practical structured language for systems programming
- Modula-2 (1978): Added modules (encapsulation) to structured programming
- Older languages retrofitted: FORTRAN 77 added structured constructs
- Foundation for all subsequent methodology (OOP, functional, etc.)
- "The quality of programmers is a decreasing function of the density of go to statements in the programs they produce." -- Edsger Dijkstra, 1968
- 9 / 32

### Slide 10: C (1972)

- Dennis Ritchie created C at Bell Labs as a systems programming language to rewrite Unix. It became the most influential language in history: fast, portable, minimal, and the ancestor of C++, Java, C#, JavaScript, Go, Rust, and many more.
- Why C Won
- Abstraction without overhead: close to hardware yet portable
- Unix rewritten in C (1973) -- proved systems could be written in high-level language
- Minimal runtime: no garbage collector, no heavy standard library
- Pointer arithmetic: direct memory manipulation when needed
- "Portable assembly" -- compiles efficiently on any architecture
- K&R book (1978): model of clarity; defined the language's culture
- C's Legacy Today
- Linux kernel: 27+ million lines of C
- Windows, macOS kernels primarily C
- Python, Ruby, PHP interpreters written in C
- Embedded systems: 70%+ of firmware in C
- Still #1 or #2 in TIOBE index after 50+ years
- Every major OS, database, and network protocol implemented in C
- #include <stdio.h>
- int main(void) {
- printf("Hello, World!\n");
- return 0;
- 10 / 32

### Slide 11: Smalltalk & OOP Origins

- Alan Kay's Smalltalk (1972, public 1980) at Xerox PARC defined object-oriented programming as a paradigm. Everything is an object. Every interaction is a message. It also invented the GUI, IDE, and MVC architecture.
- OOP as Kay Intended
- "Objects" are like biological cells: encapsulated, communicating via messages
- Late binding: the receiver decides how to handle each message
- Everything is an object -- even numbers, booleans, classes, blocks
- No primitive types, no control structures outside message sending
- "I invented the term OOP and C++ is not what I had in mind" -- Alan Kay
- Beyond the Language
- Invented the modern IDE (browser, debugger, workspace)
- MVC pattern (Model-View-Controller) originated here
- Influenced: Objective-C, Ruby, Python, Self, Java
- Live coding environment: change code while program runs
- Pharo/Squeak: active open-source Smalltalk implementations today
- "The best way to predict the future is to invent it." -- Alan Kay, Xerox PARC, 1971
- 11 / 32

### Slide 12: SQL & Declarative Languages

- SQL (1974, standardized 1986) introduced declarative programming to the mainstream: you describe WHAT you want, not HOW to get it. The database engine figures out the execution strategy. This idea powers most of the world's data infrastructure.
- SQL's Revolution
- Based on relational algebra (Codd, 1970)
- Declarative: "SELECT name FROM users WHERE age > 30"
- Query optimizer finds best execution plan automatically
- Standardized across vendors (mostly): Oracle, PostgreSQL, MySQL, SQL Server
- 40+ years later, still the universal data language
- Other Declarative Languages
- Prolog (1972): Logic programming; AI, expert systems, NLP
- HTML/CSS: Declare structure and style; browser handles rendering
- Regular expressions: Declare patterns; engine finds matches
- Make/Terraform/Kubernetes YAML: Declare desired state
- React (JSX): Declare UI; framework handles DOM updates
- -- SQL: Find top 5 customers by revenue this year
- SELECT c.name, SUM(o.amount) as total
- FROM customers c
- JOIN orders o ON c.id = o.customer_id
- WHERE o.date >= '2026-01-01'
- GROUP BY c.name
- ORDER BY total DESC
- LIMIT 5;
- 12 / 32

### Slide 13: Ada, Pascal & Software Safety

- As software grew mission-critical (avionics, nuclear, medical), languages emerged that prioritized correctness and safety over programmer convenience. Ada (1983) remains mandatory for US defense systems.
- Pascal (1970)
- Niklaus Wirth's teaching language for structured programming
- Strong typing, clear syntax, enforced discipline
- Turbo Pascal (Borland, 1983): made it practical (fast compiler, IDE)
- Delphi (Object Pascal): dominated Windows RAD development in 1990s
- Legacy: influenced Ada, Modula, Oberon
- Ada (1983)
- US DoD commissioned it (named after Ada Lovelace)
- Strong typing, range checking, tasking (concurrency), generics
- Mandatory for safety-critical: fighter jets, missiles, nuclear plants, trains
- SPARK subset: formally provable correctness (no runtime errors possible)
- Boeing 777 fly-by-wire, Airbus A380, ISS software
- The Ariane 5 Lesson (1996): A 64-bit float converted to 16-bit integer overflowed, crashing a $370M rocket 37 seconds after launch. Ada's range-checking was disabled for performance. The disaster proved that language safety features exist for a reason.
- 13 / 32

### Slide 14: C++ (1979/1985)

- Bjarne Stroustrup added object-oriented features to C, creating "C with Classes" (1979), later renamed C++ (1983). It became the dominant language for performance-critical software: games, browsers, operating systems, databases, and compilers.
- Design Philosophy
- "Zero-overhead abstraction" -- you don't pay for what you don't use
- Compatible with C (mostly) -- reuse existing C code and libraries
- Multi-paradigm: procedural, OOP, generic, functional (modern C++)
- Direct hardware access when needed; abstractions when wanted
- Standardized: C++11/14/17/20/23 added major features
- C++ Everywhere
- Game engines: Unreal Engine, Unity internals, id Tech
- Browsers: Chrome, Firefox, Safari rendering engines
- Databases: MySQL, MongoDB, Redis
- Finance: high-frequency trading systems (nanosecond latency)
- Adobe suite, Microsoft Office, Photoshop, AutoCAD
- Machine learning: TensorFlow, PyTorch backends in C++
- // Modern C++20
- #include <ranges>
- #include <vector>
- auto squares = std::views::iota(1, 100)
- | std::views::filter([](int n){ return n % 2 == 0; })
- | std::views::transform([](int n){ return n * n; });
- 14 / 32

### Slide 15: The Functional Renaissance

- Functional programming -- treating computation as evaluation of mathematical functions without side effects -- experienced waves of innovation from the 1970s through today, profoundly influencing all modern languages.
- ML / OCaml (1973)
- Robin Milner's ML introduced type inference: the compiler deduces types without annotations. Hindley-Milner type system. OCaml used at Jane Street (finance), Facebook (Hack, Flow).
- Haskell (1990)
- Pure functional, lazy evaluation, powerful type system with type classes. "Avoid success at all costs." Influenced: Rust (traits), Swift (protocols), modern JavaScript (promises, map/filter).
- Erlang (1986)
- Ericsson's language for telecom: lightweight processes, message passing, "let it crash" philosophy. 99.9999999% uptime (AXD301 switch). Basis for Elixir, WhatsApp backend.
- Functional Ideas That Won: First-class functions, immutability, pattern matching, map/filter/reduce, option types, algebraic data types, and type inference are now in Java, C#, Python, JavaScript, Rust, Swift, and Kotlin. The mainstream adopted functional programming piecemeal rather than wholesale.
- 15 / 32

### Slide 16: Perl & the Scripting Revolution (1987)

- Larry Wall's Perl -- the "Swiss army chainsaw" -- pioneered practical scripting: text processing, system administration, and later web CGI. It proved that developer productivity often matters more than execution speed.
- Scripting Languages Key Traits
- Interpreted (no compilation step): edit, run, repeat instantly
- Dynamic typing: no type declarations needed
- Built-in regex, string manipulation, file I/O
- Glue languages: connect existing programs and systems
- "Getting things done" over theoretical elegance
- The Scripting Family
- sh/bash (1971/1989): Unix shell scripting; still ubiquitous
- AWK (1977): Text processing; influenced Perl
- Perl (1987): "Duct tape of the internet"; CGI era king
- Tcl (1988): Embeddable; Tk GUI toolkit
- Python (1991), Ruby (1995), PHP (1995): Next generation
- Lua (1993): Tiny embeddable scripting (games, Redis)
- "There's more than one way to do it." -- Larry Wall (Perl motto)
- 16 / 32

### Slide 17: Python (1991)

- Guido van Rossum created Python emphasizing readability and simplicity. Its "batteries included" philosophy and gentle learning curve made it the world's most popular language by the 2020s, dominating AI/ML, data science, web backends, and education.
- Most popular (TIOBE 2024-26)
- 8.2M
- Developers worldwide
- 500K+
- PyPI packages
- Years old
- Why Python Won
- Readability: enforced indentation, clean syntax, reads like pseudocode
- Gentle learning curve: first language for millions
- Ecosystem: NumPy, Pandas, scikit-learn, TensorFlow, Django, Flask
- Glue language: easy C/C++ bindings (NumPy, Cython)
- "There should be one obvious way to do it" -- Zen of Python
- Domains
- AI/ML: PyTorch, TensorFlow, Hugging Face -- Python is THE language
- Data Science: Pandas, Jupyter notebooks, matplotlib
- Web: Django, Flask, FastAPI
- Automation: DevOps, scripting, testing
- Education: Most-taught first language worldwide
- 17 / 32

### Slide 18: Java (1995)

- "Write once, run anywhere." James Gosling's Java at Sun Microsystems promised platform independence through the JVM. It became the enterprise standard, Android's language, and remains one of the most-used languages decades later.
- Key Innovations
- JVM: Compile to bytecode; run on any platform with a JVM
- Garbage collection: Automatic memory management (no manual free())
- Strong static typing: Catch errors at compile time
- Robust standard library: Collections, networking, threading, I/O
- Security model: Sandboxing (originally for applets)
- Java's Empire
- Enterprise: Spring, Hibernate, Jakarta EE dominate backend
- Android: Primary language until Kotlin (2017); still massive codebase
- Big Data: Hadoop, Spark, Kafka, Elasticsearch all JVM
- Financial services: most bank backends
- JVM platform: hosts Kotlin, Scala, Clojure, Groovy
- 18 / 32

### Slide 19: JavaScript (1995)

- Brendan Eich created JavaScript in 10 days at Netscape. Despite its rushed origins and well-known quirks, it became the most deployed programming language in history -- the only language that runs natively in every web browser.
- The Accidental Lingua Franca
- Created in 10 days (May 1995) under pressure from Netscape management
- Name chosen for marketing (capitalize on Java hype); technically unrelated
- Prototype-based OOP (from Self); first-class functions (from Scheme)
- Standardized as ECMAScript (1997); evolved slowly, then rapidly (ES6/2015+)
- Only language guaranteed in all browsers -- a monopoly by accident
- JavaScript Everywhere
- Frontend: React, Vue, Angular, Svelte (all UI frameworks)
- Backend: Node.js (2009) -- V8 engine outside browser
- Mobile: React Native, Ionic, Capacitor
- Desktop: Electron (VS Code, Discord, Slack)
- Serverless: AWS Lambda, Cloudflare Workers
- ~98% of websites use JavaScript
- // Modern JavaScript (ES2024)
- const results = await Promise.all(
- urls.map(url => fetch(url).then(r => r.json()))
- const names = results.flatMap(r => r.users).map(u => u.name);
- 19 / 32

### Slide 20: Ruby & PHP: Web's Workhorses

- Ruby (1995) and PHP (1995) powered the Web 2.0 era. PHP dominated server-side web development through sheer accessibility, while Ruby on Rails (2004) pioneered conventions that reshaped web frameworks everywhere.
- Ruby
- Yukihiro Matsumoto: "optimized for programmer happiness"
- Elegant OOP: everything is an object, blocks, metaprogramming
- Ruby on Rails (2004): "Convention over Configuration" -- built Twitter, GitHub, Shopify, Basecamp
- Influenced: Elixir's syntax, Swift, CoffeeScript
- Less dominant now but still beloved; ~1M developers
- PHP
- Rasmus Lerdorf (1995): started as "Personal Home Page Tools"
- Embed code directly in HTML; easiest path to dynamic websites
- Powers 77% of websites with known server-side language
- WordPress (43% of all websites), Wikipedia, Facebook (Hack variant)
- Modern PHP (8.x): type system, JIT compiler, enums, fibers -- much improved
- 20 / 32

### Slide 21: C# & .NET (2000)

- Microsoft's answer to Java, designed by Anders Hejlsberg (who also created Turbo Pascal and TypeScript). C# evolved into one of the most feature-rich languages, while .NET became a cross-platform runtime rivaling the JVM.
- C# Innovations (Pioneered for Mainstream)
- Properties (getter/setter as first-class feature)
- LINQ (Language Integrated Query): SQL-like syntax in code
- async/await (2012): made asynchronous programming accessible -- copied by JS, Python, Rust, etc.
- Nullable reference types, pattern matching, records
- Unity game engine: C# is #1 game development language
- .NET Ecosystem
- .NET Core/5+: fully cross-platform (Linux, macOS, Windows)
- ASP.NET: enterprise web framework; powers Stack Overflow
- Xamarin/MAUI: cross-platform mobile development
- Blazor: C# in the browser (WebAssembly)
- F#: functional language on .NET (OCaml-inspired)
- 21 / 32

### Slide 22: Go (2009)

- Created at Google by Rob Pike, Ken Thompson (Unix co-creator), and Robert Griesemer, Go was designed for the cloud era: simple, fast compilation, built-in concurrency, and excellent tooling. It powers much of modern cloud infrastructure.
- Design Philosophy
- Radical simplicity: 25 keywords; no classes, no generics (until 1.18), no exceptions
- Fast compilation: large projects compile in seconds
- Goroutines: lightweight concurrent functions (millions per process)
- Channels: safe communication between goroutines (CSP model)
- Single static binary: no runtime dependencies to deploy
- gofmt: one true style -- no formatting debates
- Go's Domain
- Docker: Container runtime written in Go
- Kubernetes: Container orchestration in Go
- Terraform: Infrastructure as code
- Prometheus, Grafana, etcd: Cloud-native observability
- CockroachDB, InfluxDB: Distributed databases
- The default language for cloud infrastructure and DevOps tools
- 22 / 32

### Slide 23: Rust (2010/2015)

- Mozilla's Rust solved a 50-year-old problem: memory safety without garbage collection. Its ownership system guarantees no null pointers, no data races, and no use-after-free -- at compile time, with zero runtime cost. Voted "most loved language" 7 years running.
- The Ownership Innovation
- Every value has exactly one owner; ownership can be transferred (moved) or borrowed
- Borrow checker enforces rules at compile time -- no runtime overhead
- No null: Option<T> forces explicit handling of absence
- No data races: type system prevents shared mutable state
- "If it compiles, it probably works" -- community saying
- Rust Adoption
- Linux kernel (2022): first new language accepted besides C
- Android: 2022+ new code; memory bugs dropped 76%
- Windows: Microsoft rewriting core components in Rust
- AWS: Firecracker (Lambda runtime), Bottlerocket OS
- Cloudflare, Discord, Dropbox, Meta: production Rust
- WebAssembly: Rust is the dominant source language for Wasm
- // Rust: ownership prevents data races at compile time
- fn main() {
- let s = String::from("hello");
- let r = &s; // immutable borrow -- safe
- println!("{r}");
- // let m = &mut s; // ERROR: can't borrow mutably while immutably borrowed
- 23 / 32

### Slide 24: Swift & Kotlin: Modern Platform Languages

- Apple's Swift (2014) and JetBrains' Kotlin (2011/Google-endorsed 2017) replaced aging predecessors (Objective-C and Java) with modern, safe, expressive alternatives while maintaining full interoperability.
- Swift
- Replaced Objective-C for Apple platforms (iOS, macOS, etc.)
- Protocol-oriented programming (Haskell type classes + OOP)
- Optionals: null safety baked into the type system
- Value types (structs) preferred over reference types
- Swift on Server growing (Vapor framework)
- Open source since 2015; Linux support
- Kotlin
- Google's preferred language for Android (2017+)
- Full Java interop: call Java from Kotlin and vice versa
- Null safety: nullable types explicit (String? vs String)
- Coroutines: structured concurrency (influenced by Haskell, Go)
- Kotlin Multiplatform: share code across Android, iOS, web, server
- Concise: ~40% less code than equivalent Java
- 24 / 32

### Slide 25: TypeScript (2012)

- Anders Hejlsberg (again) created TypeScript at Microsoft: a strict superset of JavaScript that adds optional static types. It solved JavaScript's scalability problem -- large codebases become unmaintainable without types. By 2025, most new JavaScript projects use TypeScript.
- Why TypeScript Won
- Gradual typing: adopt incrementally, file by file
- 100% JavaScript compatibility: valid JS is valid TS
- IDE support: autocomplete, refactoring, error detection
- Type inference: writes types for you in many cases
- Advanced type system: generics, mapped types, conditional types, template literals
- TypeScript Adoption
- Angular, Vue 3, Svelte: built with/for TypeScript
- VS Code, Slack, Figma: built in TypeScript
- Next.js, Nuxt, Remix: TypeScript-first frameworks
- Deno: TypeScript native runtime (no transpilation step)
- ~78% of JS developers use TypeScript (2025 survey)
- 25 / 32

### Slide 26: Programming Paradigms

- Languages embody different philosophies about how to structure computation. Most modern languages are multi-paradigm, borrowing ideas from several traditions.
- Imperative
- Step-by-step instructions changing state. The oldest and most intuitive paradigm. Assembly, C, Go. "Do this, then do that."
- Object-Oriented
- Organize code around objects that encapsulate data and behavior. Java, C#, Python. "Tell objects to do things."
- Functional
- Compute by evaluating pure functions without side effects. Haskell, Clojure, Elixir. "Transform data through functions."
- Declarative
- Describe what you want, not how. SQL, HTML/CSS, Prolog, React. "Specify the goal; system finds the path."
- Logic
- Express facts and rules; system derives conclusions. Prolog, Datalog, Answer Set Programming. "State the constraints; solve."
- Concurrent/Actor
- Model computation as communicating processes. Erlang, Go (goroutines), Akka. "Independent actors exchanging messages."
- 26 / 32

### Slide 27: Type Systems

- A language's type system is perhaps its most important design decision. It determines when errors are caught, how expressive the code can be, and what guarantees the compiler provides.
- Static vs. Dynamic
- Static: Types checked at compile time (Java, Rust, Haskell, TypeScript)
- Dynamic: Types checked at runtime (Python, Ruby, JavaScript, Lisp)
- Gradual: Optional static types (TypeScript, Python 3.5+ type hints, Hack)
- Trade-off: safety vs. flexibility vs. development speed
- Trend: industry moving toward static/gradual typing
- Advanced Type Features
- Type inference: Compiler deduces types (ML, Rust, Kotlin, Swift)
- Algebraic data types: Sum types + product types (Rust enum, Haskell data)
- Generics: Parameterize types (List<T>) -- Java, C#, Rust, Go 1.18+
- Dependent types: Types that depend on values (Idris, Agda, Lean) -- cutting edge
- Linear/affine types: Track resource usage (Rust ownership, Clean uniqueness)
- 27 / 32

### Slide 28: Concurrency Models

- As CPUs stopped getting faster and grew more cores, concurrency became essential. Languages took fundamentally different approaches to the problem of coordinating parallel execution safely.
- Threads + Locks
- Traditional approach (C, C++, Java). Shared memory with mutex/semaphore protection. Powerful but error-prone: deadlocks, race conditions, priority inversion.
- Message Passing
- Actors/processes communicate via messages (Erlang, Go channels, Akka). No shared state; sender and receiver decoupled. Scales well; easier to reason about.
- Async/Await
- Cooperative multitasking for I/O-bound work (C#, JS, Python, Rust). Single thread handles many tasks by yielding at await points. Efficient for web servers, APIs.
- Software Transactional Memory
- Database-like transactions for memory (Haskell STM, Clojure refs). Compose safely; retry on conflict. Elegant but limited adoption.
- Ownership (Rust)
- Type system prevents data races at compile time. Fearless concurrency: if it compiles, no races. Send/Sync traits control what crosses thread boundaries.
- Structured Concurrency
- Emerging pattern (Kotlin, Swift, Java 21): concurrent tasks form a hierarchy. Parent waits for children; errors propagate up. Prevents orphaned tasks.
- 28 / 32

### Slide 29: Domain-Specific Languages

- Not all languages are general-purpose. Domain-Specific Languages (DSLs) trade generality for expressiveness in a particular domain, often making experts vastly more productive.
- Data & Query
- SQL (databases)
- GraphQL (API queries)
- R (statistics)
- MATLAB (engineering math)
- Cypher (graph databases)
- Infrastructure
- Terraform HCL (cloud infra)
- Dockerfile (containers)
- Makefile (builds)
- Nix (package management)
- Ansible YAML (automation)
- Document & Markup
- HTML (web structure)
- CSS (styling)
- LaTeX (typesetting)
- Markdown (documentation)
- GLSL/HLSL (GPU shaders)
- Embedded DSLs: Many languages support creating DSLs within themselves: Ruby (Rails, RSpec), Kotlin (Gradle, Ktor), Scala (sbt, Spark SQL), Haskell (Parsec). The host language's syntax becomes the basis for a specialized mini-language.
- 29 / 32

### Slide 30: AI & the Future of Programming Languages

- Large language models are transforming how code is written, but not eliminating the need for programming languages. New languages continue to emerge, and AI is becoming both a tool for programmers and a consumer of programs.
- AI-Assisted Coding
- GitHub Copilot, Claude Code, Cursor: AI writes code from descriptions
- Types help AI: strongly-typed languages get better AI completions
- Test generation, refactoring, documentation -- AI handles tedium
- Natural language as interface layer OVER formal languages (not replacing them)
- Estimated 30-50% of code AI-assisted by 2026
- Emerging Languages & Trends
- Mojo (2023): Python superset for AI/ML with C-level speed
- Zig: Better C; no hidden allocations; comptime metaprogramming
- Carbon: Google's C++ successor experiment
- Effect systems: Track side effects in types (Koka, Effekt)
- Verified programming: Proofs alongside code (Lean 4, F*)
- Trend: safety, simplicity, composability over raw features
- "The limits of my language mean the limits of my world." -- Ludwig Wittgenstein (equally true for programming languages)
- 30 / 32

### Slide 31: Language Popularity Over Time

- EraDominant LanguagesDriving Forces
- 1950s-60sFORTRAN, COBOL, LISP, ALGOLScientific computing, business data processing
- 1970sC, Pascal, Smalltalk, SQLOperating systems, structured programming, databases
- 1980sC++, Ada, Objective-C, PerlOOP, safety-critical systems, scripting
- 1990sJava, JavaScript, Python, PHP, RubyWeb, platform independence, rapid development
- 2000sC#, Scala, Clojure, GoEnterprise, functional mainstream, cloud
- 2010sRust, TypeScript, Kotlin, SwiftSafety, type systems, mobile platforms
- 2020sPython (AI), Rust, TypeScript, GoAI/ML, memory safety, web scale
- 31 / 32

### Slide 32: Further Reading

- Books
- Concepts, Techniques, and Models of Computer Programming -- Van Roy & Haridi
- Structure and Interpretation of Computer Programs -- Abelson & Sussman (SICP)
- Programming Language Pragmatics -- Michael Scott
- Coders at Work -- Peter Seibel (interviews with language creators)
- A History of Programming Languages -- Wexelblat (HOPL proceedings)
- Online Resources
- HOPL Conference Papers: hopl4.sigplan.org
- The Computer Language Benchmarks Game: Performance comparisons
- Learn X in Y Minutes: Quick syntax overviews (learnxinyminutes.com)
- Exercism.org: Practice 70+ languages with mentoring
- TIOBE / Stack Overflow Survey: Popularity and trends annually
- "A language that doesn't affect the way you think about programming, is not worth knowing." -- Alan Perlis, first Turing Award recipient (1966)
- 32 / 32


## Related Decks

- [AI & Machine Learning](https://shipslides.com/d/technology-ai-and-ml)
- [Artificial Intelligence: From Turing to Transformers](https://shipslides.com/d/technology-artificial-intelligence)
- [Biotechnology](https://shipslides.com/d/technology-biotech)
- [Blockchain Technology](https://shipslides.com/d/technology-blockchain)