CS Curricula

Courses tagged with pls

COSC-231: Programming Language Paradigms (1) pls

The main purpose of a programming language is to provide a natural way to express algorithms and computational structures. The meaning of “natural” here is controversial and has produced several distinct language paradigms. Furthermore, the languages themselves have shaped our understanding of the nature of computation and of human thought processes. We will explore some of these paradigms and discuss the major ideas underlying language design. Several languages will be introduced to illustrate ideas developed in the course. Topics will include functional programming, declarative programming, and programming for concurrency and distributed computing. Offered in alternate years. (Amherst)

COSC-371: Compiler Design (1) pls

An introduction to the principles of the design of compilers, which are translators that convert programs from a source language to a target language. Compilers typically take programs written in a general-purpose programming language, such as Java or C, and produce equivalent assembly language programs. This course examines how source code is parsed, how an internal representation of that code is built, and then how the equivalent assembly code is generated. We examine basic type systems and static analysis, where the compiler can catch errors in the code during translation. We see how procedural, functional, and object-oriented languages are modeled and translated. Each student will design and implement a compiler for a small language. Offered in alternate years. (Amherst)

CSE 240: Introduction to Programming Languages (3) pls

Introduces the procedural, object-oriented, functional and declarative languages. (ASU)

CSE 340: Principles of Programming Languages (3) pls

Formal syntactic and semantic descriptions, compilation and implementation issues, and theoretical foundations for several programming paradigms. (ASU)

CSE 440: Compiler Construction I (3) pls

Introduces programming language implementation. Implementation strategies such as compilation, interpretation, and translation. Major compilation phases such as lexical analysis, semantic analysis, optimization, and code generation. (ASU)

COMP 3220: Principles Of Programming Languages (3) pls

Study of programming language principles supporting procedural abstraction, data abstraction, storage allocation, and parallel execution; language types and examples; language translations. (Auburn)

CSCI 3300: Programming Languages Concepts (3) pls

This course is centered around the concepts of the design and advanced features of programming languages. The differences between functional, imperative, and object-oriented programming will be discussed. Syntax specification, program evaluation, typing, abstract data types, and recursion will be discussed. (Augusta)

CSCI 4800: Compiler Writing (3) pls

An examination of compiler techniques used in generating machine code. Topics covered include scanning and parsing, code generating, optimization and error recovery. Programming projects in compiler construction. (Augusta)

CS 471: Programming Languages (4) pls

Introduction to the design and implementation of programming languages: linguistic features for expressing algorithms; formal syntax specification; introduction to language semantics and parsing; declarative programming (functional and goal-driven); scripting languages; imperative programming (procedural and object-oriented); comparative design and implementation issues across languages and paradigms. Assignments emphasize languages such as Prolog, Haskell, Python, and Ruby. Required lab includes student presentations. (Binghamton)

CS 472: Compiler Design (4) pls

Fundamentals of programming language translation. Compiler design concepts. General aspects of lexical analysis and parsing of context-free languages. Grammars and parsing techniques. Syntax-directed translation. Declarations and symbol management. Semantic processing and code generation. Principles, methods and examples of code optimization. (Binghamton)

CSCI3366: Principles of Programming Languages (3) pls

This course studies issues in programming language design and implementation. Language features like statically scoped variables, higher-order functions, static type-checking, recursion and pattern-matching are considered, from the points of view of both language users and language implementors. The class also introduces the functional programming paradigm, using a language like Haskell or OCaml. Other topics considered include garbage collection, tail recursion, and basics of parsing. Finally, the class introduces computer theorem-proving, using an advanced language like Agda, for reasoning about functional programs. The graded work of the class consists of regular short programming assignments as well as a more substantial project (Boston)

CS 320: Concepts of Programming Languages (4) pls

Concepts involved in the design of programming languages. Bindings, argument transmission, and control structures. Environments: compile-time, load-time, and run-time. Interpreters. (BU)

CS 516: Software Foundations via Formal Languages (4) pls

Study of the hierarchy of formal languages with a focus on algorithms on the formalisms. Experimentation with these algorithms using a computer toolset. Applications of these algorithms to compiler construction, implementation of finite-state control devices, and formal methods. (BU)

CS 525: Compiler Design Theory (4) pls

Covers the basic mathematical theory underlying the design of compilers and other language processors and shows how to use that theory in practical design situations. Topics may include lexical analysis, parsing, syntax-directed translation, code optimization, and code generation. (BU)

COSI 150a: Compiler Design (4) pls

The goal of this course is to provide an overview of the theory and practice of Compiler Design. This course will cover the fundamental components of Compiler Design including scanning, lexical analysis, parsing, semantic analysis, static analysis, and code generation. (Brandeis)

COSI 190a: Introduction to Programming Language Theory (4) pls

An introduction to the mathematical semantics of functional programming languages. Principles of denotational semantics; lambda calculus and its programming idiom; Church-Rosser theorem and Böhm's theorem; simply typed lambda calculus and its model theory: completeness for the full type frame, Statman's 1-section theorem and completeness of beta-eta reasoning; PCF and full abstraction with parallel operations; linear logic, proofnets, context semantics and geometry of interaction, game semantics, and full abstraction. Usually offered every second year. (Brandeis)

CSCI 1260: Compilers and Program Analysis (1) pls

Have you ever wondered why C programs seem to run faster than Python programs? Have you ever been confused by an error message and wondered why Java couldn't understand your program? In CSCI 1260, we'll learn how compilers read in code in one language and produce code in another; in particular, we'll learn how to translate high-level languages to code that your computer's processor can understand. We will get hands-on practice developing compilers for a series of increasingly complex languages. Along the way, we'll learn some general best practices for developing and testing complex software systems. (Brown)

CSCI 1730: Design and Implementation of Programming Languages (1) pls

Explores the design principles of modern programming languages through implementation, comparison, and reflection. Examines a variety of linguistic features that impact both control and data. Topics vary by year; more information on the course home page. (Brown)

CS 115: Functional Programming (34) pls

This course is a both a theoretical and practical introduction to functional programming. (Caltech)

CS 131: Programming Languages (36) pls

CS 131 is a course on programming languages and their implementation. It teaches students how to program in a number of simplified languages representing the major programming paradigms in use today (imperative, object-oriented, and functional). It will also teach students how to build and modify the implementations of these languages. Emphasis will not be on syntax or parsing but on the essential differences in these languages and their implementations. Both dynamically-typed and statically-typed languages will be implemented. Relevant theory will be covered as needed. Implementations will mostly be interpreters, but some features of compilers will be covered if time permits. Enrollment limited to 30 students. (Caltech)

CS 164: Compilers (9) pls

This course covers the construction of compilers: programs which convert program source code to machine code which is directly executable on modern hardware. The course takes a bottom-up approach: a series of compilers will be built, all of which generate assembly code for x86 processors, with each compiler adding features. The final compiler will compile a full-fledged high-level programming language to assembly language. Topics covered include register allocation, conditionals, loops and dataflow analysis, garbage collection, lexical scoping, and type checking. This course is programming intensive. All compilers will be written in the OCaml programming language. (Caltech)

CS 251: Programming Languages: Design and Implementation (6) pls

What makes a programming language like “Python” or like “Java”? This course will look past superficial properties (like indentation) and into the soul of programming languages. We will explore a variety of topics in programming language construction and design: syntax and semantics, mechanisms for parameter passing, typing, scoping, and control structures. Students will expand their programming experience to include other programming paradigms, including functional languages like Scheme and ML. (Carleton)

15-312: Foundations of Programming Languages (12) pls

This course discusses in depth many of the concepts underlying the design, definition, implementation, and use of modern programming languages. Formal approaches to defining the syntax and semantics are used to describe the fundamental concepts underlying programming languages. A variety of programming paradigms are covered such as imperative, functional, logic, and concurrent programming. In addition to the formal studies, experience with programming in the languages is used to illustrate how different design goals can lead to radically different languages and models of computation. (CMU)

15-314: Programming Language Semantics (12) pls

This lecture course introduces the foundational concepts and techniques of programming language semantics. The aim is to demonstrate the utility of a scientific approach, based on mathematics and logic, with applications to program analysis, language design, and compiler correctness. We focus on the most widely applicable frameworks for semantic description: denotational, operational, and axiomatic semantics. We use semantics to analyze program behavior, guide the development of correct programs, prove correctness of a compiler, validate logics for program correctness, and derive general laws of program equivalence. We will discuss imperative and functional languages, sequential and parallel, as time permits. (CMU)

17-355: Program Analysis (12) pls

This course covers both foundations and practical aspects of the automated analysis of programs, which is becoming increasingly critical to find software errors and assure program correctness. The theory of abstract interpretation captures the essence of a broad range of program analyses and supports reasoning about their correctness. Building on this foundation, the course will describe program representations, data flow analysis, alias analysis, interprocedural analysis, dynamic analysis, Hoare Logic and verification, program synthesis and repair, model checking, and symbolic execution. Through assignments and projects, students will design and implement practical analysis tools that find bugs and verify properties of software. This course satisfies the Logic and Languages constrained elective category of the Computer Science major, the Theoretical Foundations requirement of the Computer Science master's degree, and the Technical Software Engineering requirement for the Software Engineering minor. (CMU)

17-363: Programming Language Pragmatics (12) pls

This course provides a broad and pragmatic foundation in the most basic tool of the programmer: programming languages. It starts with the fundamentals of syntax, parsing, and binding, the core structural concepts in programming languages. The course will then cover program semantics and type systems, and students will learn to relate them with a type soundness theorem. Finally, a coverage of intermediate optimization and code generation offers the opportunity to discuss both producing efficient code and reasoning about the correctness of program transformations. Assignments involve a combination of tool-assisted formal reasoning and proofs about programming languages, and implementing these language constructs in a compiler. This course fulfills the Logic and Languages constrained elective of the B.S. in Computer Science. Students with substantial math and programming experience who have not satisfied the specific prerequisites can contact the instructor for permission to enroll. (CMU)

15-411: Compiler Design (15) pls

This course covers the design and implementation of compiler and run-time systems for high-level languages, and examines the interaction between language design, compiler design, and run-time organization. Topics covered include syntactic and lexical analysis, handling of user-defined types and type-checking, context analysis, code generation and optimization, and memory management and run-time organization. (CMU)

15-417: HOT Compilation (12) pls

The course covers the implementation of compilers for higher-order, typed languages such as ML and Haskell, and gives an introduction to type-preserving compilation. Topics covered include type inference, elaboration, CPS conversion, closure conversion, garbage collection, phase splitting, and typed assembly language. (CMU)

CSDS 337: Compiler Design (4) pls

Design and implementation of compilers and other language processors. Scanners and lexical analysis; regular expressions and finite automata; scanner generators; parsers and syntax analysis; context free grammars; parser generators; semantic analysis; intermediate code generation; runtime environments; code generation; machine independent optimizations; data flow and dependence analysis. There will be a significant programming project involving the use of compiler tools and software development tools and techniques. Offered as CSDS 337 and ECSE 337. (Case)

CSDS 345: Programming Language Concepts (3) pls

This course examines the four main programming paradigms: imperative, object-oriented, functional, and logical. It is assumed that students will come to the course with significant exposure to object-oriented programming and some exposure to imperative programming. The course will teach the functional paradigm in depth, enhance the students' knowledge of the object-oriented and imperative paradigms, and introduce the logical paradigm. The course will explore language syntax, semantics, names/scopes, types, expressions, assignment, subprograms, abstraction and inheritance. This exploration will have several forms. Students will study the programming language concepts at a theoretical level, use the concepts in functional language programming, and implement the concepts by designing language interpreters. (Case)

CSDS 345N: Programming Language Concepts (3) pls

COMS W3101: Programming Languages (1) pls

Introduction to a programming language. Each section is devoted to a specific language. Intended only for those who are already fluent in at least one programming language. Sections may meet for one hour per week for the whole term, for three hours per week for the first third of the term, or for two hours per week for the first six weeks. May be repeated for credit if different languages are involved (Columbia)

COMS W4115: Programming Lang ＆ Translators (3) pls

Modern programming languages and compiler design. Imperative, object-oriented, declarative, functional, and scripting languages. Language syntax, control structures, data types, procedures and parameters, binding, scope, run-time organization, and exception handling. Implementation of language translation tools including compilers and interpreters. Lexical, syntactic and semantic analysis; code generation; introduction to code optimization. Teams implement a language and its compiler (Columbia)

CS 4110: Programming Languages and Logics (4) pls

An introduction to the theory, design, and implementation of programming languages. Topics include operational semantics, type systems, higher-order functions, scope, lambda calculus, laziness, exceptions, side effects, continuations, objects, and modules. Also discussed are logic programming, concurrency, and distributed programming. (Cornell)

CS 4120: Introduction to Compilers (3) pls

An introduction to the specification and implementation of modern compilers. Topics covered include lexical scanning, parsing, type checking, code generation and translation, an introduction to program analysis and optimization, and compile-time and run-time support for modern programming languages. As part of the course, students will build a working compiler for an object-oriented language. (Cornell)

CS 4121: Practicum in Compilers (2) pls

Students will build a working compiler for an object-oriented language. (Cornell)

CS 4160: Formal Verification (4) pls

An introduction to formal verification, focusing on correctness of functional and imperative programs relative to mathematical specifications. (Cornell)

COSC 57: Compilers (1) pls

Techniques for automatic translation of programming languages are discussed. The course includes a brief survey of various techniques and formalisms that can be used for describing the syntax and semantics of programming languages, for describing abstract and concrete machine architectures, and for describing program translation and transformation. This course includes a project to construct a compiler that will translate a program written in a high-level language into machine code for a conventional-architecture machine. (Dartmouth)

COSC 59: Principles of Programming Languages (1) pls

This course provides a study of the principles of programming languages. The course will focus on the similarities and differences among imperative, functional, logical, and object-oriented programming languages. Topics include formal definitions of languages and tools for automatic program translation, control structures, parameter passing, scoping, types, and functions as first-class objects. For each language category, implementation issues will be discussed, and program development strategies illustrated through programming exercises. (Dartmouth)

COSC 69.14: Functional Programming in Haskell (1) pls

This course teaches a different approach to programming. In functional programming, we treat programs like values. The type of that value tells you what the program might do and restricts the possible buggy programs that don’t do what you want them to do. In Haskell, you direct the type system to help improve your productivity, and your code’s maintainability, by ensuring that certain bugs yield uncompilable code. Haskell programming is a recommended skill, regardless of whether you have a direct need for it. Programming in Haskell is not difficult, but has a steep learning curve when attempting to learn it on your own. Hence this course won’t be easy, but it will help you through the difficult part. We use the latest GHC compiler, which is the most commonly used Haskell compiler in industry. (Dartmouth)

CS 3240: Languages and Computation (3) pls

Interpreters as abstract machines and the tools used to construct them, such as scanners and parsers. An introduction to models of computation as embodied by different programming languages. Limits of and relationships between these models. (Georgia Tech)

CS 4240: Compilers, Interpreters, and Program Analyzers (3) pls

Study of techniques for the design and implementation of compilers, interpreters, and program analyzers, with consideration of the particular characteristics of widely used programming languages. (Georgia Tech)

CS 4392: Programming Languages (3) pls

Fundamentals of programming language design and theory. Topics include formal semantics and type systems for imperative, functional, and parallel languages; lambda calculus and its variants; the Curry-Howard Correspondence; techniques for proving language properties and verifying program specifications. (Georgia Tech)

CS 6241: Design and Implementation of Compilers (3) pls

Design and implementation of modern compilers, focusing upon optimization and code generation. (Georgia Tech)

CS 6246: Object-Oriented Systems and Languages (3) pls

Design and implementation of object-oriented systems. Aspect-oriented programming, type systems, OO language implementation (virtual dispatch, GC), OO language design (genericity, reflection, mixins). (Georgia Tech)

COMPSCI 1520: Programming Languages (4) pls

Comprehensive introduction to the principal features and overall design of both traditional and modern programming languages, including syntax, formal semantics, abstraction mechanisms, modularity, type systems, naming, polymorphism, closures, continuations, and concurrency. Provides the intellectual tools needed to design, evaluate, choose, and use programming languages. (Harvard)

COMPSCI 1530: Compilers (4) pls

Implementation of efficient interpreters and compilers for programming languages. Associated algorithms and pragmatic issues. Emphasizes practical applications including those outside of programming languages proper. Also shows relationships to programming-language theory and design. Participants build a working compiler including lexical analysis, parsing, type checking, code generation, and register allocation. Exposure to run-time issues and optimization. (Harvard)

COMPSCI 2270: Cryptography (4) pls

Cryptography is as old as human communication itself, but has undergone a revolution in the last few decades. It is now about much more than 'secret writing' and includes seemingly paradoxical notions such as communicating securely without a shared secret, and computing on encrypted data. In this challenging but rewarding course we will start from the basics of private and public key cryptography and go all the way up to advanced notions such as fully homomorphic encryption and software obfuscation. This is a proof-based course that will be best appreciated by mathematically mature students. (Harvard)

COMPSCI 2520R: Advanced Topics in Programming Languages (4) pls

Seminar course exploring recent research in programming languages. Topics vary from year to year. Students typically read and present research papers, undertake a research project. (Harvard)

6.1100: Computer Language Engineering (4) pls

Analyzes issues associated with the implementation of higher-level programming languages. Fundamental concepts, functions, and structures of compilers. The interaction of theory and practice. Using tools in building software. Includes a multi-person project on compiler design and implementation. (MIT)

6.1120: Dynamic Computer Language Engineering (4) pls

Studies the design and implementation of modern, dynamic programming languages. Topics include fundamental approaches for parsing, semantics and interpretation, virtual machines, garbage collection, just-in-time machine code generation, and optimization. Includes a semester-long, group project that delivers a virtual machine that spans all of these topics. (MIT)

6.5110: Foundations of Program Analysis (12) pls

Presents major principles and techniques for program analysis. Includes formal semantics, type systems and type-based program analysis, abstract interpretation and model checking and synthesis. Emphasis on Haskell and Ocaml, but no prior experience in these languages is assumed. Student assignments include implementing of techniques covered in class, including building simple verifiers. (MIT)

6.5120: Formal Reasoning About Programs (12) pls

Surveys techniques for rigorous mathematical reasoning about correctness of software, emphasizing commonalities across approaches. Introduces interactive computer theorem proving with the Coq proof assistant, which is used for all assignments, providing immediate feedback on soundness of logical arguments. Covers common program-proof techniques, including operational semantics, model checking, abstract interpretation, type systems, program logics, and their applications to functional, imperative, and concurrent programs. Develops a common conceptual framework based on invariants, abstraction, and modularity applied to state and labeled transition systems. (MIT)

6.5150: Large-scale Symbolic Systems (12) pls

Concepts and techniques for the design and implementation of large software systems that can be adapted to uses not anticipated by the designer. Applications include compilers, computer-algebra systems, deductive systems, and some artificial intelligence applications. Covers means for decoupling goals from strategy, mechanisms for implementing additive data-directed invocation, work with partially-specified entities, and how to manage multiple viewpoints. Topics include combinators, generic operations, pattern matching, pattern-directed invocation, rule systems, backtracking, dependencies, indeterminacy, memoization, constraint propagation, and incremental refinement. (MIT)

6.5151: Large-scale Symbolic Systems (12) pls

CS 4400: Programming Languages (4) pls

Introduces a systematic approach to understanding the behavior of programming languages. Covers interpreters; static and dynamic scope; environments; binding and assignment; functions and recursion; parameter-passing and method dispatch; objects, classes, inheritance, and polymorphism; type rules and type checking; and concurrency. (Northeastern)

CS 4410: Compilers (4) pls

Studies the construction of compilers and integrates material from earlier courses on programming languages, automata theory, computer architecture, and software design. Examines syntax trees; static semantics; type checking; typical machine architectures and their software structures; code generation; lexical analysis; and parsing techniques. Uses a hands-on approach with a substantial term project. (Northeastern)

COMP_SCI 321-0: Programming Languages (1) pls

Introduction to key parts of programming languages: syntax, semantics, and pragmatics. Implementation of a series of interpreters that show how various aspects of programming languages behave. (Northwestern)

COMP_SCI 322-0: Compiler Construction (1) pls

The compiler is the programmer's primary tool. Understanding the compiler is therefore critical for programmers, even if they never build one. Furthermore, many design techniques that emerged in the context of compilers are useful for a range of other application areas. This course introduces students to the essential elements of building a compiler: parsing, context-sensitive property checking, code linearization, register allocation, etc. To take this course, students are expected to already understand how programming languages behave, to a fairly detailed degree. The material in the course builds on that knowledge via a series of semantics preserving transformations that start with a fairly high-level programming language and culminate in machine code. (Northwestern)

COMP_SCI 323-0: Code Analysis and Transformation (1) pls

This course covers fast, sophisticated code analysis and transformation tools essential for modern software development. You will learn the fundamentals of code analysis and transformation. (Northwestern)

COMP_SCI 324-0: Dynamics of Programming Languages (1) pls

This course introduces students to the semantics of programming languages, focusing on building a foundational understanding of PLs by breaking them down to their most basic ingredients. (Northwestern)

CSCI 131: Programming Languages (1) pls

A thorough examination of issues and features in language design and implementation, including language-provided data structuring and data-typing, modularity, scoping, inheritance and concurrency. Compilation and run-time issues. Introduction to formal semantics. (Pomona)

CSCI 181N: Advanced Functional Programming (1) pls

Immutable, higher-order, side-effect free programming combines with various structuring disciplines (e.g., static type inference, monads) to offer a powerful, alternative viewpoint on programming. We will learn Haskell and its idioms, with an eye towards the language-based thinking of CSCI 131 (but none of its formalism). The course culminates in a project. (Pomona)

CSCI 181V: Principles of Programming Languages: Object-Oriented (1) pls

A thorough examination of issues and features in language design and implementation, including abstraction mechanisms, types, scoping, modularity, inheritance and concurrency. Special emphasis on issues with object-oriented languages. (Pomona)

COS 320: Compiling Techniques (1) pls

The principal algorithms and concepts associated with translator systems. Topics include lexical analysis, syntactic analysis, parsing techniques, symbol table management, code generation and optimization, run time system design, implementation issues related to programming language design. Course will include a large-scale programming project utilizing the above topics. Three lectures. (Princeton)

COS 326: Functional Programming (1) pls

An introduction to the principles of typed functional programming. Programming recursive functions over structured data types and informal reasoning by induction about the correctness of those functions. Functional algorithms and data structures. Principles of modular programming, type abstraction, representation invariants and representation independence. Parallel functional programming, algorithms and applications. (Princeton)

CS 35200: Compilers: Principles And Practice (3) pls

The theory and practice of programming language translation, compilation, and run-time systems, organized around a significant programming project to build a compiler for a simple but nontrivial programming language. Modules, interfaces, tools. Data structures for tree languages. Lexical analysis, syntax analysis, abstract syntax. Symbol tables, semantic analysis. Translation, intermediate code, basic blocks, traces. Instruction selection, CISC and RISC machines. Liveness analysis, graph coloring register allocation. Supplemental material drawn from garbage collection, object-oriented languages, higher-order languages, dataflow analysis, optimization, polymorphism, scheduling and pipelining, memory hierarchies. (Purdue)

CS 45600: Programming Languages (3) pls

Concepts for structuring data, computation, and whole programs. Object-oriented languages, functional languages, logic- and rule-based languages. Data types, type checking, exception handling, concurrent processes, synchronization, modularity, encapsulation, interfaces, separate compilation, inheritance, polymorphism, dynamic binding, subtyping, overloading, beta-reduction, unification. (Purdue)

CS 50200: Compiling And Programming Systems (3) pls

Basic principles of compilers and compiler design; control of translation, loading, and execution; symbolic coding systems; lexical and syntactic analysis, design and operation of assemblers and macroprocessors; design of interpretive systems. Students are expected to complete a large programming project as part of the course. Typically offered Fall. (Purdue)

COMP 311: Functional Programming (4) pls

An introduction to concepts, principles, and approaches of functional programming. Functional programming is a style of programming where the key means of computation is the application of functions to arguments (which themselves might be functions). This style of programming has become increasingly popular in recent years because it offers important advantages in designing, maintaining, and reasoning about programs in many modern contexts such as web services, multicore programming, and cluster computing. Course work consists of a series of programming assignments in the Scala programming language and various library extensions such as Apache Spark. (Rice)

COMP 312: Intro to Programming Languages (3) pls

This course explores the design landscape of programming languages and compilers, with the primary goal of giving students skills and knowledge that will help them as practitioners. After completing the course, students should be able to evaluate the tradeoffs between different programming languages, choose the language that is best-suited to a given task, write code using the functional programming paradigm, and learn new languages more quickly. Specific topics covered include lexical and syntactic analysis, type systems, variable scopes and bindings, control flow structures, and functional programming. Case studies from modern programming languages will be used to illustrate a range of abstractions and design choices. (Rice)

COMP 403: Reasoning and Software (3) pls

Our reliance on software of all forms is increasing by the day. As a result, it is more important than ever to ensure that programs function correctly and cannot be exploited by hostile adversaries. The field of formal methods takes on this challenge, developing algorithms and programming methodologies that can be used to formally reason about what happens when software executes on arbitrary inputs, often without actually executing the program. Such reasoning can be used, for example, to identify subtle bugs and vulnerabilities in programs, or to give mathematical proofs of program correctness. This is a hands-on introduction to the field of formal methods. In this class, you will learn the theoretical foundations of these systems; you will also implement a series of systems that can be used to reason about the correctness of C programs. (Rice)

COMP 408: Verified Programming (3) pls

The course will explore the mathematical underpinnings of reliable software. The students will learn how to use proof assistants to construct software along with a machine-checkable proof of its correctness. Basic concepts of logic, functional programming, static type systems and deductive verification will be covered. (Rice)

COMP 411: Principles of Programming Languages (4) pls

The design, definition and abstract implementation of programming languages including methods for precisely specifying syntax and semantics. (Rice)

COMP 412: Compiler Construction for Undergraduate Students (4) pls

Topics in the design of programming language translators, including parsing, run-time storage management, error recovery, code generation and optimization. (Rice)

CSSE 304: Programming Language Concepts (4) pls

Syntax and semantics of programming languages. Grammars, parsing, data types, control flow, parameter passing, run-time storage management, binding times, functional programming and procedural abstraction, syntactic extensions, continuations, language design and evaluation. Students will explore several language features by writing an interpreter that implements them. (Rose-Hulman)

CSSE 402: Theory and Practice of Garbage Collection (4) pls

Garbage collection (GC) is a method of automatically reclaiming dynamically allocated storage that an application no longer needs. In this course, students will explore the classical problems of garbage collection such as detecting unused objects and reclaiming the space allocated to them. Students will survey the GC literature to become familiar with the current state-of-the-art and future research directions. Students will explore techniques used to implement state-of-the-art garbage collection algorithms and will design and implement garbage collectors for a memory-managed language (e.g.,Java, C#, php, or Python). (Rose-Hulman)

CSSE 403: Programming Language Paradigms (4) pls

A survey of some current and emerging programming languages, focusing on unique language paradigms-ways of structuring solutions or manipulating data. Examples of paradigms include dynamic programming languages, object-oriented programming, highly parallelizable code, and functional programming. Emphasizes developing independent learning techniques that will allow students to acquire skills in new languages quickly. Students will develop basic skills in at least three different languages representing distinct paradigms. They will also be exposed to a selection of other languages. Includes a substantial team project. (Rose-Hulman)

CSSE 404: Compiler Construction (4) pls

Theory and practice of programming language translation. Lexical analysis, syntax analysis, parser generators, abstract syntax, symbol tables, semantic analysis, intermediate languages, code generation, code optimization, run-time storage management, error handling. Students will construct a complete compiler for a small language. (Rose-Hulman)

CS 143: Compilers (34) pls

Principles and practices for design and implementation of compilers and interpreters. Topics: lexical analysis; parsing theory; symbol tables; type systems; scope; semantic analysis; intermediate representations; runtime environments; code generation; and basic program analysis and optimization. Students construct a compiler for a simple object-oriented language during course programming projects. (Stanford)

CS 151: Logic Programming (3) pls

Logic Programming is a style of programming based on symbolic logic. In writing a logic program, the programmer describes the application area of the program (as a set of logical sentences) without reference to the internal data structures or operations of the system executing the program. In this regard, a logic program is more of a specification than an implementation; and logic programs are often called runnable specifications. This course introduces basic logic programming theory, current technology, and examples of common applications, notably deductive databases, logical spreadsheets, enterprise management, computational law, and game playing. Work in the course takes the form of readings and exercises, weekly programming assignments, and a term-long project. (Stanford)

CS 242: Programming Languages (34) pls

This course explores foundational models of computation, such as the lambda calculus and other small calculi, and the incorporation of basic advances in PL theory into modern programming languages such as Haskell and Rust. Topics include type systems (polymorphism, algebraic data types, static vs. dynamic), control flow (exceptions, continuations), concurrency/parallelism, metaprogramming, verification, and the semantic gap between computational models and modern hardware. The study of programming languages is equal parts systems and theory, looking at how a rigorous understanding of the semantics of computation enables formal reasoning about the behavior and properties of complex real-world systems. (Stanford)

CS 243: Program Analysis and Optimizations (34) pls

Program analysis techniques used in compilers and software development tools to improve productivity, reliability, and security. The methodology of applying mathematical abstractions such as graphs, fixpoint computations, binary decision diagrams in writing complex software, using compilers as an example. Topics include data flow analysis, instruction scheduling, register allocation, parallelism, data locality, interprocedural analysis, and garbage collection. (Stanford)

CS 340R: Rusty Systems (3) pls

Language shapes thought; for 40 years, software systems and some of their research challenges have been defined by the C language. In the past 5 years, this has begun to change, with new languages (Rust, Go, coq) becoming competitors to C in large classes of systems. CS 340R is a project-centric course that examines how the Rust programming language changes software systems, solving some problems while presenting new ones. This course seeks to ask and start to answer a simple question: 'What are the most important open research challenges for software systems written in Rust?' (Stanford)

CS 343D: Domain-Specific Programming Models and Compilers (3) pls

This class will cover the principles and practices of domain-specific programming models and compilers for dense and sparse applications in scientific computing, data science, and machine learning. We will study programming models from the recent literature, categorize them, and discuss their properties. We will also discuss promising directions for their compilation, including the separation of algorithm, schedule, and data representation, polyhedral compilation versus rewrite rules, and sparse iteration theory. (Stanford)

CS 343S: Domain-Specific Language Design Studio (3) pls

This is a design-studio course for the creation of domain-specific languages (DSLs). We will start with lectures teaching fundamental skills for designing and implementing DSLs, followed by a long term project designing and implementing a DSL of the student's choice. The course will particularly emphasize the role that languages can play in tasks that we do not usually think of as programming, such as DSLs for knitting patterns or geometric constructions. (Stanford)

CS 350: Secure Compilation (3) pls

This course explores the field of secure compilation, which sits at the intersection between security and programming languages. The course covers the following topics: threat models for secure compilers, formal criteria for secure compilers to adhere to, security relevance of secure compilation criteria, security architectures employed to achieve secure compilation, proof techniques for secure compilation with a focus on backtranslation. (Stanford)

CS 355: Advanced Topics in Cryptography (3) pls

Topics: Pseudo randomness, multiparty computation, pairing-based and lattice-based cryptography, zero knowledge protocols, and new encryption and integrity paradigms. May be repeated for credit. (Stanford)

CS 357S: Formal Methods for Computer Systems (3) pls

The complexity of modern computer systems requires rigorous and systematic verification/validation techniques to evaluate their ability to correctly and securely support application programs. To this end, a growing body of work in both industry and academia leverages formal methods techniques to solve computer systems challenges. This course is a research seminar that will cover foundational work and current topics in the application of formal methods-style techniques to reliable and secure computer systems design. (Stanford)

CS 358A: Programming Language Foundations (3) pls

This course introduces advanced formal systems and programming languages as well as techniques to reason formally about them. Possible systems of study include: the lambda calculus, System F, the Pi and Spi calculi, simply-typed languages, security type systems for non-interference, robust safety, linear types, ownership types, session types, logical relations and semantic models etc. (Stanford)

CPSC 073: Programming Languages (1) pls

This course presents a collection of features central to programming languages' design and implementation. Core topics include identifiers and scope, higher-order functions, types and type checking, state and mutation, objects, and memory management. The course explores these concepts through the implementation of interpreters and other programs that manipulate programs, and through exercises that explore choices in the space of programming language design. (Swarthmore)

CPSC 075: Compilers (1) pls

This course explores the conversion of programs from source code to executable forms. Topics covered include lexical analysis, formal grammars and parsing, runtime representation decisions, code transformation and generation, and static optimization techniques. (Swarthmore)

CSCE 314: Programming Languages (3) pls

Exploration of the design space of programming languages via an in-depth study of two programming languages, one functional and one object-oriented; focuses on idiomatic uses of each language and on features characteristic for each language. (Texas A&M)

CSCE 434: Compiler Design (3) pls

Programming language translation; functions and general organization of compiler design and interpreters; theoretical and implementation aspects of lexical scanners; parsing of context free languages; code generation and optimization; error recovery. (Texas A&M)

CS 105: Programming Languages (4) pls

Principles and application of computer programming languages. Emphasizes ideas and techniques most relevant to practitioners, but includes foundations crucial for intellectual rigor: abstract syntax, lambda calculus, type systems, dynamic semantics. Case studies, reinforced by programming exercises. Grounding sufficient to read professional literature. (Tufts)

CS478: Programming Languages (3) pls

Concepts of high-level programming language design are explored in detail. Cadets will examine the fundamental issues of programming language design and use this knowledge as a framework for comparison of different high-level languages. Cadets will study concepts from some or all of the imperative, functional, object-oriented, concurrent, and logic programming language paradigms. (West Point)

CS 164: Programming Languages and Compilers (4) pls

Survey of programming languages. The design of modern programming languages. Principles and techniques of scanning, parsing, semantic analysis, and code generation. Implementation of compilers, interpreters, and assemblers. Overview of run-time organization and error handling. (Berkeley)

CSE 130: Programming Languages: Principles and Paradigms (4) pls

Introduction to programming languages and paradigms, the components that comprise them, and the principles of language design, all through the analysis and comparison of a variety of languages (e.g., Pascal, Ada, C++, PROLOG, ML.) Will involve programming in most languages studied. (UCSD)

CSE 131: Compiler Construction (4) pls

Introduction to the compilation of programming languages, practice of syntax-directed translation, type checking, code generation, optimization, interpretation, and compiler structure. Students may receive repeat credit for CSE 131A and CSE 131B by completing CSE 131. May be coscheduled with CSE 231. (UCSD)

CMPSC 160: Translation of Programming Languages (4) pls

Study of the structure of compilers. Topics include: lexical analysis; syntax analysis including LL and LR parsers; type checking; run-time environments; intermediate code generation; and compiler-construction tools. (UCSB)

CMPSC 162: Programming Languages (4) pls

Concepts of programming languages: scopes, parameter passing, storage management; control flow, exception handling; encapsulation and modularization mechanisms; reusability through genericity and inheritance; type systems; programming paradigms (imperative, object-oriented, functional, and others). Emerging programming languages and their development infrastructures. (UCSB)

CS 421: Programming Languages & Compilers (3) pls

Structure of programming languages and their implementation. Basic language design principles; abstract data types; functional languages; type systems; object-oriented languages. Basics of lexing, parsing, syntax-directed translation, semantic analysis, and code generation. (Illinois)

CS 422: Programming Language Design (3) pls

Exploration of major language design paradigms using imperative and functional programming as unifying themes. Tools include both practical language processor construction and theoretical models. (Illinois)

CS 426: Compiler Construction (3) pls

Compiler structure, syntax analysis, syntax-directed translation, automatically constructed recognizers, semantic analysis, code generation, intermediate language, optimization techniques. (Illinois)

CS 425: Principles of Programming Languages (4) pls

Syntax and semantics. Scope rules, environments, stores, denoted and expressed values, procedures, and parameters. Definitional interpreters. Types, overloading, parametric polymorphism, and inheritance. Varieties of abstraction. (UO)

CS 461: Introduction to Compilers (4) pls

Lexical analysis, parsing, attribution, code generation. (UO)

CIS 3410: Compilers and Interpreters (1) pls

You know how to program, but do you know how to implement a programming language? In CIS 3410 you'll learn how to build a compiler. Topics covered include: lexical analysis, grammars and parsing, intermediate representations, syntax-directed translation, code generation, type checking, simple dataflow and control-flow analyses, and optimizations. Along the way, we study objects and inheritance, first-class functions (closures), data representation and runtime-support issues such as garbage collection. This is a challenging, implementation-oriented course in which students build a full compiler from a simple, typed object-oriented language to fully operational x86 assembly. The course projects are implemented using OCaml, but no knowledge of OCaml is assumed. (Penn)

CIS 5000: Software Foundations (1) pls

This course introduces basic concepts and techniques in the foundational study of programming languages. The central theme is the view of programs and programming languages as mathematical objects for which precise claims may be made and proved. Particular topics include operational techniques for formal definition of language features, type systems and type safety properties, polymorphism, constructive logic, and the Coq proof assistant. This course is appropriate as an upper-level undergraduate CIS elective. Undergraduates who have satisfied the prerequisites are welcome to enroll. There are no formal prerequisites, but students should know how to program at the level of a couple of undergrad courses and have developed some 'mathematical maturity' (through two or more undergraduate math courses, including at least one involving rigorous proofs); a course in functional programming or compilers may also be helpful. (Penn)

CIS 5540: Programming Paradigms (1) pls

Achieving mastery in a new programming language requires more than just learning a new syntax; rather, different languages support different ways to think about solving problems. Not all programming languages are inherently procedural or object-oriented. The intent of this course is to provide a basic understanding of a wide variety of programming paradigms, such as logic programming, functional programming, concurrent programming, rule-based programming, and others. (Penn)

CMPU 331: Compilers (1) pls

This course covers the implementation of compilers – programs that transform source programs written in a higher-level language into executable formats. (Vassar)

CSE 425S: Programming Systems and Languages (3) pls

A systematic study of the principles, concepts and mechanisms of computer programming languages: their syntax, semantics and pragmatics; the processing and interpretation of computer programs; programming paradigms; and language design. Illustrative examples are selected from a variety of programming language paradigms. (Washington U.)

CSE 428S: Multi-Paradigm Programming in C++ (3) pls

Intensive focus on how modern C++ language features support procedural, functional, generic, and object-oriented programming paradigms and allow those paradigms to be applied both separately and in combination. Topics covered will include various C++ language features and semantics, especially from the C++11 standard onward, with studio exercises and lab assignments designed to build proficiency in using them effectively within and across the different programming paradigms. (Washington U.)

CSE 431S: Translation of Computer Languages (3) pls

The theory of language recognition and translation is introduced in support of compiler construction for modern programming languages. Topics include syntactic and semantic analysis, symbol table management, code generation, and runtime libraries. A variety of parsing methods is covered, including top-down and bottom-up. Machine problems culminate in the course project, for which students construct a working compiler. (Washington U.)

CS 251: Principles of Programming Languages (1) pls

This course introduces the principles underlying the design, semantics, and implementation of modern programming languages in major paradigms including function-oriented, imperative, and object-oriented. (Wellesley)

CS 301: Compiler and Runtime Design (1) pls

This course covers principles and practice in the design and implementation of modern compilers and programming language runtime systems. (Wellesley)

COMP 321: Design of Programming Languages (1) pls

This course provides an introduction to various concepts in programming languages. Topics will include parameter passing, type checking and inference, control mechanisms, data abstraction, module systems, and concurrency. Basic ideas in functional, object-oriented, and logic programming languages will also be discussed. (Wesleyan)

COMP 323: Programming Language Implementation (1) pls

This course is an introduction to the implementation of programming languages. Students will learn how to formally describe and implement major components of the implementation pipeline. Topics may include lexical analysis and parsing (checking whether source code is well-formed and converting it to an internal programmatic representation), type-checking and -inference (static program analysis for safety features), interpretation (direct execution of a high-level language program), and compilation (translation to a low-level language such as assembly or bytecode). (Wesleyan)

CSCI 334: Principles of Programming Languages (1) pls

This course examines the concepts and structures governing the design and implementation of programming languages. It presents an introduction to the concepts behind compilers and run-time representations of programming languages; features of programming languages supporting abstraction and polymorphism; and the procedural, functional, object-oriented, and concurrent programming paradigms. Programs will be required in languages illustrating each of these paradigms. (Williams)

CSCI 434: Compiler Design (1) pls

This tutorial covers the principles and practices for the design and implementation of compilers and interpreters. Topics include all stages of the compilation and execution process: lexical analysis; parsing; symbol tables; type systems; scope; semantic analysis; intermediate representations; run-time environments and interpreters; code generation; program analysis and optimization; and garbage collection. The course covers both the theoretical and practical implications of these topics. Students will construct a full compiler for a simple object-oriented language. (Williams)

CPSC 421: Compilers and Interpreters (1) pls

Compiler organization and implementation: lexical analysis, formal syntax specification, parsing techniques, execution environment, storage management, code generation and optimization, procedure linkage and address binding. (Yale)

CPSC 448: Silicon Compilation (1) pls

An upper-level course on compiling computations into digital circuits using asynchronous design techniques. (Yale)