Programming Languages

Keywords

ver. 1.0.0

Bridges foundational computation theory and lambda-calculus with practical functional and modern JVM language techniques (Clojure and Kotlin).

This node unifies core theory and practical programming: it presents Turing machines and decidability, develops the lambda calculus and fixed-point recursion as the foundation of functional programming, and gives hands‑on, idiomatic guides to Clojure (REPL-driven Lisp, immutability, concurrency, macros/DSLs) and Kotlin (concise, safe, interoperable modern JVM development).

This integrated summary covers three complementary strands:

  1. Computation theory and models
  • Formal definitions and constructions for Turing Machines (configurations, example machines for tasks like erasure, copying, language recognition, and non‑context‑free acceptance).
  • Universal Turing Machines and the idea of self‑hosted computation.
  • Central decidability and undecidability results: Church–Turing thesis, countability and diagonalization arguments, reductions, the Halting Problem, the acceptance/simulation problem, and the Post Correspondence Problem — including illustrative puzzles and proof techniques.
  1. Lambda calculus and functional foundations
  • The untyped lambda calculus: syntax, reduction rules, and encodings for booleans, conditionals, and Church numerals.
  • Construction of recursion using fixed‑point combinators (the Y combinator) and how recursion enables arithmetic and higher‑order abstractions.
  • How these formal devices underpin functional programming concepts and influence language design.
  1. Practical functional and modern language practice
  • Clojure: a compact, REPL‑driven, Lisp‑family tour that teaches core types and immutable collections, functional idioms, concurrency via immutable values plus managed mutable identities (the four reference types), and macro programming from safe macros to advanced DSL/compile‑time techniques. Also covers practical mechanics (namespaces, metadata, destructuring, reader literals, Java interop) and patterns using functions and closures.
  • Kotlin: an idiomatic, pragmatic guide for concise, safe, and interoperable JVM code. Topics include core syntax and types, null‑safety and platform types, functions and lambdas (including inline semantics), collection transformations (eager and lazy), classes/data classes/objects, generics, delegates, annotations/reflection, extension and operator conventions, and DSL construction.

Taken together, the material moves from abstract models of computation and the mathematical roots of functional programming to concrete language techniques and tooling. Readers gain theoretical insight (why certain problems are undecidable, how computation can be encoded) alongside practical skills for building robust, expressive programs in Clojure and Kotlin, and an understanding of how lambda calculus informs real‑world language features and idioms.

Modules

Turing Machine

Introduces Turing Machines, Universal Turing Machines, and core decidability/undecidability results in the theory of computation.

Lambda Calculus

Introduction and development of functional programming from its theoretical roots through lambda-calculus syntax, encodings, and recursion via the Y combinator

Clojure

A practical, REPL-driven course on Clojure covering its Lisp identity, immutable data and concurrency model, core mechanics, functions/closures, and macro programming from basics to DSLs

Kotlin

A practical, idiomatic tour of Kotlin: syntax, types, functions, functional patterns, interop, and advanced language conventions for building readable, safe, and extensible code.