CS 375: Compilers: Online

CS 375 Class Web Page

Note: Links will be filled in after the lectures occur.

Lectures from Fall 2026

Lectures from Spring 2026

January 13, 2026:
- Pascal vs. C, Java; Languages and Costs
- Error Cost; Disk; Input Buffer
- Lexical Ambiguity; Double Buffering; Character Codes
- Getting Started; Allocating Token
January 15, 2026:
- C Strings in Tokens
- Number Conversion
- 10 bits = 3 decimal digits; Shift
- Floating Point Representation
- Floating Point Conversion; + is Not Associative
January 20, 2026:
- Number Conversion
- Issues with Numbers
- Hierarchy of Grammars
- Ambiguity
- Regular Expressions
January 22, 2026:
- lex; return() and yylval
- lex specifications
- lex rules
- Making token value from yytext; commentsinlex.txt
- Hierarchy of Parsers; Context Free Grammar
January 29, 2026:
- Context-Free Parsers; Derivation; Ambiguity
- Recursive Descent
- Unambiguous Grammar; Shift, Reduce
- Tree Form; Associativity; Reduce Code
February 3, 2026:
- Shift, Reduce Operations
- Operator Precedence Examples
- Operator Precedence: Parens, Associativity
- Unary Minus; Function Call, Subscript
- push and pop on Stack; Starter Files
- Recursive Descent
- Parser Options; yacc: Table Lookup
February 5, 2026:
- yacc and lex
- begin statement; if statement
- binop; Tracing for Observability
- Compound Statements; pasgram.txt
February 10, 2026:
- pasgram.txt ; Spelling Correction; Loops
- for loop; parse.h ; Symbol Table as Map
- Hash, Hash with Buckets
- Lexical Scoping; Built-in Symbols
February 12, 2026:
- Symbol Table; Constants and Enums
- Intension; Variable Lookup; Allocating Storage
- Alignment and Padding
- Program line; block Structure, Record
February 17, 2026:
- Identifiers and Symbol Table
- Record, Array
- Type Inference, Type Lattice
- References, Walk through Type Tree; 3 Steps
- Record vs. Array; Type of AREF operator
February 19, 2026:
- 3 Steps of Reference; Array Reference Tree
- Row-Major Order: Rightmost Subscript is Inner Loop
- Record: Offset Added to Existing AREF; Recursive Pointers
- References and Walk through Type Tree
- Static vs. Dynamic Type Checking
February 24, 2026:
- Static vs. Dynamic Type Checking; Sound
- Equality; == vs. .equals() in Java
- Structural Equivalence; Intermediate Code
- Quadruples and Reverse Polish
February 26, 2026:
- Absolute File and Loading
- Backpatching; Linking: Module Interactions
- Library; Relocation
- DLL = Dynamically Linked Library
March 3, 2026:
- Position-Independent Code; Math Functions; Newton-Raphson
- Approximate sqrt; Number Conversion for Output
- I/O Statements; Stack and Heap Storage
- Free List; Buddy System; malloc()
- Garbage Collection
- Roll-Your-Own Free List to Avoid GC
March 5, 2026:
- findtype(); Record Declarations
- Record References; Procedure Call is Expensive; Runtime Stack
- Interpreter; JVM; Code Generation Stack
- Code for progn, Assignment
March 10, 2026: Review for Midterm
- Record and Array Addressing
- Operator Precedence Parsing
- Hashing; Regular Expressions; Regular and Context Free
- Grammars and Languages
- Ambiguity; Languages that are Context Free
March 24, 2026:
- Trees for Array Reference
- Memory Hierarchy; Register Used Table
- Few Registers Are Needed; EAX vs. RAX
March 26, 2026:
- Variable Addressing; aref
- Arithmetic Operations
- Condition Code Register and Jumps
- Intrinsic Functions; If Statement
- If Statement Optimization
March 31, 2026:
- AREF Code; Pointers
- Call by Value, Call by Reference
- Java: Call by Value; Immutable
- C Macros; In-line Subroutine
April 2, 2026:
- Optimization; Pareto Distribution
- Partial Evaluation
- Expression Interpreter; Data Flow Analysis
April 7, 2026:
- Common Subexpressions; Dominator; Computed, Killed
- Available, Busy
- Error Detection; 4-color Theorem
- Def-Use Chain; Graph Coloring; Code Motion; Strip Mining
- Loop Indexing, Post-Increment
April 9, 2026:
- Memoization; Dynamic Expression Reuse; Store Multiple
- Multiple Condidion Codes; Cache Prefetch; Instruction Re-ordering
- Speculative Execution; Branch Prediction
- Register Windows for Subroutine Call; Simulation
- Information Hiding
April 14, 2026:
- Different Representations; Object Storage
- Class and Instance; Dynamic Dispatch
- Boxed Number: Arithmetic Causes Garbage; Roll-Your-Own Garbage Recycling
- Java Overloading; Inheritance of Data
April 16, 2026:
- Inherited Data as Stack
- Multiple Inheritance: Problems
- Optimizing OOP
- Getting Started on Code Generation
April 21, 2026:
- AST = Abstract Syntax Tree; Patterns
- Matching and Substitution
- Inlining Inherited Methods; Recursive Descent Parsing
April 23, 2026: Review for Final Exam
- Record and Array Addressing
- Languages and Grammars
- Optimization; OOP
- == in Java; Call by Reference, Value
- Optimization for Advanced Architectures; Reverse Polish
Lectures from Fall 2025
- August 26, 2025:
  - Pascal Syntax; Machine Language vs. Assembly; Cost
  - Double Buffering; Character Codes
  - Error Cost; Disk and Buffer; Lexical Ambiguity
  - Table Lookup; Tokens; Getting Started
- August 28, 2025:
  - token pointer; Strings in C
  - Case Sensitivity; Integer Conversion
  - Other Number Bases; Error Checking
  - Float: Integer with a Decimal Point
- September 2, 2025:
  - Floating Point
  - Floating Point Details
  - SNaN; Chomsky Hierarchy; Stack of Parsers
  - Context Free = Tree Grammar; Ambiguity
- September 4, 2025:
  - Stack of Parsers; Lexican Ambiguity
  - Ambiguity: Some String Has 2 Parse Trees
  - Finite Automaton; lex works by Table Lookup
  - Regular Expressions, Rules
  - 2 return values; lex rules
- September 9, 2025:
  - Float exponent range; lex: return(), yylval
  - lex example
  - yytext, yyleng; comments
  - strings; Hierarchy of Parsers
  - Context Free: Recursive
  - Context FreeLanguages
- September 11, 2025:
  - Statement, Expression; Derivation
  - Abstract Syntax Tree; Ambiguous vs. Unambiguous Grammar
  - Shift and Reduce Operations
  - Left Associativity
- September 16, 2025:
  - Shift and Reduce Operations, Form of Trees
  - Operator Precedence Examples
  - Operator Precedence Example; Push
  - Pop; Unary Operator, Funcall, Array Reference
  - Recursive Descent Parsing
  - Parser Options; Yacc: Table Driven Parser
- September 18, 2025:
  - Yacc; Synthesized Translation
  - Yacc Grammar; Test Files
  - begin ... end; if statement
  - segfault and debugging
  - Control Theory; Trace Vector
- September 23, 2025:
  - yacc parser; Tree Form and Pretty-Printer
  - segfault, Debugging; pasgram.txt; yacc -v parse.y
  - yacc Precedence; Grammar Conflicts
  - Errors, Spelling Correction, DWIM
  - for loop
- September 25, 2025:
  - Hashing, Hashing with Buckets
  - Calling findid(); Storage Allocation, Alignment
  - Hierarchy of Symbol Tables, Inheritance
  - Alignment: Bottom Address Bits Must be Zero
- September 30, 2025:
  - Symbolic Constants, Subranges
  - findtype(); Block Structure; pasgram.txt
  - Program Structure; Record Declaration
  - Array Size; Type Coercion
  - Type Lattice
- October 2, 2025:
  - Making Symbol Table Records; Variant Records
  - Declarations and Type Tree; 3 Steps
  - Record Reference; Array Reference
  - Canonical Form for AREF; Row-Major Order
  - Locality; Combining Structure References
- October 7, 2025:
  - References: Record and Array
  - 3 Steps in References; Java Array
  - Circular References; Types as Tree
  - Static and Dynamic; Runtime Type Representation
  - Typing Can Be Too Strong; Sound, Complete
  - Variant Records; Type Equivalence
- October 9, 2025:
  - Quadruples, Reverse Polish
  - Executing Reverse Polish; Loading Process; Intension
  - Backpatching
- October 14, 2025:
  - Linker: Gathering Needed Modules
  - Relocation Options
  - DLL for Shared Libraries; Math Functions
  - sqrt and Newton-Raphson Iteration
- October 16, 2025: Review for Midterm Exam
  - Record and Array Addressing
  - Operator Precedence Parsing
  - Hashing; Regular Expression Simplification
  - Regular vs. Context Free
  - Changing Grammar; BNF; Recursive Descent; Array Order
  - Nonterminal vs. Terminal
- October 23, 2025:
  - Records: findtype, instfields, nconc, instrec
  - Making Symbol Table Entry, reducedot, alignment
  - Number Conversion for Output
  - Compound I/O Statements; Heap
  - Returning Memory: Free List, Fragmentation
- October 28, 2025:
  - Tree for Array References
  - Garbage Collection
  - Maintaining Your Own Free List
  - Subroutine Call Is Expensive; Inlining
- October 30, 2025:
  - Point and Dot
  - Stack Frame, Stack Addressing
  - Interpreted Code; Code Generation Stack
  - Code Generation for Statements
  - Expressions: C version of genarith()
- November 4, 2025:
  - CPU and Memory; Expression Traversal
  - Immediate vs. Literal; Expression Generation
  - Optimizing Move; Register Pairing; Used Table
  - Not Many Registers Needed; RAX vs. EAX
  - Addressing Variable on Stack
- November 6, 2025:
  - Register USED Table; Stack Addressing; Operations
  - Condition Code and Jump Instructions
  - IF Statement Generation
  - Optimizing IF; Array Addressing on Stack
  - Pointer Addressing
- November 11, 2025:
  - Pointers; Special Functions p. 148
  - Call by Value, Call by Reference
  - Aliasing; Java == vs. .equals()
  - eq, == : Same Memory Location; Java Array
  - C Macros; In-line Function
- November 13, 2025:
  - Optimization; Partial Evaluation
  - Partial Evaluation Example; Code Motion
  - Control Flow Analysis: Dead Code
- November 18, 2025:
  - Dominator; Computed, Killed, Available
  - Error Detection from Data Flow; Def-Use Chain
  - Graph Coloring for Register Allocation
  - Strip Mining; Post-Increment
  - Memoization; Dynamic Data Flow
- November 20, 2025:
  - Pareto Distribution; Cache Prefetch
  - Branch Prediction; SPARC Register Stack
  - Object = Record + Pointer to Class; foo.bar is O(1)
  - Subclasses Inherit Methods, Instance Variables
- December 2, 2025:
  - Object, Class Hierarchy, Inheritance
  - Multiple Inheritance
- December 4, 2025: Review for Final Exam
  - Record, Array, Pointer
  - Grammar and Language
  - Available, Busy, Killed; OOP
  - Basic Block, Call by Reference/Value, Optimization
  - Architecture and Compiler; Array Reference Order
  - Java ==, Array; Static Storage, Stack, Heap
Lectures from Spring 2025
- January 14, 2025:
  - Lexer vs. Parser; Pascal vs. C
  - Machine Language, Assembly, Programmer Cost
  - Disk and Buffering; Lexical Ambiguity
  - Double Buffering; Character Codes; Tokens
- January 16, 2025:
  - C strings
  - Token fields; Numbers as Characters
  - Integer Number Conversion
  - Floating Point
- January 23, 2025:
  - Running lexanc; Float Representation
  - Float Conversion; Range Test
  - Floating +: Not Associative; SNaN
  - Chomsky Hierarchy; Hierarchy of Parsers
  - Ambiguity
- January 28, 2025:
  - Hierarchy of Parsers; Tree Grammar
  - lex
  - number; return vs yylval; commentsinlex.txt
  - yytext, yyleng
- January 30, 2025:
  - Context Free: Recursive, Counting
  - Derivation; Ambiguity Cases
  - Parser: Recursive Descent; Deep Structure
  - Unambiguous Grammar; Shift, Reduce
- February 4, 2025:
  - string in lex; Parser Options
  - Associativity; Shift and Reduce Operations
  - Operator Precedence Examples
  - Operator Precedence with Parens; Push, Pop
  - Starter Files; Unary Minus
  - Function Call, Array Reference
- February 6, 2025:
  - Recursive Descent
  - Yacc: begin ... end
  - binop(); Observability and Debug Bit Vector
- February 11, 2025:
  - Starting Parser Project
  - Loops: Flowchart
  - copytok(); scope
- February 13, 2025:
  - variable and findid(); Hashing
  - Hashed with Buckets; Lexical Scope, Levels of Symbol Table
  - Symbolic Constants, Subranges, Kinds of Blocks
  - Storage Allocation, Alignment, Padding
- February 18, 2025:
  - Variant Records
  - Array Size; Type Inference and Coercion
  - Type Lattice; Function Type
  - Structure References: 3 Steps; aref
- February 20, 2025:
  - Coercion; Type of funcall result
  - Blocks; Array Access
  - Locality, Row-Major Order
  - Circular References
  - Walk through Type Tree; Static, Dynamic
- February 25, 2025:
  - Installing Constants; Extra progns are OK; graph1i.pas
  - Static, Dynamic; Dynamic Type Checking; Tag Methods
  - Type Equivalence
  - Quadruples, Reverse Polish
  - Reverse Polish
- February 27, 2025:
  - Loading Process
  - CPU vs. Memory
  - Backpatching; Linking: Bringing in Modules
  - Relocation
- March 4, 2025:
  - type statement, findtype; Math Functions
  - sqrt and Newton-Raphson Iteration
  - I/O Statements; Maintaining a Free List
  - Reclaiming Unused Memory
- March 6, 2025:
  - Record Declaration
  - Type Declarations; Mark-and-Sweep Garbage Collection
  - Copying and Reference Counting Garbage Collection
  - Static vs. Dynamic Call Graph and Stack; Interpreted Code
- March 11, 2025: Review for Midterm
  - Records and Arrays
  - Operator Precedence Parsing
  - Hashing; Regular Expressions; Chomsky Hierarchy
  - Context Free: Balanced Parens; Language = Set of Strings
- March 25, 2025:
  - Array Reference
  - Code Generation: Arithmetic Expression
  - Immediate Data vs. Literal; Arithmetic in C
- March 27, 2025:
  - Multi-Dimensioned Array References
  - Register Allocation
  - Stack Addressing
- April 1, 2025:
  - Literal Data; genarith() for Operators
  - Condition Code and Jumps
  - Intrinsic Functions; IF Statement
  - IF Optimization; AREF Addressing
- April 3, 2025:
  - Getting Started on Code Generation
  - Stack Addressing; Pointer Code; Call by Value
  - Call by Reference; Java Objects
  - Aliasing, Call with Constant, == in Java
- April 8, 2025:
  - Register Allocation; Op Code Lookup
  - C Macros; Closed vs. In-Line Subroutine
  - Pareto Distribution; Optimize Loops
  - Induction Variable; Partial Evaluation
- April 10, 2025:
  - funcall and Floating Literals; Reduction Patterns
  - Partial Evaluation; Expression Interpreter
  - Global Optimization; Bit Vector for Finite Sets
- April 15, 2025:
  - Code Generation for AREF, Pointer, funcall
  - Basic Block; Dominator; Common Subexpressions
  - Available, Busy; Def-Use Chain; Graph Coloring
  - Graph Coloring; Strip Mining
- April 17, 2025:
  - AREF and Pointer
  - Post-increment; Memoization; Result Reuse in CPU
  - Condition Codes; Cache Prefetch; Branch Prediction
  - SPARC Register Stack; OOP
- April 22, 2025:
  - Object = Record + Class; Where to Put Tags
  - Ontology = Class Hierarchy; Adding Data, Inheriting Methods
  - Multiple Inheritance
- April 24, 2025: Review for Final Exam
  - Records and Arrays
  - Regular vs. Context Free
  - Optimization; Call by Reference, Value
  - Optimization, Left-Associative
Lectures from Fall 2024
- August 27, 2024:
  - Pascal vs. C; Cost of Programming
  - Disk; Character Buffer; Lexical Ambiguity
  - Double Buffering; Table Lookup; Character Codes
  - TOKEN Pointer
- August 29, 2024:
  - cs375 files; C strings
  - Identifier strings; Number Character Codes
  - Integer Number Conversion
  - Floating Number Conversion
  - Floating Number Representation
- September 3, 2024:
  - Floating Point; Context Free Grammar
  - Ambiguity; Chomsky Hierarchy
  - Lexer, Parset stack; lex
  - Regular Expressions
- September 5, 2024:
  - Regular Expressions; lex rules
  - return() and yylval; yytext; comments
  - Parser Levels; Context Free
  - Top-Down vs. Bottom-Up Parsing
- September 10, 2024:
  - Top-down Parsing; Parser options
  - Shift and Reduce Operations; Tree Form; Left Associativity
  - Floating Add Is Not Associative
  - Operator Precedence Parsing Examples
  - Parentheses; Push and Pop
- September 12, 2024:
  - Operator Precedence; Starter Files
  - Operator Precedence: Unary, Function Calls
  - Recursive Descent: Grammar Becomes Code
  - Shift-Reduce Parser; Sequence of Statements
  - Constructing Output for Begin Statement
- September 17, 2024:
  - Recycling Tokens
  - Parser Options; Begin Statement
  - If Statement; Building in Observability with Trace Vector
  - Edit Distance, Error Correction; Loop Test
- September 19, 2024:
  - for statement; while statement
  - Binding; Hashing
  - Hash with Buckets; Lexical Scoping
  - Pre-defined Symbols; Starter Files
- September 24, 2024:
  - symtab.txt ; Symbolic Constants, Subrange
  - var statement; block ordering
  - Stack Addressing
  - Address Alignment
  - Padding; Scope; Record References
- September 26, 2024:
  - Record Declaration
  - Array Size; Type Inforence for Operators
  - Type Lattice, Data Sizes; 3 Reference Steps
  - Array Reference and Canonical Form
  - Row-Major Order; Rightmost Subscript Should Be Inner Loop
- October 1, 2024:
  - Structure References: yacc Code, Record, Array
  - Combined Array and Record Reference
  - Circular References
  - References as Walk through Type Tree
  - Ways to Tag Variables; Sound, Complete
- October 3, 2024:
  - Variant Records (Union Types)
  - Java: Meaning of == vs. .equals()
  - Structural Eaquivalence; Intermediate Code
  - Quadruples; Peephole; Reverse Polish
- October 8, 2024:
  - Absolute File; Loader; Memory Banks
  - Backpatching; Collecting Files in Linker
  - Relocation Possibilities; DLL
- October 10, 2024:
  - Formatting Numbers for Output
  - Math Functions; Newton-Raphson Iteration
  - I/O Statements; Maintaing Your Own Free List
  - Buddy System; malloc(); Mark-and-Sweep; Copying
  - Reference Counting Garbage Collection
- October 15, 2024:
  - Function Call Stack
  - Interpreted Code; Code Generation Hierarchy
  - Code Generation for progn, Assignment
  - Code Generation for Expressions; Constants
- October 17, 2024: Review for Midterm
  - Record and Array Addressing
  - Operator Precedence Parsing
  - Hashing; Regular Expression; Grammars
  - Kinds of Grammar, Language
  - Context Free; Floating Point
- October 24, 2024:
  - Record Declarations: instfields, nconc, instrec
  - genarith; Constants and Literals
  - Memory Hierarchy; Register used table
  - Registers Needed; Data Flow
- October 29, 2024:
  - Structure Access; Pointer
  - Subrange, 1-D Array
  - RAX contains EAX; Stack Addressing
  - Arithmetic Instructions and genarith()
- October 31, 2024:
  - Structure References and Types
  - 2-D Array Reference
  - Condition Code Register and Jumps
  - Intrinsic Functions; IF statement
  - IF Optimization; Array Addressing
- November 5, 2024:
  - Call by Reference, Call by Value
  - Algol; C define: Textual Substitution
  - Closed vs. In-Line Subroutine
  - Pareto Distribution: Most Time Spent in Loops
  - Keeping Loop Index in a Register
- November 7, 2024:
  - Partial Evaluation
  - Use of Flow Graph; Bit Vectors to Represent Sets
  - Propagating Available through Graph; Un-Initialized Data
- November 12, 2024:
  - Def-Use Chain; Data Flow for Error Checking
  - Graph Coloring for Register Allocation; Hoisting
  - Strip Mining; Post-Increment
  - Memoization; Moving Code
  - Store Multiple; Multiple Condition Codes; Cache Prefetch
  - SPARC Register Stack and Windows
- November 14, 2024:
  - Getting Started on Code Generation
  - Object Oriented Programming
  - Dynamic Dispatch; Time and Space Overhead
- November 19, 2024:
  - Object = Record + Class Designator
  - Basic Types as Objects; Extending Data
  - Inheritance, Shadowing, vtable
  - Multiple Inheritance Causes Problems
- November 21, 2024:
  - OOP Implementation; Pattern Matching
- December 3, 2024:
  - Saving Register for funcall
  - Starting Code Generation
  - Substitute, Match, Transform
  - Top-down, Recursive Descent Parser
- December 5, 2024: Review
  - Array, Record, Pointer Addressing
  - Grammar and Chomsky Hierarchy
  - Local Optimization; Avaiable, Busy; OOP Overhead
  - Basic Blocks; Call by Reference, Value
  - Architecture and Compiler; Ambiguity; Reverse Polish
Lectures from Spring 2024
- January 16, 2024:
  - Pascal vs. C
  - Cost of Programmer, cost of Bugs
  - Disk and Input Buffering; Double Buffering
  - Character Codes; Table Lookup; Pointer to Token
- January 18, 2024:
  - Strings in C
  - Number Conversion ...
  - Number Conversion
  - Floating Point Numbers
- January 23, 2024:
  - Floating Point: Accuracy
  - Floating Point Add is Not Associative
  - SNaN; Chomsky Hierarchy of Grammars/Languages
  - Context Free: Tree Grammar; Ambiguity and IF
- January 25, 2024:
  - Hierarchy of Parsers; Ambiguity
  - lex Examples; Finite State Machine
  - lex Definitions
  - lex return vs. yylval; comments; making tokens
- January 30, 2024:
  - Hierarchy of Parsers; Context Free
  - Derivation; Top-Down Parsing
  - Expressions: Precedence, Addociativity; Shift
- February 1, 2024:
  - Tree Form; Operator Precedence Example
  - Operator Precedence Examples
  - Associativity; Stack Operations in C
  - Other Considerations in Expressions
  - Function Call; Parser Options
  - Recursive Descent Parsing
- February 6, 2024:
  - yacc; begin-end
  - Tree for begin-end, expressions
  - Observability: Debug Bit Vector
- February 8, 2024:
  - pasgram.txt; trivb.tree; yacc precedence
  - Pascal for loop: Test at Top
  - parse.h: Signatures; Pascal Program Structure
- February 13, 2024:
  - Hashing; Hash with Buckets
  - Lexical Scope; Predefined Symbols; Symbolic Constants
  - Enumerated Types; variable and findid()
  - Program line; Variable Layout in Memory
  - CPU vs. Memory: Data must be Word-Aligned
- February 15, 2024:
  - Notes on trivb.pas Assignment
  - Storage Allocation: Padding; Symbol Functions
  - Variant Records
  - Arrays: Size, Low Bound
  - Type Inference and Coercion
- February 20, 2024:
  - Structures: Grammar; Records, Arrays
  - Array Addressing
  - Row-Major Order, Locality
- February 22, 2024:
  - 3 Addressing Steps; Array Reference Tree
  - Combining aref Constants; Circular Type References
  - Pointer Dereference; Walk through Type Tree
  - static, dynamic, sound, complete
  - Possible Causes of Type Errors
- February 27, 2024:
  - Type Tagging at Runtime
  - eq vs. equal in Lisp; == vs. .equals() in Java
  - Structural Equivalence; Type Signatures; Quadruples
  - Parsing to Reverse Polish
- February 29, 2024:
  - Function Return Type; Repeat Loop
  - Repeat Loop Tree; Absolute File and Loading
  - Intension; Backpatching
  - Linker: Resolving Symbols Across Modules
- March 5, 2024:
  - segfault and function calls; record example
  - Record Definition and Access
  - Operator Precedence Parsing
  - Hashing; Regular Expressions; Regular Grammar
  - Grammar Rewriting; Left-Associative
- March 19, 2024:
  - Links among Program Modules
  - Relocation: No Change, Relocate, External; DLL
  - sqrt: Newton-Raphson Iteration
  - sqrt in your head; sin, cos, exp; Integer Output
  - Floating Output; Compound I/O Statements
- March 21, 2024:
  - findtype(); Making Symbol Records
  - Record Declarations and Symbol Structure
  - Combining Freed Memory Blocks; Own Freelist
  - Garbage Collection
- March 26, 2024:
  - Subrange; 1-D Array Reference
  - 2-D Array Reference
  - Call Overhead; Dynamic Flow Graph and Stack
  - Interpreted Code
- March 28, 2024:
  - Labels; Multiply-dimensioned Arrays
  - Multiply-dimensioned Array Reference; Pointers
  - Code Generation Stack; progn
  - Assignment Statement; genarith()
  - Constants; genarith() in C
- April 2, 2024:
  - Special Functions: writeln and new
  - Memory Hierarchy; Register Pairing; used table
  - Register Use in Expression; Data Flow
  - RAX contains EAX; x86 Stack Addressing
- April 4, 2024:
  - Code Generation; Stack Variable Addressing
  - Arithmetic Expression and Instructions
  - Condition Code Register
  - Intrinsic Functions; IF Statement Generation
  - Special Cases of IF
- April 9, 2024:
  - Array Addressing
  - Call by Value, Reference
  - Call in Java; C macros
  - Closed vs Open Subroutine Call; Inlining
- April 11, 2024:
  - Code Gen Stack; Registers; Hints
  - Pareto Distribution; Optimize Loops!
  - Partial Evaluation
- April 16, 2024:
  - Stack Machine; Common Subexpression; dead code
  - Bit Vectors; Dominator and Back Arc
  - Available; Killed
  - Busy, Def-Use Chains; Graph Coloring
  - 4-Color Theorem (does not apply to compilers)
- April 18, 2024:
  - genaref: Load vs. Store
  - genaref: Pointer vs. Array
  - Def-Use Chain; Graph Coloring; Hoisting
  - Postincrement; Speedup; Strip Mining
  - Memoization; Cache Prefetch
  - Branch Prediction; Register Windows
- April 23, 2024:
  - Object = Record + Class
  - Subclasses: Add Variables, Methods
  - Multiple Inheritance; Optimization
- April 25, 2024:
  - Record and Array Addressing
  - Language Classes
  - Optimization; OOP
  - Call by Referencee, Value
  - Architecture and Compiler
Lectures from Fall 2023
- August 22, 2023:
  - Languages: Pascal, Machine, Assembly
  - Economics of Programming
  - Disk, Buffering; Lexical Ambiguity
  - Double Buffering; Character Codes
- August 24, 2023:
  - Starting Lexer; C strings
  - Storing Identifier Names
  - Integer Number Conversion
  - Overflow; IEEE Floating Point
  - Preview: Floating Point Conversion
- August 29, 2023:
  - Floating Point Conversion
  - Floating Point: Fractions are Approximate; SNaN
  - Grammars; Ambiguity; Chomsky Hierarchy
- August 31, 2023:
  - Hierarchy of Parsers; lex and Finite State Machine
  - lex
  - yytext, yyleng, comments
- September 5, 2023:
  - Contex Free Parsing; Derivation
  - Top-Down vs. Bottom-Up Parsing; Unambiguous Expression Grammar; Shift Operation
  - Associativity; First-Child / Next-Sibling Tree
  - Operator Precedence Parsing Example
- September 7, 2023:
  - Tree; Shift Operation; Operator Precedence
  - Operator Precedence Examples
  - Push, Pop; Detecting Unary -
  - Function Call, Array Reference
  - Recursive Descent
- September 12, 2023:
  - Yacc: begin-end, Expression Tree
  - Observability; Debug Printouts; Tree Form
  - Yacc Conflicts: Reduce/Reduce, Shift/Reduce
- September 14, 2023:
  - lex numbers, strings; Edit Distance; Loops
  - for loop flowchart; parse.h
  - Hashing, Hash with Buckets
- September 19, 2023:
  - Lexical Scope, Pre-defined Names
  - const and subrange
  - Variable and findid(); Block Order
  - Allocating Variables; CPU vs. Memory
  - Storage Alignment
- September 21, 2023:
  - Symbol Table Routines; Record vs. Array
  - Type Inference
  - Type Lattice; Traversing Type Tree
  - Variable Steps; Record Reference
  - Array Reference
- September 26, 2023:
  - Label Number; Function Call
  - Record Example
  - Array Reference; Row-Major Order
  - Locality: Rightmost Subscript is Inner Loop
  - Circular Type Reference; Type Tree
  - Static and Dynamic Types
- September 28, 2023:
  - Static vs. Dynamic Typing
  - Identifying Dynamic Type; eq vs. equal
  - Java: == Means Same Address for Reference Types
  - Sound and Complete; Type Issues
  - Type Checking: Structural vs. Name Equivalence
- October 3, 2023:
  - Quadruples; Parsing to Reverse Polish
  - Executing RPN; Absolute File and Loading
  - Banked Memory; Backpatching
- October 5, 2023:
  - Linker: Links between Programs; Literal vs. Immediate
  - Dynamically Linked Library (DLL); sin() series
  - sqrt(): Newton-Raphson Iteration
  - Converting Numbers for Printing
  - I/O Statements; Stack vs. Heap
- October 10, 2023:
  - Stack and Heap; Free List, Buddy System; malloc
  - Garbage Collection: Mark and Sweep; Copying; Reference Counting
  - Avoiding GC in Java; Function Call Overhead
  - Interpreted Code
- October 12, 2023:
  - Function Result Type
  - Record and Array
  - Operator Precedence Parsing
  - Parsing to Reverse Polish; Hashing
  - Regular Expressions; Grammar
  - Grammar and Tree; Grammar and its Language
- October 19, 2023:
  - Label Table; Record Declaration
  - Record Declaration and Reference
  - Code Generation for Statements
  - Code Generation for Expressions
  - Registers: used table
- October 24, 2023:
  - Subrange; Register Used Table
  - Register usage in Expressions; Data Flow
  - X86 Variable Addressing; Code Generation for Expressions
  - Compare and Jump
- October 26, 2023:
  - Array Reference
  - 2-D Array Reference
  - IF Statement Flowchart
  - Optimizing IF; Array Addressing
  - Pointer Dereference
- October 31, 2023:
  - Call by Value, Reference
  - C Macros; Closed vs. In-line Subroutine
  - Pareto Distribution; Optimization
- November 2, 2023:
  - Loop Unrolling; Partial Evaluation
  - Partial Evaluation Examples
  - Reachability, Dead Code Elimination; Bit Vectors
- November 7, 2023:
  - Pointers and Record References
  - Combined arefs
  - NIL; Dominator; Data Flow; Computed, Killed
  - Available and Basic Blocks
- November 9, 2023:
  - MOV: Addressing for Variables
  - Available, Busy/Live, Use in Error Detection
  - Def-Use Chains, Graph Coloring for Register Allocation
  - Hoisting; Strip Mining; Postincrement
- November 14, 2023:
  - Code Generation for IF Statement
  - Memoization; Reusing Result in Hardware
  - Cache Prefetch; Code Reordering; Branch Prediction Bit
  - Register Windows; Discrete Event Simulation
- November 16, 2023:
  - Code Generation for AREF; Object = Record + Class
  - Extending Instance Variables: Stack
  - Extending Methods; Multiple Inheritance
- November 28, 2023:
  - Code Generation for AREF
  - AREF as LHS of Assignment
  - Pointer op and CLTQ
  - Object Representation; Deadlines
- November 30, 2023:
  - Due Dates and Exam Study Resources
  - Records and Arrays
  - Robot Question; Language Classes; Local Optimization
  - Available, Busy, Killed; OOP Penalties
  - Call by Reference, Value; What to Optimize
  - Context Free; Regular Expression
  - Reverse Polish
Lectures from Summer 2023
- July 10, 2023:
  - Pascal vs. C; Cost of Programmer
  - Buffering Characters; Lexical Ambiguity
  - Double Buffering; Character Codes
- July 11, 2023:
  - Character Classes; C Strings
  - Integer Number Conversion
  - Integer Sizes; Overflow; Other Number Bases
  - Floating Point
- July 12, 2023:
  - Floating Point
  - Floating Point Conversion
  - Associativity, SNaN
  - Languages and Grammar
  - Ambiguity: if statement, Expressions
- July 13, 2023:
  - lex: finite automaton to table-driven parser
  - lex examples
  - lex data; hierarchy of parsers
  - Context Free
- July 14, 2023:
  - Parser; Derivations
  - Ambiguity; Top-Down vs. Bottom-Up Parsers
  - Unambiguous Grammar; Shift Operation; Associativity
  - Operator Precedence Parsing Examples
  - Example with Parentheses
- July 17, 2023:
  - Operator Precedence Parsing
  - Operator Precedence Examples
  - Push and Pop on C Stack
  - Other Parsing Issues: Function Calls
  - Recursive Descent Parsing
- July 18, 2023:
  - String Transfer; Yacc; begin - end
  - begin-end processing; expressions and binop()
  - Trace Vector; Yacc Starter File Example
  - Spelling Correction and DWIM
- July 19, 2023:
  - Looping Statement: Expand into Basic Code
  - Symbol Table; Scope; Hashing
  - Hashed with Buckets; Nested Scopes
  - Pre-Defined Symbols
- July 20, 2023:
  - Symbolic Constant, Subrange
  - Variable Declaration, Block Structure
  - Memory Alignment
  - Records, Array: Fencepost Error
- July 21, 2023:
  - Changes for trivb.pas; Record Padding
  - Variant Records or Union Types
  - Type Coercion; Type Lattice
  - Types as Tree/Graph Structure; 3 Steps
  - Array Reference
- July 24, 2023:
  - Notes on Assignment; 3 Reference Steps
  - AREF for Records, Arrays
  - Importance of Memory Locality; Row-Major Order
  - Compound Reference; Circular References
  - Structure Access is a Walk through Type Graph
- July 25, 2023:
  - Dynamic Type Checking
  - Static Typing, Strongly Typed
  - int vs. Integer Trap : == Means Same Address
  - Structural Equivalence; Quadruples
- July 26, 2023: Review for Midterm
  - Record and Array Addressing
  - Operator Precedence Parsing
  - Hashing, Regular Expressions
  - Grammars and Language Classes
- July 28, 2023:
  - Changes for graph1.pas
  - Function Result Type; Intermediate Code
  - Parsing to Reverse Polish; Absolute File and Loader
  - Backpatching
- July 31, 2023:
  - Questions on graph1.pas; Linking Process
  - Relocation Cases; Dynamically Linked Library (DLL)
  - Math Library; Newton-Raphson Iteration
  - Approximate Square Root
- August 1, 2023:
  - Newton-Raphson Iteration; findtype()
  - Record Declaration and Reference
  - Number Conversion for Output
  - I/O Statements; Maintaining Your Own Free List
  - Fragmentation; Mark-and-Sweep Garbage Collection
  - Copying Garbage Collection; Reference Counting
- August 2, 2023:
  - Array References
  - Multi-Dimensional Array References
  - Stack Frame, Interpreted Code
  - Code Generation: progn, :=
- August 3, 2023:
  - Pointer Dereference
  - Code Generation: Assignment -> genarith()
  - genarith() in C
  - Immediate Operand, Literals, Registers
- August 4, 2023:
  - Register Allocation: Used Table
  - X86 Registers; Volatile Registers
  - Variable Addressing on Stack
  - Arithmetic; Condition Code and Jump
- August 7, 2023:
  - Saving Register for Funcall
  - Code Generation for If Statement
  - Array Reference; Call by Value, Reference
  - Call by Value: Safe; by Reference: Fast for Arrays
- August 8, 2023:
  - Aliasing; C Macros; In-Line Compilation
  - Local vs. Global Optimization; Pareto Distribution
  - Partial Evaluation
- August 9, 2023:
  - Starting Code Generation Assignment
  - genarith(), Code Generation
  - Program Analysis: Detecting Errors, Improving Code
  - Data Flow, Available on Entry
  - Graph Coloring for Register Allocation
- August 10, 2023:
  - Hoisting; Memoization; Cache Prefetch
  - Branch Prediction; Register Windows; Strip Mining
  - Instance = Record + Class; Extending Data in Subclass
  - Shadowing and Inheritance
- August 11, 2023:
  - Aref Parsing and Code
  - Aref Generation; Object, Method
  - Review: Record and Array Storage
  - Array and Record Reference; Language Type
  - Optimization; Call by Reference, Value
Lectures from Spring 2023
- January 10, 2023:
  - Pascal vs. C; Machine, Assembly Language
  - Economics; Disk Latency
  - Character Buffering
  - Character Codes
- January 12, 2023:
  - Strings in C
  - Accessing token parts; Integer Numbers
  - Integer Number Conversion
  - Floating Point; Floats are Approximate
- January 17, 2023:
  - IEEE Floating Point
  - Floating Point Number Conversion
  - Floating Point: Not Associative; SNaN
  - Language,Grammar, Ambiguity
  - IF Statement Ambiguity
- January 19, 2023:
  - Hierarchy of Parsers; Finite Automaton
  - lex
  - lex Rules, return values
  - lex character buffer, comments
- January 24, 2023:
  - Hierarchy of Parsers; Context-Free Grammar
  - Language, Derivation, Ambiguity
  - Unambiguous Parsing; Shift
- January 26, 2023:
  - Left Associative; Parser Options; Shift and Stacks
  - First-Child / Next-Sibling Tree
  - Operator Precedence Parsing
  - Operator Precedence with Parens; Push/Pop
  - Starter Files; Function Calls, Subscripts
  - Recursive Descent Parser
- February 7, 2023:
  - Recursive Descent Parser
  - yacc
  - begin .. end statement; binop()
  - Control Theory; Trace Vector
- February 9, 2023:
  - IF Statement Example Tree
  - Spelling Correction; Loop Testing
  - FOR Loop Flowchart
- February 14, 2023:
  - Hashing, Hashing with Buckets
  - Lexical Scoping, Predefined Symbols
  - Symbolic Constants, Enumerations, Subrange
  - var statement; order of declaration blocks
- February 16, 2023:
  - Symbol Table: Variables
  - Storage Alignment
  - Symbol Table Routines; Records
  - Array Size; Operator Types
  - Coercion; Type Lattice
- February 21, 2023:
  - Structure References
  - Array Reference
  - Row-Major Order, Locality
  - Circular References; Traversing Type Tree
- February 23, 2023:
  - Type Checking: Static, Dynamic; Type Tags
  - Sound, Strong Type Checking; Holes in Type System
  - eq vs. equal; == vs. .equals() in Java
  - Strunctural Equivalence; Intermediate Code
- February 28, 2023:
  - Named Constant; Coercion; Intermediate Code
  - Parsing to Quadruples, Reverse Polish
  - Loader, Absolute File
  - Load, Store Instructions
  - Backpatching
- March 2, 2023:
  - Linking: Bringing in Library Subroutines
  - Sharing a DLL; Newton-Raphson Iteration
  - Square Root
  - Formatting Numbers for Output
  - Closed vs. In-Line Subroutine
  - Expanding Compound I/O Statements
- March 7, 2023: Review for Midterm Exam
  - Record Layout and Array Size
  - Record and Array Reference; Regular Expressions
  - Operator Precedence Parsing
  - Grammars and Languages
  - Associativity; Language; Reverse Polish; Loop Order
  - Static and Dynamic Type Checking
- March 21, 2023:
  - Steps for Record Declaration
  - Stack and Heap
  - Free List and Garbage Collection
  - Avoiding GC by Maintaining Private Free List
  - Function Calls and Runtime Stack
- March 23, 2023:
  - Array Declaration and Reference
  - 2-D Array Reference
  - Code Generation Stack
  - Memory Hierarchy; Code Generation for Expressions
- March 28, 2023:
  - Leaving Loop Index in Register; Register Pairing
  - Register Used Table; Data Flow
  - X86 Registers, Operations; Condition Code Register
- March 30, 2023:
  - findtype(); Conditional Jump
  - Intrinsic Functions; If Statement Flowchart
  - Op Code Tables; If Statement Optimization
  - Array Addressing; Pointer Dereference
  - Call by Value, Reference
- April 4, 2023:
  - Call by Value, Reference; C macros; In-line
  - Inline Small Procedures; Pareto Distribution
  - Compile Once, Run Many Times; Partial Evaluation
  - Partial Evaluation Example: power
- April 6, 2023:
  - Partial Evaluation; Data Flow Analysis
  - Code Flow; Bit Vector; Dominator
  - Available, Busy, Def-Use Chain
  - Graph Coloring for Register Allocation
- April 11, 2023:
  - Getting Performance from Multiple CPUs
  - Improving Loops over Arrays; Memoization
  - Multiple Condition Codes; Cache Prefetch
  - Branch Prediction; Register Windows
  - OOP: Class, Method Call
- April 13, 2023:
  - Code Gen: Saving Register; Getting Started
  - OOP: Instance, Boxed Number
  - Java: Number Types, Extending Classes
  - Java: field, method call: Inheritance, Shadowing
  - Multiple Inheritance: Problems
- April 18, 2023:
  - Class Implementation
- April 20, 2023:
  - Records, Arrays
  - Grammar, Local Optimization
  - Data Flow, OOP Overhead
  - Basic Blocks, Flow Graph; Call by Reference, Value
  - Things to Oprimize
  - Reverse Polish, Branch Prediction, Locality
  - Integer vs. int
Lectures from Fall 2022
- August 23, 2022:
  - Pascal vs. C; Assembly Language
  - Cost of Error Increases with Time to Detection
  - Disk, Buffer, Double Buffering
  - Ambiguity and Lookahead
- August 25, 2022:
  - Table Lookup; C strings
  - Integer Number Conversion
  - Detecting Overflow; Getting Started on Assignment 1
  - Intro to Float Conversion
- August 30, 2022:
  - Floating Point; left shift; normalize; exponent bias
  - Floating point number conversion; approximations
  - SNaN; Chomsky Language Hierarchy; Context Free Grammar
  - Hierarchy of Parsers
- September 1, 2022:
  - Context Free Grammar; Hierarchy of Parsers
  - Ambiguity: some string with 2 parse trees
  - Chomsky Hierarchy; Finite Automaton and lex
  - lex specifications
- September 6, 2022:
  - Regular Expressions and lex
  - yytext, yyleng, comments
  - Parsing: Context-Free Grammar
- September 8, 2022:
  - Top-Down, Bottom-Up; Grammar vs. Counter
  - Ambiguous, Unambiguous Expression Grammar; Shift
  - Shift and Reduce; Associativity; Parser Options
  - Tree Format; Operator Precedence Examples
- September 13, 2022:
  - Operator Precedence Examples
  - Operator Precedence Example; Push and Pop
  - Intermediate Code Tree; Parser Options
  - Recursive Descent: Grammar Rule as Code
- September 15, 2022:
  - Operator Precedence: errors, unary, function call, array
  - Yacc: begin...end statement
  - begin...end code; control theory
- September 20, 2022:
  - Debug Mask; progn; Spelling Correction
  - for statement
- September 22, 2022:
  - Hashing for Symbol Table
  - Hash with Buckets; Hierarchy of Name Spaces
  - Symbolic Constants and Enumerations
  - Variables: Alignment and Padding
- September 27, 2022:
  - Alignment, Records
  - Arrays
  - Array Size; Types and Coercion
  - Type Lattice; References in Grammar
- September 29, 2022:
  - Structure Reference Steps; Nested AREF
  - Array Reference
  - Row-Major Order
  - Java Arrays; Combined References
  - Circular References
- October 4, 2022:
  - References as Traversal of Type Tree
  - Dynamic Type Checking: Tag, Speed Penalty
  - Overly Strict Types; Not Everything Can Be Checked Statically
  - Variant Records; Complexity of Equality Testing
  - Java: == vs. .equals()
- October 6, 2022:
  - Pascal block structure; Intermediate Code
  - Quadruples, Reverse Polish
  - Absolute File and Loading Process
  - Disk Access; Intension vs. Extension
- October 11, 2022:
  - Backpatching; Linker
  - Relocation
  - DLL: Dynamically Linked Library
- October 13, 2022:
  - Record Layout
  - Array, Storage, Reference
  - Operator Precedence Parsing
  - Hashing; Regular Expressions; Regular Language
  - Regular Language, Grammar, Parse Tree
- October 20, 2022:
  - Details of Record Declaration
  - Math Functions; Newton-Raphson; sqrt
  - Number Output; I/O Statements
  - Pointer and new(); Local Free List
  - Buddy System and malloc()
- October 25, 2022:
  - Array Declaration and Reference
  - Multi-Dimensional Array Reference
  - Stack, Heap, Pointer; Garbage Collection
  - Reference Counting; Function Call Overhead
- October 27, 2022:
  - Stack and Program Execution
  - Interpreted Code; progn
  - Assignment Statement, Expression
  - Code Generation for Expression
- November 1, 2022:
  - Code Generation for Operators
  - Register Allocation
  - Registers Used, Data Flow
  - x86 Registers, Addressing
- November 3, 2022:
  - x86 Op Codes; Condition Code Register
  - Condition Code and Conditional Branch
  - Registers and Function Call; IF Statement
  - IF Optimization; Array Reference Addressing
- November 8, 2022:
  - Record Structures
  - Subrange, Arrays
  - Call by Value, Reference
- November 10, 2022:
  - In-Line vs. Closed Subroutine
  - Optimization
  - Partial Evaluation
  - Data Flow Analysis can Detect Errors
- November 15, 2022:
  - Register Assignment; Program Analysis
  - Dominatore; computed, killed
  - Available, busy, def-use chain; Graph Coloring
  - Graph Coloring for Register Assignment
- November 17, 2022:
  - Pareto Distribution; Hoisting; Strip Mining
  - Strip Mining: Multiple CPUs; Post-Increment
  - Memoization; Runtime Data Flow
  - CPU Techniques for Speedup; Cache Prefetch
  - Branch Prediction; Register Windows
- November 29, 2022:
  - OOP: Object = Record + Pointer to Class
  - Data and Method Inheritance
  - Multiple Inheritance; Optimization
- December 1, 2022:
  - Review: Records
  - Grammar, Local Opt., Available, Busy, Killed
  - Object-Oriented; Call by Reference, Value
  - Language, Reverse Polish, Call with Integer in Java
Lectures from Summer 2022
- July 11, 2022:
  - Pascal vs. C; Programming Economics
  - Cost of Error Increases with Time; Disk Access
  - Buffer; Lexical Ambiguity; Double Buffering
  - Character Codes; Table Lookup
- July 12, 2022:
  - C strings, Identifiers
  - Integer Number Conversion
  - Other Number Bases, Error Checking
  - Floating Point
- July 13, 2022:
  - Floating Point Conversion
  - Floating Point; Chomsky Hierarchy
  - Ambiguity
- July 14, 2022:
  - Finite State Machine; Hierarchy of Parsers
  - lex: return() and yylval
  - number and conversion
  - strings and comments
- July 15, 2022:
  - Context Free Grammars: Recursion and Trees
  - Floating Point Add Is Not Associative
  - Top-Down vs. Bottom-Up Parsing; Deep Structure
  - Unambiguous Parsing; Shift and Reduce
- July 18, 2022:
  - Parser Options; Associativity; Shift Action
  - Operator Precedence Parsing Examples
  - Parsing with Parens; First-Child / Next-Sibling Tree
  - Tree for Operations; Push and Pop in C
  - Parsing Function Calls, Array References
  - Top-Down Recursive-Descent Parser
- July 19, 2022:
  - Yacc; begin-end syntax
  - Constructing begin-end code; arithmetic ops
  - Trace printouts; starter file examples
- July 20, 2022:
  - error in yacc; Parser Options
  - for loop
  - Declarations and Symbol Table
- July 21, 2022:
  - Hashing; Lexical Scope
  - Inheritance of Symbols from Surrounding Scopes
  - Constant Symbols
  - Subranges as Lists of Constants
  - Variable Declarations and Block Structure
- July 22, 2022:
  - Allocating Storage; CPU-Memory Connection
  - Storage Alignment and Padding
  - Creating Symbols; Records
  - Arrays in Symbol Table
  - Type Coercion
  - Type Lattice
- July 25, 2022:
  - Structure References: Record
  - Array Reference, Canonical Form
  - Row-Major Order; Fortran and Java Arrays
  - Combined Array and Record References
  - Types as Trees, References as Traversal
- July 26, 2022:
  - Getting Started on Parser
  - Dynamic Type Checking
  - Dynamic vs. Static Type Checking
  - Holes in Type Checking
  - Pointer vs. Structural Equality; Java == vs. .equals()
  - Structural Equivalence
- July 27, 2022: Review for Midterm Exam
  - Record and Array Storage
  - Record and Array Access
  - Operator Precedence Parsing
  - Regular Expressions and Grammar
  - Chomsky Hierarchy, Grammars, Languages
- July 29, 2022:
  - Functions; Polymorphism in OOP
  - Intermediate Code: Quadruples, Reverse Polish
  - Reverse Polish; Steps From Source Code to Execution
  - Loading and Execution; BSS: Intension for Storage
- August 1, 2022:
  - Memory Banks; Backpatching; Adding Library Modules
  - Code Relocation Options
  - Dynamically Linked Library; Math Functions
- August 2, 2022:
  - sqrt, Newton-Raphson Iteration
  - Approximate sqrt; Printing Numbers
  - I/O Statements; new()
  - Recycling Unused Storage; Mark-and-Sweep
  - Copying Garbage Collection, Reference Counting; Doing Your Own Free List
- August 3, 2022:
  - Stack and Stack Frame; Interpreted Code
  - Code Generation Hierarchy; Code for Statements
  - Expressions: Postorder
  - Code Generation for Expressions
- August 4, 2022:
  - Register Allocation
  - Register Reuse; x86 Registers; Data Addressing
- August 5, 2022:
  - Base-Offset Addressing; 3 Steps for Reference
  - Records: Declaration Steps and Use
  - Array Reference
  - Pointer Reference; x86 Addressing
- August 8, 2022:
  - Arithmetic Instructions on x86
  - Condition Code and Conditional Jump
  - Saving Intermediate Result on Stack; IF Statement
  - IF Statement Optimization; Array Addressing
- August 9, 2022:
  - Call by Value, Call by Reference
  - Java Arrays; C Macros; Overhead of Procedure Call
  - Inlining: Best for Small Procedures
  - Pareto Distribution; Where to Optimize: Loops
- August 10, 2022:
  - Symbol Table Structure for Pointers
  - Optimization; Partial Evaluation
  - Data Flow Analysis
- August 11, 2022:
  - Data Flow Analysis
  - Def-Use Chains, Graph Coloring, Strip Mining
  - Cache Prefetch, Branch Prediction, Register Windows
  - Object Storage, Class Structure
  - Method Call: Dynamic Dispatch
- August 12, 2022: Review for Final
  - Record/Array Declaration and Access
  - Grammar, Chomsky Hierarchy, Local Optimization
  - Optimization, Object-Oriented Programming, Call
  - Optimization
  - Reverse Polish
Lectures from Spring 2022
- January 18, 2022:
  - Pascal vs. C; Programming Economics
  - Bug Cost Increases with Time; Buffering
  - Lexical Ambiguity; Double Buffering
- January 20, 2022:
  - characters and strings in C
  - representing identifier names
  - integer number conversion
  - floating point representation
  - floating point number conversion
- January 25, 2022:
  - Number Conversion: Other Bases
  - Floating: Fractions Not Exact, + Not Associative
  - Chomsky Hierarchy; Ambiguity
  - Hierarchy of Languages, Parsers
- January 27, 2022:
  - Floating SNaN; Hierarchy of Parsers
  - lex: Table-driven Parser
  - lex Examples
  - yytext and yyleng
  - Context Free Grammars and Languages
- February 1, 2022:
  - Floating Overflow; Hierarchy of Parsers
  - Derivations, Parse Tree, Ambiguity
  - Top-Down, Bottom-Up; Parser Options
  - Unambiguous Parse Tree; Shift Action
- February 8, 2022:
  - string in lex; shift in parsing
  - Associativity; First-Child/Next-Sibling Tree
  - Operator Precedence Parsing Examples
  - Stack Operations in C
  - Reduce; Error Checking and Unary Minus
- February 10, 2022:
  - Parser Options; Unary Operator
  - Parsing Function Calls, Array References
  - Recursive Descent Parser
  - Shift-Reduce Parser; Synthetic Translation
  - yacc; begin-end = { ...}
- February 15, 2022:
  - Trees for progn, expression
  - Observability: Trace Vector; Tree for Example
  - Error Correction; Point Op
- February 17, 2022:
  - for loop: flowchart
  - for loop: code and tree
  - Symbol Table: scope, hashing
  - Symbol Table: levels; constants
- February 22, 2022:
  - Grammar Debugging; Constants
  - Enumerated Constants; Variable Declarations
  - Order of Declarations; Simple vs. Reference Vars
  - Alignment and Padding
  - findtype(), Putting a Type in symtype
- February 24, 2022:
  - Understanding Trees; Starting Parser Assignment
  - Record Declaration
  - Variant Records
  - Array Declaration
  - binop: Inferring Type, Type Coercion
- March 1, 2022:
  - Record Declaration
  - Type Lattice; Walk through Type Tree
  - Addressing: 3 Steps; aref operator
  - Array Reference
  - Row-Major Order; Combining Constants
- March 3, 2022:
  - Combining Constants in aref; Circular Reference
  - Circular Reference; Pointer Reference
  - Structure vs Name Equivalence; Type Tree
  - Dynamic Type Checking
  - Sound Type System; Array Dimensions
  - Type Problems: Array Bounds, Variant Records
- March 8, 2022:
  - Page Table for Tags
  - Review: Record, Array
  - Operator Precedence Parsing
  - Hashing; Regular Expressions
  - Kind of Grammar, Language
  - Context Free vs. Regular
  - Function Signature; Polymorphic Procedure
- March 22, 2022:
  - Handling Symbolic Constants
  - Label Numbers; Intermediate Code; Quadruples
  - Reverse Polish
  - Absolute File and Loading; Branches to Labels
- March 24, 2022:
  - Back-patching
  - Link Editor: Assembling the Cast
  - 3 Cases for Relocation: Nothing, Address, External
  - Shared Dynamically Linked Library; Newton-Raphson
  - sqrt()
- March 29, 2022:
  - Constants; Coercion; segfault
  - Compound I/O Statements; new item; free list
  - Buddy System; malloc(); kinds of storage
  - Garbage Collection: Mark and Sweep, Copying, Reference Count
- March 31, 2022:
  - Procedure Call Overhead; Runtime Stack
  - Record Declaration
  - findtype for record; Interpreted Code
  - Code Generation for progn
- April 5, 2022:
  - Symbol Table for Arrays
  - Symbol Table for Subrange
  - Code Generation: progn
  - Code Generation: genarith()
  - Numeric Constants: Immediate, Literal
- April 7, 2022:
  - Assertions; findtype(): Type Name vs. Type
  - Variable Reference: 3 Steps; Record Reference
  - Subrange, simple aref
  - aref + record
  - multiple subscripts; pointer
  - searchins() for circular references; special functions
- April 12, 2022:
  - Code Generation for Expressions
  - Register Allocation
  - Variable Addressing on Stack
- April 14, 2022:
  - Stack Addressing; Array; Arithmetic Insgtruction
  - Condition Code and Conditional Jump
  - If Statement Code
- April 19, 2022:
  - Pointer; Call by Value vs. Reference
  - Passing Array by Reference; Constants with Reference
  - Macros; Closed vs. Inline Subroutine
  - Inline Small Subroutines
- April 21, 2022:
  - Pareto Distribution; Common Subexpression
  - Peephole Optimization; Partial Evaluation Rules
  - Partial Evaluation Example; Data Flow
- April 26, 2022:
  - genarith() for Id; Bit Vector
  - Dominator; Data Flow; Available
  - Available on Exit; Def-Use Chain
  - Error Detection; Graph Coloring
  - Register Assignment from Graph Coloring
- April 28, 2022:
  - Hoisting; Strip Mining
  - Memoization; Hardware Optimizations
  - Cache Prefetch; Branch Prediction
  - Register Stack
- May 3, 2022:
  - Object Storage
  - Storage: Instance Variables Added at End
  - Method Lookup, Inheritance
  - Multiple Inheritance; Inherit Method and Re-Compile
- May 5, 2022:
  - Review: Records, Arrays Addressing
  - Grammar and Language
  - Optimization, OOP
  - Basic Block, Control Flow, Call by Reference, Value
  - Optimization and Architecture
Lectures from Fall 2021
- August 26, 2021:
  - Pascal vs. C, Java; Programming Economics
  - Disk, Buffering for Characters
  - Tokens; Getting Started
- August 31, 2021:
  - Getting Started; C strings
  - Integer Number Conversion
  - Floating Point
  - Associativity, SNaN
- September 2, 2021:
  - Floating Point
  - Ambiguity
  - Grammar Hierarchy
  - Context Free
- September 7, 2021:
  - lex
  - lex: Specifications and Return Values
  - lex: Text Buffer and Comments
  - Context Free Languages and Parsing
- September 9, 2021:
  - Derivations and Parse Trees
  - Cocke-Kasami-Younger Parser
  - Unambiguous Expression Parsing; Shift
  - Left Associativity
- September 14, 2021:
  - First-Child/Next-Sibling Tree
  - Operator Precedence Parsing
  - Operations on Stacks
  - Recursive Descent Parsing
- September 16, 2021:
  - Parser Project Options
  - begin - end statement
  - Expressions; Observability and Trace Vector
- September 21, 2021:
  - Making Intermediate Code for begin-end, if
  - Error Correction in Handwritten Parser
  - Making Code for Loops
- September 23, 2021:
  - Hashing
  - Making New Token; Inheriting Symbols
  - Symbolic Constants; Getting Started on Parser
  - Calling findid()
- September 28, 2021:
  - blocks structure: declarations in right order
  - Symbol Table Levels; Allocating Memory, Alignment
  - Alignment and Padding
  - Field Access in Various Languages
- September 30, 2021: and September 30, 2021:
  - Array Declaration: Size
  - Type Coercion
  - Structure References; Record Field
  - Array Reference
  - Row-Major Order and Locality
- October 5, 2021:
  - Connecting Identifier to Symbol Table; Row-Major Order
  - Adding Constants in an AREF
  - Circular References in Declarations
  - Structure References Specify a Walk through Type Tree
  - Dynamic Typing: Ways to Implement
- October 7, 2021:
  - Notes on Assignment
  - Sound and Complete; Type Equivalence
  - Polymorphic Procedure; Quadruples
  - Reverse Polish; Loader
- October 12, 2021:
  - Backpatching
  - References between Files; Immediate Instruction
  - Dynamically Linked Library; Newton-Raphson Iteration
  - Sine Function; Number Conversion for Output
- October 14, 2021: Review for Midterm
  - Record Storage
  - Record Reference
  - Operator Precedence Parsing
  - Hashing; Regular Expressions
  - Regular and Context Free Grammars
  - Examples of Context Free
- October 21, 2021:
  - I/O Statements; Maintaining a Free List
  - Coalescing Free Blocks
  - Garbage Collection
  - Procedure Calls, Variables, Stack
  - Virtual Machine Code
- October 26, 2021:
  - Code Generation
  - Memory Hierarchy
  - genarith()
  - Immediate vs. Literal; used table
  - Few Registers Needed
- October 28, 2021:
  - Register Allocation
  - Record Declaration
  - Record Reference
  - Nested Registers on X86
- November 2, 2021:
  - Record Declaration; Reference with Pointer
  - Stack Addressing; aref, Multiply via Shift
  - Expression Operands; Compare and Jump
  - Type Change Functions
- November 4, 2021:
  - Array Declaration and Reference
  - Subrange in Array Declaration; Types as Tree
  - If Statement: General Case
  - If Statement Optimization; Array Addressing
  - Call by Value and by Reference
- November 9, 2021:
  - Call by Reference, Value; Arrays in Java
  - Call by Name; Constants with Reference; Macros in C
  - Closed vs Open (Inline) Subroutine
  - Optimization; Materialization
- November 11, 2021:
  - insttype(), record, subrange
  - changes to findtype(); partial evaluation
  - Partial Evaluation Example: power(x,n)
  - Common Subexpression Elimination
- November 16, 2021:
  - Labels; subrange for subscript
  - Arrays: 1-dimension, 2-dimension
  - 2-dimension array; multiple record references
  - program flow analysis; available, busy, def-use
  - def-use chain: registers, error detection
- November 18, 2021:
  - new() with Pointer; Def-Use Chain
  - Def-Use Chains, Register Allocation by Graph Coloring
  - Code Motion; Strip Mining
  - Memoization
  - Cache Prefetch; Branch Prediction; Register Windows
- November 23, 2021:
  - Code Generation Overview
  - genarith() Outline in C
  - Register Allocation; Stack Addressing
  - Op Code Tables; IF Statement
  - IF Statement Flowchart
- November 30, 2021:
  - Code Gen: Op Code Table; Register Allocation
  - OOP Instance; Data Added at Bottom of Record
  - Methods: Inheritance, Shadowing
  - Multiple Inheritance; Recompiling Methods at Lower Level
- December 2, 2021:
  - Saving Register Across Function Call
  - Review: Record Layout, Array Size
  - Review: Record Access, Grammar
  - Review: Optimization; OOP
  - Review: Optimization
  - Review: Peephole Opt.; Call by Reference, Value
  - Review: Architecture + Compiler
Lectures from Summer 2021
- July 12, 2021:
  - Pascal vs. C; cost of programming
  - Input Buffer
  - Double Buffering; Lexical Ambiguity
  - Token; Strings in C
- July 13, 2021:
  - Integer Number Conversion
  - Errors, Other Bases
  - IEEE Floating Point
  - Floating Point Conversion
- July 14, 2021:
  - Floating Point; Grammar
  - Ambiguity; Language Classes
  - Hierarchy of Grammars; Regular Grammar
- July 15, 2021:
  - Hierarchy of Grammars; lex
  - lex; commentsinlex.txt
  - lex character buffer; context free
- July 16, 2021:
  - Top-Down Recursive Descent Parser
  - Unambiguous Expression Grammar
  - Shift Action; Associativity; Tree form
  - Operator Precedence Examples
  - Operator Precedence with Parens
- July 19, 2021:
  - Operator Precedence; Stack in C
  - cons(): push onto stack
  - Parsing Function Call, Subscript
  - Recursive Descent: Top-Down Parser
  - yacc: table-driven parser
- July 20, 2021:
  - yacc; begin-end parsing
  - Observability: in-process traces
- July 21, 2021:
  - Spelling Correction; Abstract Syntax Tree
  - Loop: where to test; parser subroutines; declarations
  - Symbol Table; Getting Started with Parser
- July 22, 2021:
  - Hashing, Hash with Buckets
  - Symbol Table Levels; const declaration
  - Enumberated Types; vblock etc.
- July 23, 2021:
  - Placing Variables in Memory: Alignment, Padding
  - Record Declaration
  - Array Declaration
  - Type Coercion
- July 26, 2021:
  - Record and Reference
  - Array Reference
  - Row-Major Order and Loop/Subscript Order
- July 27, 2021:
  - AREF for record, array reference
  - Circular References; Pointer Dereference
  - Types as Tree/Graph Structure; Static, Dynamic
  - Dynamic Type Checking, Java Reference Types
- July 28, 2021:
  - Types: too strong, sound, complete, dynamic, holes
  - Structural Equivalence, Name Equivalence
  - Polymorphic Procedure: OOP Method
  - Exam Sample: Record, Array
  - Exam Sample: Operator Precedence Parsing
  - Exam Sample: Regular Expression, Modifying Grammar
- July 30, 2021:
  - Intermediate Code: Quadruples, Triples, Tree to RPN
  - Stack execution; Absolute File
  - Back-patching; Notes for graph1.pas
  - Notes for graph1.pas
- August 2, 2021:
  - Changing binop() for type propagation and coercion
  - Linker: Finding Modules, Relocation
  - DLL; Breaking I/O Statements into Parts
- August 3, 2021:
  - Record Declarations and Reference
  - Memory: Explicit Request, Release
  - Own freelist in Java; Identifying Runtime Type
  - Garbage Collection; Runtime Stack
- August 4, 2021:
  - Common Errors; JVM Code; Code Generation Hierarchy
  - Code Gen for progn, assignment
  - genarith() example; Memory Hierarchy
  - Register Allocation
- August 5, 2021:
  - Notes on pasrec.pas assignment
  - Code Generation, Load/Store
  - Register Used Table; Data Flow
  - X86 Addressing: Stack Variables, Pointer
- August 6, 2021:
  - Array References
  - Code Generation for Arithmetic Expression
  - Condition Code Register
  - Code Generation for IF Statement
- August 9, 2021:
  - Call by Reference, Call by Value
  - Call by Value in Java; Inlining
  - Inlining: Best for Small Subroutines
- August 10, 2021:
  - Pareto Distribution; Partial Evaluation
  - Partial Evaluation Example
  - Control Flow Analysis; Bit Vector
  - Data Flow Example
- August 11, 2021:
  - Reusing Expressions: Computed, Killed
  - Available; Error Detection
  - Graph Coloring for Register Assignment
  - Strip Mining; Postincrement; Memoization
  - Hardware Can Dynamically Reuse Expression
- August 12, 2021:
  - Cache Prefetch, Speculative Execution
  - Register Windows; Object Implementation
  - OOP Class Hierarchy, Instance Variables, Methods
- August 13, 2021:
  - Object Implementation and Method Call
  - Multiple Inheritance
  - Final Exam Example: Record, Array
  - Examples: Grammar, Avaiable, Busy, Killed
  - Examples: Call by Reference, Value; x[i] in Loop
Lectures from Spring 2021
- January 19, 2021:
  - C vs. Pascal
  - Cost of Programmer
  - Double Buffering
  - Intro to Number Conversion
- January 21, 2021:
  - C strings
  - Integer Number Conversion
  - Floating Point
  - Floating Point Conversion
- January 26, 2021:
  - Facts re Floating Point
  - Floating Point; Grammar
  - Ambiguity; Nested Grammars
  - Grammar Hierarchy; Lex Implementation
- January 28, 2021:
  - Grammars and lex
  - lex
  - Context-Free Grammars and Languages
- February 2, 2021:
  - Derivation; Top-down Parsing; Deep Structure
  - Augmented Transition Net; Expression Parsing
  - Associativity; First-Child/Next-Sibling Tree
  - Operator Precedence Example
- February 4, 2021:
  - Parsing Methods; Shift, Reduce, Tree
  - Operator Precedence Examples
  - Operator Precedence Examples
  - Stack Handling in C
  - Parsing Function Calls and Arrays
- February 9, 2021:
  - Recursive Descent
  - Shift-Reduce Parser: yacc
  - begin statement
- February 11, 2021:
  - Intermediate Code; Trace Bit Vector
  - Edit Distance for Error Correction
  - Intermediate Code for Loops
- February 25, 2021:
  - Notes on trivb.pas Assignment
  - Hashing for Symbol Table
  - Symbol Table Levels; Constants
- March 2, 2021:
  - const declaration
  - program declaration, blocks
  - variable allocation in memory
  - variable lookup in symbol table
- March 4, 2021:
  - Notes on trivb.pas assignment; allocating storage
  - Record Declaration
  - Array Declaration; Operator Type and Coercion
  - Type Coercion, Type Lattice
- March 9, 2021:
  - Structure References
  - Row-Major Order
  - Type Structure
  - Array Example from Midterm Study Guide
- March 23, 2021:
  - Moving through type graph
  - Type tagging methods; sound, complete
  - Type Equivalence
  - Java Integer; Polymorphic method
  - Intermediate code: Quadruples
- March 25, 2021:
  - Producing Intermediate Code during Parsing
  - Absolute File and Loader
  - Back-patching
- March 30, 2021:
  - Absolute File; Following References; Relocation
  - Relocation; Dynamically Linked Library; Math Functions
  - Newton-Raphson and sqrt
  - Output Conversions; I/O statements
- April 1, 2021:
  - Installing Record in Symbol Table
  - Heap Storage
  - Garbage Collection Methods
  - Maintaining Your Own Free List
- April 6, 2021:
  - Runtime Stack
  - Code Generation
  - Code Generation: Assignment, Expression
  - Code Generation: genarith()
- April 8, 2021:
  - aref assignment
  - Multiple aref
  - Code Generation: Assignment, Expressions
  - Register Allocation
  - Data Flow and Register Reuse
- April 13, 2021:
  - x86-64: Registers, Addressing
  - x86-64: Arithmetic, Condition Code
  - Conditional Jump
  - Subroutine Call
- April 15, 2021:
  - Record Declaration and Reference
  - Structure Declarations and References
  - Labels and If Statement
  - If Statement Optimization
- April 20, 2021:
  - Making record symbol table entry
  - Pointer reference; call by value, reference
  - Closed vs Open (In-line) Subroutine
  - aref in a loop is good to optimize
- April 22, 2021:
  - Optimization: Partial Evaluation
  - Partial Evaluation: Removal of Interpretation
  - Global Optimization: Flow Graph Analysis
- April 27, 2021:
  - Getting Started on Code Generation; Bit Vectors
  - Global Optimization: Computed, Killed
  - Available, Busy
  - Def-Use Chains
  - Graph Coloring for Register Allocation
- April 29, 2021:
  - Get a Register, genarith()
  - Strip Mining; Finite Differencing
  - Memoization
  - Cache Prefetch; Branch Prediction; Register Windows
  - Object Representation
- May 4, 2021:
  - aref and jump table
  - aref details
  - Object; Java Integer
  - Extending a Class: Data
- May 6, 2021:
  - Inheritance
  - Multiple Inheritance
Lectures from Fall 2020
- August 28, 2020:
  - Pascal; Assembly Language; Economics of Programming
  - Double Buffering; Lexical Ambiguity
  - Character Codes; Table Lookup
- September 1, 2020:
  - Strings in C
  - Integer Conversion
  - Basic Float Conversion
  - Floating Point Representation
- September 3, 2020:
  - Associativity and Floating Point
  - Chomsky Language Hierarchy
  - Ambiguity
  - Eliminating Ambiguity
- September 8, 2020:
  - lex
  - lex; language hierarchy
  - context free languages; derivation
  - examples of ambiguity in programming languages
- September 10, 2020:
  - Top-Down Parsing
  - Ambiguity and Parsing
  - Shift-Reduce Parsing, First-Child/Next-Sibling Tree
  - Shift-Reduce Examples
  - Shift-Reduce Examples
- September 15, 2020:
  - Operator Precedence Examples
  - Parsing Function Call
  - Operator Precedence + Recursive Descent
  - Stack in C
  - Yacc: default action, begin-end
- September 17, 2020:
  - Intermediate Code for Begin-End
  - Building in Observability
  - Yacc vs. Hand-written Parser
- September 22, 2020:
  - For Loop; Hashing
  - Hash with Buckets; Symbol Table Levels
  - Symbolic Constants; Subrange
- September 24, 2020:
  - var Declaration and Block Structure
  - Relative Addressing
  - Data Alignment and Padding
  - Runtime Stack, Record
- September 29, 2020:
  - Record and Array Declarations
  - Type Coercion and Type Lattice
  - Structure References
  - Array References
- October 1, 2020:
  - Structure References
  - Row-Major Order
  - Combined AREFs; Circular Structures
  - Traversal of Type Structure
  - Dynamic Type Checking
- October 6, 2020:
  - Function signature; sound, complete
  - Type Equivalence
  - Polymorphic method; Quadruples
  - Reverse Polish
- October 8, 2020: and second part:
  - Loader; Banked Memory
  - Backpatching; Link Editing
  - Relocation Cases
- October 13, 2020:
  - DLL; I/O Statement Expansion
  - Keeping a Free Storage List
  - Garbage Collection Methods
  - Number Conversion for Output
- October 15, 2020: Review for Midterm
  - array and record calculations
  - operator precedence parsing
  - regular expressions and languages
  - Chomsky hierarchy, grammars, languages
- October 20, 2020: Midterm Exam
- October 22, 2020:
  - Notes on graph1 assignment
  - Type Coercion in binop(), funcall
  - Newton-Raphson Iteration for sqrt()
  - Easy sqrt(), preamble, stack frame
  - Function calls and stack; virtual machine code
  - Code generation for progn
- October 27, 2020:
  - Code Generation for Expressions
  - Immediate Instruction; Registers
  - Simple Register Allocation
- October 29, 2020:
  - x86 Addressing, Arithmetic
  - Condition Code Register and Jump
  - Code Generation for If
  - Addressing for Array Reference
- November 3, 2020:
  - Record Declarations
  - Record Reference
  - Call by Reference and Value
  - Creation of Alias by Call
  - Call by Reference vs. Value
- November 5, 2020:
  - Processing Array Declarations
  - Simple Array References
  - Compound Array References
  - Open (Inline) vs. Closed Subroutine
  - Pareto Distribution; what to Optimize
- November 10, 2020:
  - Array Declaration and Reference
  - Pointers
  - Multiple aref's; padding
  - Peephole optimization; Partial Evaluation
  - Partial Evaluation Example
- November 12, 2020:
  - Stack Machine
  - Bit Vector; Flow Graph
  - Available and Busy
- November 17, 2020:
  - Array References
  - Two-dimensional Array References
  - Definition-Use Chains
  - Graph Coloring
  - Strip Mining
- November 19, 2020:
  - Memoization, Advanced Hardware
  - PowerPC Features
  - Register Windows; Discrete Event Simulation
- November 24, 2020:
  - genarith(): Literals
  - genarith(): Binary Ops
  - genarith(): Unary Ops
  - Object Storage; Java Integer
  - Extending Objects
  - Inheritance and Shadowing
- December 1, 2020:
  - Object, Method Inheritance
  - Multiple Inheritance
  - Just In Time Compilation
- December 3, 2020: Review
  - Review A
  - Review B
  - Review C
  - Review D
  - Review E
  - Review F
-->

Lectures from Summer 2020
- July 13, 2020:
  - Pascal vs. C; kinds of code; cost of errors grows
  - Disk and input buffer; Lexical ambiguity
  - Character codes; starting assignment
  - Strings in C
- July 14, 2020:
  - Double Buffering; Assignment 1
  - Lexer; tokens
  - Integer Conversion
  - Integer Overflow
  - Floating Point Representation
- July 15, 2020:
  - Floating Point Conversion
  - Floating Point Values
  - Significant Digits; Ambiguity
  - Ambiguity; Language Classes
- July 16, 2020:
  - lex: table; special variables
  - lex: making output tokens
  - lex comments; language hierarchy
  - recursion; agreement; derivations
  - Left Recursion
- July 17, 2020:
  - Top-Down vs. Bottom-Up; Ambiguity; Deep Struture
  - Stack; Ambiguous vs Unambiguous Expression Grammar
  - Expression Trees; Associativity
  - First-Child/Next-Sibling Tree; Operator Precedence
  - Operator Precedence Parsing Example
- July 20, 2020:
  - Operator Precedence Examples
  - Operator Precedence; Stack in C
  - Parser Options
  - Parsing Function Call and Subscripts
  - Writing Recursive Descent Code
- July 21, 2020:
  - begin intermediate code
  - binop(); Building In Observability
  - Tree for IF Example
- July 22, 2020:
  - Edit Distance; For Loop Flowchart
  - For Loop Tree
  - Hashing variants
  - Lexical Scoping
- July 23, 2020:
  - Symbol Table: Constants
  - Declaration Statements
  - Addressing and Alignment
  - Notes on trivb.pas Assignment
- July 24, 2020:
  - Symbol Table Entry for Record
  - Array Size; Type Coercion
  - Type Lattice
  - Walk through Type Tree
  - Record and Array References
- July 27, 2020:
  - Array Reference Code
  - Row Major Order
  - Combined References; Circular Type References
  - Circular Function Calls; Pointer Dereference
  - Dynamic Typing and == in Java
- July 28, 2020:
  - Dynamic Typing
  - Type Equivalence
  - Polymorphic Method
  - Quadruples and Polish
- July 29, 2020: Review for Midterm
  - Record and Array Size
  - Operator Precedence Parsing
  - Hashing; Regular Expressions
  - Context Free and Regular Grammars
  - Converting Tree to Reverse Polish
- July 30, 2020: No Lecture; Midterm Exam
- July 31, 2020:
  - Installing Record Declaration
  - Executable File and Loader
  - Backpatching process
- August 3, 2020:
  - Array References
  - Pointers; Linker
  - Relocation options
  - Dynamically Linked Library; Number Conversion for Output
- August 4, 2020:
  - Math Library
  - Compound I/O Statements
  - Free List and Garbage Collection
  - Garbage Collection, Roll-your-own Free List
  - Subroutine Call Overhead
- August 5, 2020:
  - Runtime Stack; Interpreted Code
  - Code Generation
  - Expression Generation
  - Expression Generation; Memory Hierarchy
- August 6, 2020:
  - Register Allocation
  - x86 Addressing
  - x86 Arithmetic Instructions
- August 7, 2020:
  - Op Code Table; Condition Code Register
  - Conditional Jump
  - Saving Registers across Subroutine Call
  - If Statement Generation
  - Call by Reference
- August 10, 2020:
  - Call by Reference vs. Call by Value
  - Call by Value in Java; C Macros
  - Open or Inline Subroutine
  - Optimization: Pareto Distribution
- August 11, 2020:
  - Partial Evaluation
  - Common Subexpressions
  - Matrix Representation of Graph
  - Bit Vector; Control Flow
  - Data Flow
- August 12, 2020:
  - Saving Register Across Funcall
  - Data Flow, Def-Use Chain
  - Graph Coloring for Register Assignment
  - Strip Mining
  - Advancced Hardware Features
- August 13, 2020:
  - Array Reference Addressing; Object Representation
  - Class Hierarchy; Multiple Inheritance
  - Mixin Methods
- August 14, 2020: Review
  - Array size and reference
  - Grammar example
  - OOP; flow graph
  - Optimization; advanced CPU features
  - Row-major Order; Substitution, def-use chaain
Lectures from Spring 2020
- March 31, 2020:
- April 2, 2020:
- April 7, 2020:
- April 9, 2020:
- April 14, 2020:
- April 16, 2020:
- April 21, 2020:
- April 23, 2020:
- April 28, 2020:
- April 30, 2020:
- May 5, 2020:
- May 7, 2020:
Gordon S. Novak Jr.