Programming Languages, Part A — functional foundations

This course presents key programming language concepts with an emphasis on functional thinking. ML, Racket, and Ruby serve as concrete vehicles to show how constructs, semantics, and style affect correctness and expressiveness.

Who it fits and who it doesn't: programming languages, Part A

Best suited for

• Developers with basic experience who want deeper insight into language constructs and semantics.
• Those moving toward functional programming and seeking hands-on practice in ML, Racket, Ruby.
• Students aiming to systematize ideas: lexical scope, closures, recursion, types.
• Engineers who value composable, predictable code.

Not ideal for

• Absolute beginners with no coding practice.
• Anyone expecting a framework- or tool-centric tutorial.
• Use cases needing only quick recipes without conceptual depth.

Problem → outcome in learning programming languages (Part A)

• Problem: Syntax differences obscure common ideas. Outcome: Recognize cross-language concepts and transfer skills.
• Problem: Unpredictable side effects. Outcome: Functional techniques (immutability, pure functions) for steadier logic.
• Problem: Difficulty managing abstractions. Outcome: Practice with higher-order functions, modules, and composition.
• Problem: Hard to reason about correctness. Outcome: Semantic thinking: how language constructs guide specs and tests.

Comparison with alternatives: programming languages and approaches

• Single-language focus: fast start but narrow view; here, transferable concepts via ML, Racket, Ruby.
• Theory-only tracks: formalism without practice; here, theory reinforced by implementations.
• Recipe-only learning: quick yet brittle; here, emphasis on principles that scale.
• Tool documentation: API details without the big picture; here, semantics and construct design.

Expected outcomes after covering the topics — programming languages, Part A

• Understanding of lexical scope, closures, expression evaluation, and side-effect control.
• Ability to apply recursion, pattern matching, and modular design.
• Hands-on practice in ML, Racket, Ruby: higher-order functions, types, immutability.
• Habit of selecting language constructs aligned with problem semantics.