Seven Obscure Languages in Seven Weeks

Rediscovering the Tools That Built the Future

by Dmitry Zinoviev

Explore seven older computer languages and discover new and fresh ideas that will change the way you think about programming. These languages were invented before we settled into our current C-style syntax and OO biases, so language designers were free to imagine what was possible. You’ll find their insights thought-provoking, and their ideas will inspire you to try different (and possibly more productive) ways of programming. From a text manipulation language where every line is a potential state machine event, to a concurrent language where everything is done using actors, you’re sure to come away from these seven languages inspired and excited.

Seven old languages; dozens of new ideas that can help shape the way we think about programming.

Have you noticed that most programming languages look the same nowadays? We’ve become complacent; we’ve fallen into a rut. We’re no longer innovating; we’re tinkering at the margins.

Fifty years ago, things were less settled. Smart people exercised their imaginations and came up with programming paradigms that will blow you away. Classes and objects, first seen in the 1960s with Simula, are still in use. But what about a language with no variables? Or one where the units of computation are independent actors? Or where every single character can express a complex operation? Imagine a language where the only flow control comes from matching patterns, or one that uses sets as its major datatype. Or how about a textual language based on macros?

These seven old, obscure languages will open your eyes to new ways of thinking about programming, and change the way you code today.

• Errata, typos, suggestions

• Source Code (zip file)

Releases:

• P1.0 2024/10/16
• B4.0 2024/09/26
• B3.0 2024/07/30
• B2.0 2024/04/04

• Preface
• Introduction
  • About the Languages
  • About the Tips
  • About You
  • About the Software
  • Writing Something Big
  • Further Reading
  • Online Resources
  • What to Do Next?
• Mastering Stack-Based Computing with Forth
  • Understanding Stack Essentials
  • Writing Comments and ``Hello, World!’’
  • Learning Predefined Forth Words
  • Dissecting Flow Control
  • Discovering Recursion
  • Arriving to Memory Operations
  • Demystifying Vectored Execution
  • Handling Errors and Exceptions
  • Exploring Character and String Operations
  • Performing Input/Output Operations
  • Writing Something Big
  • Further Reading
• Appreciating Concurrent Computing with Occam
  • Paying Tribute to Transputer
  • Greeting in Occam and KRoC excerpt
  • Studying Variables and Data Types
  • Navigating Channels
  • Exploring Processes
  • Taming Construction Processes
  • Revisiting Deadlocks
  • Introducing Arrays
  • Crafting Channel Protocols
  • Arranging Code in Compilation Units
  • Replicating Processes
  • Terminating a Distributed Application
  • Configuring Occam Programs
  • Writing Something Big
  • Further Reading
• Embracing Array-Centric Programming with APL excerpt
  • Deciphering APL Character Set
  • Activating the APL Keyboard Layout
  • Looking at Data Types
  • Executing Scalar Operations
  • Mastering Array Operations
  • Performing Input and Output
  • Creating User-Defined Functions
  • Branching
  • Adding More Array Operations
  • Working with Workspaces
  • Writing Something Big
  • Further Reading
• Unveiling Object-Oriented Programming with Simula excerpt
  • ``It’s ALGOL!’’
  • Glancing at Variables, Data Types, and Operators
  • Investigating Control Structures
  • Introducing Procedures
  • Managing File I/O
  • ``It’s Simula!’’
  • Switching to Object-Oriented Programming
  • Designing Coroutines
  • Introducing Computer Simulation
  • Writing Something Big
  • Further Reading
• Streamlining Text Processing with SNOBOL
  • Processing Lines
  • Exploring Statements
  • Constructing Patterns
  • Using Indirect References
  • Understanding Functions and Predicates
  • Comprehending Data Structures
  • Evaluating Unevaluated Expressions
  • Managing Input and Output
  • Writing Something Big
  • Further Reading
• Harnessing Set Data with Starset
  • ``Hello, Sets!’’
  • Getting to Know Starset Data Types
  • Exploring Loops
  • Designing Subroutines
  • Writing Something Big
  • Further Reading
• Automating Text Generation with m4
  • Understanding Preprocessors
  • Defining and Using Macros
  • Controlling Execution Flow
  • Handling Text
  • Diverting Output and Including Files
  • Interacting with the System
  • Writing Something Big
  • Further Reading
  • The End of Week Seven