Programming Isn't Math, It's Linguistics

About this video

• Video Title: Programming Isn't Math, It's Linguistics
• Channel: LaurieWired
• Speakers: Laurie (implied speaker, based on channel name and narration style)
• Duration: 00:30:15

Overview

This video argues that programming is fundamentally a linguistic challenge, not a mathematical one. The speaker explains how ambiguities, quirks, and interpretation issues inherent in human languages mirror those found in programming languages and their compilers. The video explores compiler theory, syntax, lexical, and semantic quirks through various examples, primarily in C++, and demonstrates how to resolve these ambiguities. It also touches upon the creation of custom parsers and formally defined languages.

Key takeaways

• Programming as Linguistics: The core argument is that the challenges in programming, particularly in communicating with compilers, are analogous to the ambiguities and complexities of human languages.
• Compiler Phases: Compilers parse code in three main stages: lexical analysis (breaking into tokens), parsing (building an abstract syntax tree and finding syntax errors), and semantic analysis (checking for logical correctness and type consistency).
• Types of Ambiguity: The video highlights several types of ambiguities:
  • Syntactic Ambiguity: When a token can fit into multiple parse trees (e.g., the "most vexing parse" in C++).
  • Dangling Else: Ambiguity in associating an else statement with its corresponding if.
  • Lexical Ambiguity: When characters or tokens can be interpreted in multiple ways, often due to context or lack thereof (e.g., nested generics in C++98 requiring spaces).
  • Semantic Ambiguity: Issues related to the meaning of code, often requiring explicit clarification (e.g., dependent type names, distinguishing between "Polish" and "polish").
• Resolving Ambiguities: The video demonstrates how explicit syntax, modern language features (like C++11's curly braces for initialization), and specifying types (using typename or template keywords) help compilers resolve these ambiguities.
• Formal Languages: The speaker briefly touches on formal language theory and examples of languages designed to minimize ambiguity, such as ASD STE 100 (Simplified Technical English) and Lisp.
• Custom Parsers: Writing a custom parser, as demonstrated with "Remmbercript," offers a practical way to understand the challenges and power of defining custom syntax and tokens.