CSC4010: Principles of Programming Languages

Static typing means the type of every variable and expression is determined and checked at compile time, before the program runs. Java, C++, and Rust use static typing. If you try to assign a string to an integer variable in Java, the compiler rejects the code before it ever executes. Dynamic typing means type checking happens at runtime: Python and JavaScript let you assign any value to any variable, and type errors only surface when the problematic code actually runs. The practical consequence is a trade-off between safety and flexibility. Static typing catches entire categories of bugs early (null reference errors, type mismatches, API contract violations), enables better IDE support (autocompletion, refactoring), and typically produces faster executables because the compiler knows exact types. Dynamic typing allows faster prototyping, more concise code, and patterns like duck typing that would require complex generics in statically typed languages. CSC4010 assignments often ask students to analyze a specific scenario and argue which typing discipline provides greater net benefit, supporting the argument with concrete examples of bugs caught or flexibility gained.

An interpreter is a program that reads source code in a programming language and executes it directly, without first compiling it to machine code. In CSC4010, students build an interpreter for a simple bespoke language that the course defines. The project typically involves four stages. First, you build a lexer (scanner) that reads raw source text and breaks it into tokens: keywords, identifiers, operators, literals, and delimiters. Second, you build a parser that takes the token stream and constructs an abstract syntax tree (AST) according to the language's grammar rules, usually expressed in BNF. Third, you implement an evaluator (or tree-walk interpreter) that traverses the AST and executes each node: evaluating expressions, executing statements, handling variable assignments, and managing control flow. Fourth, you implement an environment or symbol table that tracks variable bindings and handles scoping. The project synthesizes nearly every concept in the course: formal syntax (the grammar your parser implements), semantics (how your evaluator assigns meaning to constructs), binding and scoping (how your environment manages variable visibility), and typing (how your evaluator handles type checking or coercion at runtime).

Parameter passing determines how arguments are transmitted from a caller to a function. Pass-by-value copies the argument's value into the parameter, so changes inside the function do not affect the caller's variable. C uses pass-by-value for primitives, and Java uses pass-by-value for everything (including object references, which means the reference itself is copied, not the object it points to). Pass-by-reference gives the function direct access to the caller's variable through an alias, so modifications inside the function change the original. C++ supports explicit pass-by-reference using the ampersand (&) syntax. Pass-by-name, used historically in Algol 60, substitutes the argument expression itself into the function body and evaluates it each time the parameter is referenced, which can produce surprising results with side effects. Pass-by-value-result (copy-in/copy-out) copies the value in at the start and copies the modified value back at the end, which differs from pass-by-reference when aliasing occurs. Understanding these mechanisms matters because they affect whether functions can produce side effects, how memory is used, and how concurrent programs behave when multiple threads share data.

Rust introduced an ownership system that manages memory without garbage collection and without requiring manual allocation and deallocation. Every value in Rust has exactly one owner (a variable), and when that owner goes out of scope, the value is automatically dropped (freed). Values can be moved (transferring ownership) or borrowed (creating temporary references). Borrowing follows two rules enforced at compile time: you can have either one mutable reference or any number of immutable references to a value at any given time, but never both simultaneously. These rules eliminate data races (two threads writing to the same memory), dangling pointers (references to freed memory), and double frees (freeing memory twice) at compile time rather than at runtime. The significance for programming language design is that Rust demonstrated a third path between manual memory management (C/C++, where developers must track allocations and frees, leading to bugs) and garbage collection (Java, Python, Go, where a runtime system periodically reclaims unused memory, adding overhead and unpredictable pauses). CSC4010 uses Rust as a case study in how type system innovations can solve systems-level problems that were previously considered inherent trade-offs in language design.