CPS506 - Comparative Programming Languages - Winter 2022

Learning Objectives

In this course we will explore a variety of programming languages to broaden your perspectives.

General Learning Objectives

You should be able to:
  1. Recognize and explain the difference between static and dynamic, compile-time and run-time.
  2. Recognize and explain the different kinds of type systems: untyped, dynamically-typed, and statically-typed, as well as strength of a type system.
  3. Recognize and explain the components of program analysis: scanning, parsing, semantic analysis, and the limitations of each.
  4. Recognize and explain the pragmatic issues of a programming language: various types of interpreters, JIT, native-compilers, garbage collectors
  5. Recognize and explain the simplicity issues of a programming language: grammar size, class/module library
  6. Recognize and explain the orthogonality issues of a programming language: special syntax forms, special datatypes
  7. Recognize and explain the extensibility issues of a programming language

General Language Learning Objectives

For all of the languages we covered (Smalltalk, Elixir, Haskell, Rust), plus C and Java, you should be able to:
  1. Recognize code in the language
  2. Recognize and describe the type system
  3. Recognize and describe the precedence rules for expressions, including conversion to/from Abstract Syntax Trees
  4. Recognize and describe the evaluative characteristics of the language: simplicity, orthogonality, and extensibility
  5. Write code to define a function/method
  6. Write code to conditionally evaluate expressions/statements
  7. Write code to loop/recurse
  8. Write code to create and manipulate the default collection for the language
  9. Trace the execution of a simple (10-20 line) program and recognize the results.
  10. Write the code to implement a simple algorithm described in abstract terms (5-15 lines)
  11. Be able to understand and/or code a simple program with objects/functions/blocks as parameters

Smalltalk

In addition to the above, you should be able to:
  1. Use and recognize the object-oriented paradigm
  2. Use and recognize the classes: OrderedCollection Point
  3. Use and recognize the methods: ifTrue: ifTrue:ifFalse: whileTrue: collect: select: inject:into:
  4. The default collections would be OrderedCollection or Array although most collections have the same interfaces

Elixir

In addition to the above, you should be able to:
  1. Use and recognize tuples, lists, list comprehensions
  2. Use and recognize patterns and matching
  3. Use and recognize the functional paradigm
  4. The default collections would be lists and tuples.
  5. Be able to create processes and send/receive messages

Haskell

In addition to the above, you should be able to:
  1. Use and recognize tuples, lists, list comprehensions
  2. Use and recognize patterns
  3. Use and recognize the functional paradigm
  4. The default collections would be lists and tuples.
  5. Be able to do type inference on fairly simple functions
Monads will not be on the exam this year.

Rust

In addition to the above, you should be able to:
  1. Use and recognize traits, structs, and iterators
  2. Use and recognize the imperative paradigm
  3. The default collections would be Vec and slices.
  4. Be able to do type inference on fairly simple functions