Lecture Notes: Theory (and Practice) of Programming Languages

Comp 371 | Comp 471

Department of Computer Science

Loyola University Chicago

Welcome! In this course, we study programming language concepts and paradigms in the context of contemporary software engineering practice. This version of the course is normally taught by Konstantin Läufer and focuses on functional and concurrent programming languages with examples and projects mostly in Scala.

We maintain these lecture notes using GitHub. We also offer PDF and ePub formats for offline/mobile reading.

Warning

These notes are still being written, so expect a few rough edges. But we’re getting closer! Your contributions are highly welcome! Please submit issues and pull requests.

• 1. Overview
  • 1.1. Motivation
  • 1.2. Key learning outcomes
  • 1.3. Some starting points for functional programming
  • 1.4. Course outline
  • 1.5. Bloom’s taxonomy
• 2. Context and Background
  • 2.1. Overview of a lightweight development process
  • 2.2. Software requirements
  • 2.3. Software design principles and patterns
  • 2.4. Programming language history and paradigms
  • 2.5. Popularity indices and performance comparisons
• 3. The Imperative and Object-Oriented Paradigms in Scala
  • 3.1. Options for running Scala code
  • 3.2. The role of console applications
  • 3.3. Choices for testing Scala code
  • 3.4. The role of logging
  • 3.5. Defining domain models in imperative and object-oriented languages
  • 3.6. Modularity and dependency injection
• 4. The Functional Programming Paradigm
  • 4.1. Solving problems using built-in types and behaviors
  • 4.2. Defining algebraic data types
  • 4.3. Behaviors on algebraic data types
  • 4.4. A closer look at predefined behaviors on lists
  • 4.5. Separation of concerns at the type level
  • 4.6. Other useful abstractions
  • 4.7. References
• 5. Program Representation and Interpretation
  • 5.1. Programming language toolchains
  • 5.2. Compiler front-end concepts and techniques
  • 5.3. Programming language semantics
  • 5.4. Case study: a simple imperative language
  • 5.5. Case study: a simple imperative language with records
  • 5.6. Type systems
  • 5.7. Domain-specific languages
• 6. The Concurrent Programming Paradigm
  • 6.1. Overview
  • 6.2. Activity terminology and concerns
  • 6.3. Thread safety
  • 6.4. Dealing with shared state
  • 6.5. (Conflicting) design forces
  • 6.6. Specific concurrency mechanisms
  • 6.7. References: concurrent and asynchronous computing
• 7. Summary
• 8. Appendix: Programming Language Design Principles
• 9. Appendix: Resources
  • 9.1. Key resources
  • 9.2. Code examples
  • 9.3. Recommended/supplementary texts
  • 9.4. Additional texts on Scala
  • 9.5. Online Scala resources
  • 9.6. Resources on program representation and interpretation
  • 9.7. Other resources
• 10. Appendix: Course Software
  • 10.1. Cloud-based development environment
  • 10.2. Locally installed development environment
  • 10.3. sbt optional plugins
  • 10.4. GitHub
  • 10.5. Remote participation
• 11. Appendix: Course Syllabi
  • 11.1. Course: COMP 371/471 Programming Languages
  • 11.2. Sections: 001 Fall 2021
  • 11.3. Sections: 001/002 Fall 2020
  • 11.4. Section: 001 Fall 2019
  • 11.5. Section: 001 Fall 2018
  • 11.6. Section: 001 Spring 2018
  • 11.7. Section: 001 Spring 2017
  • 11.8. Detailed Course Outline
  • 11.9. Key Resources
• 12. Appendix: TODO

• Index

• Search Page

Todo

add sample projects, activities, tests, and (tiered) master list for presentations

Todo

add stuff from https://trello.com/c/kAMGZ4uf/28-add-in-next-iteration