technologybriefs
Saved
Software

C (programming language)

Dennis Ritchie · 1972

C didn’t make programming safer—it made systems portable, and that changed everything.

Worth your time?4.5/5Yes.Study the whole thing.What works, what does not, who it is for ↓
8:46in productionCh. 1 · A successor, not a start/ 8:46 · ceiling 15 min
4 chapters · 8:46Ceiling 15:00

The brief is written and checked. The video joins this page when it is cut.4 chapters · 1 min read · 8:46 planned

Read the brief

C is a deliberately minimal, hardware-close language that enabled Unix to become portable. It trades safety and abstraction for control and efficiency—and that trade still defines systems programming.

SoftwareProgrammingAbstractionInventionProgramming across the network →
Chapters & takeaways4
  1. 0:50
    A successor, not a start

    C replaced B as Bell Labs’ system-level language, created by Ritchie in 1972 to build Unix tools.

  2. 2:01
    From tools to kernel

    C was used first for Unix utilities, then to rewrite the Unix kernel—fully in C by Version 4 Unix in November 1973.

  3. 3:42
    Two levels, one language

    C combines low-level control with high-level abstractions—structs, preprocessing, and hardware independence—by design.

  4. 5:09
    Portable by architecture, not decree

    C is not tied to any hardware, enabling cross-platform system software long before standardisation in 1989.

Worth your time?

Yes. Study the whole thing.

4.5/ 5
What works
  • cross-platform kernel implementation
  • low-overhead utility development
  • hardware-agnostic pointer arithmetic
  • preprocessor-based code composition
What does not
  • prevent buffer overflows
  • enforce memory safety
  • include garbage collection
  • standardise I/O beyond basic libc
Study it if
  • systems programmers
  • OS developers
  • embedded engineers
Skip it if
  • web application developers
  • data scientists
  • UI designers
The written brief1 min read

What it is and the problem it solves

C is a systems programming language designed to replace B. It solves the problem of writing portable, efficient Unix utilities and kernel code without resorting to assembly.

How it works

C maps constructs directly to machine instructions while abstracting hardware-specific details. It uses a preprocessor for file inclusion, adds struct types for data organisation, and compiles without heavy runtime support.

What works

C delivers predictable compilation, direct memory access, and hardware-agnostic abstractions like structs and pointers. Its design allows Unix to run on new hardware after recompilation—not rewriting.

What does not

C does not prevent memory errors, enforce type safety at runtime, or manage resources automatically. It offers no built-in concurrency model, no standard library for networking or graphics, and no module system beyond the preprocessor.

What it changes

C decouples system programming from assembly language. It enables Unix to be rewritten portably, establishes the template for systems languages, and makes cross-platform kernel and utility development feasible without sacrificing performance.

Is it worth your time

Yes—if you need portable, low-overhead system software. C remains relevant where control, predictability, and hardware proximity matter more than developer velocity or safety guarantees.

Same field · Software4 of 114
9:22
Unix shellThe Unix shell is the foundational programmable interface for Unix-like systems. It began as Ken Thompson’s 1971 Thompson shell at Bell Labs—introducing piping, GLOBbing, and if/goto control. It evolved through the Bourne shell (1979), which added here documents and command substitution, and the C shell (by Bill Joy), which introduced interactive features like history and job control. Its lineage traces to Louis Pouzin’s RUNCOM and Glenda Schroeder’s Multics shell. It works by parsing text, executing binaries, and composing them via pipes and expansions. It succeeds as a minimal, composable language for automation—but fails as a safe, expressive, or ergonomic programming environment. It changed computing by making the OS interface itself a language, enabling system administration, scripting, and infrastructure-as-code decades before those terms existed. It remains worth your time because its mechanisms underpin modern DevOps, cloud tooling, and open-source infrastructure—even where hidden behind higher-level abstractions.
9:06
JavaScriptBrendan Eich · 1995JavaScript is the de facto client-side language of the web — not because it was well-designed for beginners, but because it shipped fast, ran everywhere, and locked in a runtime model no site could ignore.
9:41
BASICJohn Kemeny and Thomas Kurtz · 1964BASIC is a pedagogical tool, not a general-purpose language. It succeeded by narrowing scope — to Dartmouth, to undergraduates, to time-shared interaction, to FORTRAN II’s grammar stripped of complexity. Its value lies in what it excluded.
10:18
SmalltalkAlan Kay and team · 1972Smalltalk is a pure object-oriented language built for constructionist learning at Xerox PARC in the 1970s. Its first interpreter, Smalltalk-72, was written by Dan Ingalls in about 700 lines of BASIC for the Data General Nova in October 1972. It emerged from Alan Kay’s September 1972 bet that a message-passing core could fit on a page of code—and did so by the eighth morning. Smalltalk-80, released publicly in 1980, introduced foundational OOP ideas, featured an integrated development environment from inception, and established total reflection—both structural and computational. It has no primitive types: all values are objects, and all computation occurs via message passing. ANSI Smalltalk was ratified in 1998.
Up next in Technology

ChatGPT

2022 · 8:48

ChatGPT is not intelligence — it’s a prompt-to-output relay, optimised for speed, not truth.

Next brief →Back to Software
8:48