COP4020: Programming Languages

Course Description

COP4020, Programming Languages, is the course in which a computer science student stops learning languages one at a time and starts understanding what languages are — the design decisions that distinguish them, the mechanisms by which they are implemented, and the theoretical foundations that determine what any of them can express.

The University of West Florida describes "programming language theory and practice, including language design and implementation, theoretical foundations, language translation, and exposure to a variety of programming paradigms." Florida Gulf Coast University's Principles of Programming Languages covers the same territory — "language design and implementation, theoretical foundations, language translators and interpreters, and exposure to a variety of programming paradigms."

The course's pedagogical bet is that a student who has written programs in two or three similar languages does not yet know what a language is. Exposure to a genuinely different paradigm — a functional language where there is no assignment, a logic language where you state relations rather than steps — is disorienting in a productive way, and it is the point. Students commonly report that this course changed how they write code in the languages they already knew.

Two threads run through it. The design thread asks why languages differ: what problem static typing solves and at what cost, why some languages garbage-collect and others do not, what a language gains and loses by supporting first-class functions. The implementation thread asks how any of it works: lexical analysis, parsing, semantic analysis, runtime organisation, and the machinery that turns text into behaviour.

COP4020 is offered at approximately 9 Florida institutions, all universities with computer science programmes, and carries 3 credits with roughly 45 contact hours. It is a 4000-level course taken in the junior or senior year and is a required core course in most Florida computer science degrees.

⚠ Prerequisites diverge substantially, and the difference is real

• University of West Florida: COP3530 (data structures and algorithms) and COP4027 (advanced computer programming).
• Florida Gulf Coast University: COP3530 and COT4420 (theory of computation) and CEN3031 (software engineering).

FGCU's chain is markedly heavier, and COT4420 in particular changes the course. A student who has completed formal languages and automata arrives already knowing regular expressions and context-free grammars as formal objects, which means the syntax and parsing material can be taught at speed and with rigour. A student without it meets grammars for the first time here. Both approaches produce a legitimate course, but the emphasis differs — theory-first where automata precedes it, more self-contained where it does not.

The practical note: if your programme allows it, take theory of computation before this course. The two reinforce each other, and the combination is what graduate programmes and compiler-adjacent employers expect.

Learning Outcomes

Required Outcomes

• Describe the major programming paradigms — imperative, object-oriented, functional, logic and concurrent — and characterise the computational model each assumes.
• Write non-trivial programs in at least one language outside the student's prior experience, typically functional or logic.
• Specify programming language syntax formally using context-free grammars and BNF or EBNF notation.
• Construct and interpret parse trees and abstract syntax trees, and identify and resolve grammatical ambiguity.
• Explain lexical analysis and the role of regular expressions and finite automata in tokenisation.
• Explain parsing: top-down and bottom-up strategies, recursive descent, and the classes of grammar each can handle.
• Describe approaches to formal semantics — operational, denotational and axiomatic — at an introductory level, and explain why formal semantics matters.
• Analyse binding, scope and lifetime: static versus dynamic scoping, referencing environments, and the consequences of each for program behaviour.
• Analyse type systems: static and dynamic typing, strong and weak typing, type checking and inference, polymorphism, and type safety.
• Explain data type implementation: primitives, arrays, records, unions, pointers and references, and the representation choices behind them.
• Analyse subprogram implementation: the activation record, the runtime stack, parameter-passing mechanisms (value, reference, name, need), and recursion.
• Explain memory management: static, stack and heap allocation, explicit deallocation versus garbage collection, and the trade-offs including dangling references and leaks.
• Explain control abstraction and exception handling mechanisms across languages.
• Explain the object-oriented model as a language feature: inheritance, dynamic dispatch, and single versus multiple inheritance.
• Apply functional programming: first-class and higher-order functions, recursion in place of iteration, immutability, lambda expressions, closures and lazy evaluation.
• Apply logic programming: facts, rules, queries, unification and backtracking.
• Explain concurrency support in languages: threads, synchronisation, message passing, and the language-level abstractions for each.
• Compare languages critically against stated design criteria — readability, writability, reliability, cost — and defend a language choice for a given problem.

Optional Outcomes

• Implement a lexer and parser, or a complete interpreter for a small language.
• Use parser generator tools such as Lex/Yacc, Flex/Bison or ANTLR.
• Explain code generation and optimisation at an introductory level.
• Apply the lambda calculus as a formal foundation for functional languages.
• Apply advanced type system features: algebraic data types, pattern matching, type classes, generics and variance.
• Analyse scripting and dynamic language design.
• Analyse domain-specific language design and implementation.
• Explain metaprogramming, macros and reflection.
• Analyse language support for memory safety, including Rust's ownership and borrowing model.
• Trace the historical development of programming languages and the influences among them.

Major Topics

Required Topics

• Why study programming languages; language evaluation criteria; the history and genealogy of major languages
• Language design trade-offs: readability, writability, reliability, orthogonality, expressivity, cost
• Syntax description: context-free grammars, BNF and EBNF, derivations, parse trees, ambiguity, precedence and associativity in grammars
• Lexical analysis: tokens, regular expressions, finite automata, scanner construction
• Parsing: top-down and recursive descent, LL grammars; bottom-up and LR parsing; the relationship between grammar class and parser
• Semantics: attribute grammars; operational, denotational and axiomatic semantics in outline
• Names, bindings and scope: binding times, static and dynamic scope, referencing environments, named constants, aliasing
• Data types: primitives, character strings, ordinal types, arrays, records, unions, pointers and references; type checking, strong typing, type equivalence and compatibility
• Expressions and assignment: evaluation order, operator overloading, type conversion and coercion, short-circuit evaluation
• Control structures: selection, iteration, unconditional branching, guarded commands
• Subprograms: design issues, parameter-passing methods and their semantics, overloading, generics, closures
• Subprogram implementation: activation records, the runtime stack, static and dynamic links, nested subprograms, recursion
• Abstract data types, encapsulation and modules
• Object-oriented language support: inheritance, dynamic binding and its implementation, multiple inheritance, interfaces
• Exception handling and event handling across languages
• Functional programming: the paradigm, first-class and higher-order functions, recursion, immutability, closures, lazy evaluation; a functional language in practice
• Logic programming: predicate calculus basics, Horn clauses, unification, resolution, backtracking; Prolog in practice
• Concurrency: language-level threads, synchronisation primitives, message passing, and the concurrency models of specific languages
• Memory management: allocation strategies, reference counting, tracing garbage collection, and the performance and safety implications
• Comparative language study: applying the course's concepts to evaluate real languages

Optional Topics

• Implementing an interpreter or compiler front end for a small language
• Parser generators: Lex/Yacc, Flex/Bison, ANTLR
• Intermediate representations, code generation and optimisation
• Lambda calculus and formal foundations
• Advanced type systems: algebraic data types, pattern matching, type classes, dependent types in outline
• Scripting and dynamic languages; JIT compilation
• Domain-specific languages
• Metaprogramming, macros and reflection
• Memory safety by language design: Rust ownership and borrowing
• Language support for parallelism and distributed computation

Resources & Tools

• Concepts of Programming Languages (Robert Sebesta, Pearson) is the dominant text for this course in Florida and nationally, and its chapter order is effectively the standard syllabus.
• Programming Language Pragmatics (Michael Scott, Morgan Kaufmann) is the other major adoption and is stronger on implementation; Programming Languages: Principles and Paradigms (Tucker & Noonan) is a common alternative.
• Structure and Interpretation of Computer Programs (Abelson & Sussman) is free online and is used in extract where the course leans functional; Crafting Interpreters (Robert Nystrom) is also free online and is the best available practical guide for the interpreter-building project many sections assign.
• Types and Programming Languages (Pierce) is the reference for the type systems material, used in extract at undergraduate level.
• Languages students typically encounter: a functional language — Haskell, ML/OCaml, Scheme/Racket, or Scala; a logic language — Prolog (SWI-Prolog is free and standard); and comparison languages including C, Java, Python, JavaScript, Rust and Go. Racket and DrRacket are common teaching choices because the environment is designed for it.
• Implementation tools where a project is assigned: Flex and Bison, ANTLR, and the LLVM tooling for courses that reach code generation.
• Free supplementary material widely used: Learn You a Haskell for Great Good, The Rust Book, Learn Prolog Now, and the Programming Languages course materials that several universities publish openly.
• Professional and curricular context: the ACM/IEEE Computing Curricula, which place programming languages in the computer science core; ABET computing accreditation, which most Florida computer science programmes hold; and the ACM SIGPLAN community for students continuing into the area.

Career Pathways

• Software Developer and Software Engineer — SOC 15-1252. The general destination for the degree. This course's specific contribution is the ability to learn a new language quickly, which matters because a career spans more languages than any curriculum covers, and to make informed technology choices rather than defaulting to what is familiar.
• Compiler and Toolchain Engineer — SOC 15-1252 and 15-1221. A specialised and well-compensated niche; this course is its entry point, and students who enjoy it should pursue the compilers course.
• Systems Programmer — SOC 15-1252. Memory management, runtime organisation and language-level performance characteristics are daily concerns.
• Programming Language and Developer Tools Engineer — SOC 15-1252, at the companies that build languages, runtimes, static analysers and IDEs.
• Formal Methods and Verification Engineer — SOC 15-1252 and 15-1221, in aerospace, defence, medical devices and security-critical software. ⚠ Directly relevant in Florida given the aerospace and defence concentration.
• Security Researcher — SOC 15-1212. A large share of vulnerabilities are language-level — memory safety, type confusion, injection — and understanding language semantics is what makes them visible.
• Data Engineer and Backend Engineer — SOC 15-1243 and 15-1252, where language and runtime choice materially affects system behaviour.
• Graduate study in computer science — SOC 15-1221 and 25-1021. Programming languages is a recognised research area, and this course plus theory of computation is the standard preparation.
• ⚠ The realistic framing. Few graduates are hired to design languages. This course earns its place in the core for a different reason: it is foundational rather than immediately applied, and its value shows up as the ability to pick up an unfamiliar codebase in an unfamiliar language and be productive. Students who evaluate it against "will I use this next year" undervalue it; those who evaluate it against "will I still be effective in ten years when the languages have changed" do not.
• Florida employers of note: the aerospace and defence software sector on the Space Coast and in Central Florida — Lockheed Martin, Northrop Grumman, L3Harris, Boeing, SpaceX and the simulation and training contractors around Orlando, several of which do safety-critical and formal-methods work; the financial technology sector in Tampa, Jacksonville and Miami; the growing Miami technology scene; Citrix, Jabil and the established Florida technology employers; the health systems' software groups; and the state's universities and research centres.

Special Information

Position in the curriculum

COP4020 is a junior- or senior-year course and is a required core component of most Florida computer science degrees, reflecting its place in the ACM/IEEE computing curricula. It follows the programming sequence and data structures, and it sits alongside or after theory of computation, operating systems and software engineering. It commonly precedes an elective compilers course, for which it is the prerequisite.

Prerequisites narrative

Data structures and algorithms (COP3530) is universal. Beyond that, see the divergence above: UWF adds advanced programming (COP4027), FGCU adds theory of computation (COT4420) and software engineering (CEN3031). Discrete mathematics is a de facto prerequisite everywhere, since grammars, formal notation and proof-style reasoning appear throughout. Students should have real fluency in at least one imperative or object-oriented language before enrolling — the course assumes programming is not itself the difficulty.

Course format and workload

Three credits, approximately 45 contact hours, no separate laboratory. Assessment typically combines examinations with programming assignments in unfamiliar paradigms and, in many sections, a substantial implementation project — an interpreter or a parser for a small language. Expect eight to twelve hours a week outside class.

The difficulty is a paradigm shift, not volume. Students who are competent programmers in Java or Python routinely find the first functional programming assignment genuinely hard, because the habits that made them effective — loops, mutable state, step-by-step procedure — are unavailable. This is normal, it is temporary, and it is the point of the exercise. The advice that works is to stop translating: attempting to write Java in Haskell produces frustration, while accepting the new model for a fortnight produces the shift the course is after.

The implementation project, where assigned, is the other workload spike. Crafting Interpreters is free and is the resource most students find decisive on it.

Transfer and articulation

COP4020 is a 4000-level SCNS course: the number is recognised statewide, but upper-division credit is not covered by the A.A. transfer guarantee and applicability inside the major is the receiving department's decision. The course is not available before transfer from a Florida College System A.A. — the lower-division path is the programming sequence (COP2220 or COP3014, then COP3530 where offered), discrete mathematics, and the calculus and physics required by the computing programme.

The specific transfer question is the prerequisite difference: a section taught after theory of computation covers the syntax and semantics material differently from one taught without it, and that does not appear on a transcript. Carry a syllabus if the receiving programme has a compilers course with expectations about what came before. Note also that ABET-accredited computing programmes have curricular requirements that constrain what a department can accept as a substitute.

Course-code variations across Florida

The COP prefix is computer programming. Relevant numbers: COP4020 (this course, as Programming Languages or Principles of Programming Languages); COP3530 (data structures and algorithms — the universal prerequisite); COP4027 (advanced computer programming at UWF); COP4534 (data structures and algorithms II); COP4610 (operating systems). Adjacent prefixes carry the related theory and systems material: COT for theory — COT3100 (discrete structures) and COT4420 (theory of computation, FGCU's prerequisite); CEN for software engineering (CEN3031); CDA for computer architecture; CAP for applied areas including artificial intelligence and data mining; and CIS for information systems and cybersecurity. A separate compilers course, where offered, usually sits under COP4xxx or CEN4xxx and takes this course as prerequisite.

AI Integration

This course sits in an unusual position with respect to AI coding tools: the tools are built on the very machinery the course teaches, and they fail in ways the course explains.

How the material connects to the tools. Every AI coding assistant depends on tokenisation, parsing and syntactic structure — the front-end machinery of this course. Type systems, static analysis and formal verification are the technologies that make generated code checkable, and their importance rises rather than falls as more code is machine-written. Language design is itself responding: the industry's movement toward memory-safe and strongly typed languages (Rust's ownership model being the clearest example) is a bet that catching errors at compile time matters more when the volume of code being produced goes up. A student who understands type systems understands why.

Where AI helps a student here. Explaining an unfamiliar paradigm in different terms — a model that will re-explain monads or unification five ways is genuinely useful; translating a concept between languages to show the same idea in a familiar setting; debugging syntax in a language you have used for two weeks; and generating small examples to test understanding.

Where AI fails, and the pattern is instructive. Model performance degrades sharply outside the mainstream. Python, JavaScript and Java are heavily represented in training data; Haskell, ML, Prolog, Scheme and Racket are not. Ask for idiomatic Prolog or a non-trivial Haskell type signature and the failure rate rises substantially — and, tellingly, the model will still produce something confident. That is not incidental: it is exactly the "familiar paradigm bias" the course exists to break, reproduced by the tool. Models also write imperative code in functional languages, which technically runs and demonstrates none of the understanding the assignment is testing.

On the implementation side, models produce parsers that handle the examples and fail on ambiguity or edge cases, because grammar correctness is a global property that pattern-matching does not capture.

The self-interested argument for doing the work. This course's value is that it makes you able to learn languages, read unfamiliar codebases and evaluate technology choices — capabilities that become more valuable as routine code generation becomes cheap, because the scarce skill shifts from writing code to judging it. A student who generates their way through the functional programming assignments has skipped the only part of the course that produces that shift. The examination, typically closed-book and conceptual, finds this out.

Academic integrity. Computing instructors vary widely, and in this course specifically many prohibit AI on paradigm assignments while permitting it elsewhere, because the paradigm shift is the learning outcome and it cannot be delegated. Read the syllabus and ask when it is not explicit.