Programming Language Theory
In industry a growing share of source code is drafted by AI coding agents, which shifts the practitioner's leverage from typing code to specifying intent precisely and establishing that the delivered program means what was specified. That makes the language-level machinery this course already teaches - grammars, type systems, contracts, and formal semantics - the practical verification surface for machine-generated code, and it revalues declarative and functional styles as specification tools rather than historical curiosities.
Current catalog prerequisites — (CSC 300 or 4400).
Current description → proposed description
This course surveys major topics in the design, analysis, implementation and use of high-level languages. The four major programming paradigms are studied (procedural, functional, object, and declarative). Programming projects in each paradigm are implemented.
Prerequisites: (CSC 300 or 4400).
This course surveys the design, analysis, implementation, and use of high-level programming languages. Students study grammars and syntax, binding and scope, type systems, evaluation strategies, memory management, and formal semantics. Programming projects are implemented in each of the four major paradigms: procedural, functional, object-oriented, and declarative. The course then applies these foundations to a professional setting in which much source code is drafted by AI coding agents. Students examine how grammars constrain the output of language models, and how type systems, contracts, static analysis, and property-based testing serve as machine-checkable guardrails on generated programs. They also consider why declarative and functional styles can make programmer intent easier to specify and to verify. A single semester project carries this work: students design a small domain-specific language intended as a tool interface for an autonomous agent and for a non-specialist domain expert, build its grammar and type checker, apply them to model-generated code, and defend their design decisions in writing. Throughout, precise specification and disciplined review of code the programmer did not write are treated as professional responsibilities.
What changes
- Grammars and type systems framed as guardrails on model-generated code
- Verification of code the student did not write
- Domain-specific language design as an agent tool interface
- Declarative and functional paradigms reframed as specification skills
- Explicit language-implementation core: semantics, scope, memory, evaluation strategies
6 proposed outcomes, mapped to 6 program outcomes
Each outcome below is written to be observable and assessable, and each is mapped to the program learning outcomes for which it produces evidence.
Students will be able to implement a comparable solution to a common problem in each of the four major paradigms - procedural, functional, object-oriented, and declarative - and assess in a written comparison how each successive implementation changed their own approach to the problem.
The written comparison of how each successive implementation changed the student's own approach is a submitted, gradeable artifact of self-assessment, which is the continuous assessment and improvement of one's own problem-solving that PLO 4.3 describes.
Students will be able to differentiate the four major paradigms by their trade-offs in state management, expressiveness, and the effort required to verify machine-generated code.
The CLO's requirement to differentiate paradigms by stated trade-offs is a qualitative comparative analysis that draws conclusions from evidence, matching PLO 6.2's analysis of patterns to reach meaningful conclusions.
Students will be able to construct a grammar and type checker that constrain and validate the code a language model produces for a small language.
The CLO requires students to propose a technical solution to the problem of unreliable model-generated code and to evaluate it against real model output, which is the propose-and-evaluate evidence PLO 4.2 calls for.
Students will be able to evaluate AI-generated program code against a written specification using static type checking, formal semantics, and property-based testing, stating which claims each technique establishes and which it leaves unproven.
The CLO's demand that students state what each technique leaves unproven is the critical reading of a generated outcome and its risks that PLO 4.1 calls for.
Students will be able to design a domain-specific language that exposes a technical capability as a tool interface usable by an autonomous agent, together with reference documentation that enables a non-specialist domain expert to use it.
The required reference documentation that enables a non-specialist domain expert to use the language is the translation of technical knowledge for non-specialists that PLO 5.3 names.
Students will be able to defend a language design decision in a written rationale that states the semantics of the construct, the alternatives considered, and which claims were verified rather than assumed.
The CLO's requirement to defend a decision in writing and to distinguish verified claims from assumed ones is written communication conducted transparently and with integrity, which is what PLO 5.1 names.
Program outcomes this course reaches
Filled cells are program learning outcomes with at least one supporting course learning outcome in this course. Sparse coverage is expected — no single course carries all eighteen.