Programming Languages

Keywords

ver. 1.0.0

From computation’s formal roots to practical functional and modern JVM language practice: theory, lambda calculus, Clojure REPL/macros, and idiomatic Kotlin.

This node connects the historical and formal foundations of computation (from Babbage, Hilbert, Gödel to Turing and Church; Turing machines, undecidability proofs) with the theory and practice of functional programming (untyped lambda calculus, encodings, fixed-point recursion) and two pragmatic language-focused courses: a REPL-driven, macro-centered Clojure guide (immutable data, concurrency, macros/DSLs, interop) and an idiomatic Kotlin tour (syntax, types, functional patterns, null-safety, interop, DSLs).

This unified module traces computation from its origins and formalization to hands-on, language-level practice. It begins with the historical and technical foundations—Babbage, Hilbert, Gödel, and the emergence of precise computation models (Turing machines and lambda calculus), formal decision problems and canonical undecidability results (Halting Problem, PCP)—and ties those models to real hardware and programming paradigms.

Building on that theory, the node develops functional programming from first principles via the untyped lambda calculus: formal syntax and reduction rules, Church encodings for booleans and naturals, and recursion via fixed-point (Y) combinators, showing how core computation constructs arise from very small primitives.

The practical half translates theory into tooling and techniques in two modern languages. The Clojure course emphasizes REPL-driven development and Lisp identity: immutable data structures, Clojure’s approach to state and concurrency (values vs mutable identities and the four reference types), core collection and functional idioms, functions and closures for abstraction, Java interop, and a progressive macro curriculum that covers hygienic patterns, safe code generation, DSLs, and compile-time techniques.

Complementing that, the Kotlin tour provides an idiomatic, pragmatic guide to writing concise, safe, and interoperable code: language design goals, core syntax, types and null-safety, functions and lambdas (including inline semantics), collection transformations (eager and lazy), classes/data classes/objects, generics, delegates, annotations and reflection, interop with Java/platform types, naming and operator conventions, and patterns for building readable DSLs.

Together the materials form a cohesive path from abstract computational theory and the lambda-calculus foundations of functional programming through concrete, modern practice in Clojure and Kotlin—equipping you to understand why languages work the way they do and how to apply functional ideas and language-specific tooling effectively.

Modules

Computation and Turing Machines

Origins and formalization of computation, Turing machines and undecidability, plus a compact history of programming languages and their paradigms

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.