---
tags: chapman, programming langauges, cpsc 354
---

# Learning Outcomes of CPSC 354

(draft)

... the Programming Languages course at Chapman University ...

## Practical Skills

- using Git
- writing a report in Latex
- programming in Haskell
- using the parser generator BNFC
- programming linked data structures with pointers
- making sense of a research paper
- documenting software
- learning a new programming language
- programming in a language one doesn't know [^language]
- relying on online resources or
- by understanding underlying theoretical concepts
- ...

[^language]: For most students this includes Latex and Haskell (first item below) and for all students that includes our home-made languages LambdaNat and LambdaFun (second item below).

## Theoretical Background

- context-free grammars
- lambda calculus
- models of computation
- rewriting to normal form
- proving termination of algorithms
- decidability
- proving theorems on models of computation
- invariants
- abstraction as quotient wrt equivalence relations
- operational and denotational semantics
- Curry-Howard isomorphism
- ...

## Problem Solving Techniques

- finding the right level of abstraction
- recursion (solving a problem by pretending to be able to solve it)
- minimal working example
- guess and verify
- syntax-semantics double-think [^doublethink]
- invariants
- ...

[^doublethink]: What I mean here is to be able to blindly follow meaningless rules and simultaneously anticipate the meaningful end for which the rules have been designed in the first place. Double-think is an essential skill in design algorithm and in debugging programs.

## Programming Languages Concepts

(not everything was covered in the same amount of detail but all the items below showed up at some point)

- functional programming
- lexing, tokenizing
- parsing
- abstract syntax
- algebraic data types
- recursion over abstract syntax
- call stack
- pattern matching
- interpretation
- virtual machine
- imperative vs functional programming
- syntax vs semantics
- lazy vs strict, call by name vs call by value
- macro substitution vs capture avoiding substitution
- typed vs untyped
- compile time vs run time
- specification vs implementation
- stack vs heap
- mutable vs immutable variables
- memory allocation
- garbage collection
- monads
- polymorphism
- propositions as types, proofs as programs, Curry-Howard Isomorphism
- verification, Hoare logic
- theorem proving
- domain specific languages (DSLs)
- ...