Programming Paradigms

What you'll learn

• Explain what a programming paradigm is, distinguish imperative, declarative, functional, object-oriented, logic, concurrent and event-driven styles, and recognize each in code written in multi-paradigm languages.
• Write pure functions, identify side effects and explain referential transparency, and use first-class and higher-order functions, closures, partial application and composition to replace loops with pipelines.
• Use structural recursion, explain tail calls and Python's recursion limit, work with immutable and persistent data, build lazy pipelines with generators, and model data with algebraic data types and pattern matching.
• Design classes that encapsulate state behind interfaces and maintain invariants, explain identity, aliasing and dynamic dispatch, and use subtype polymorphism and duck typing.
• Apply inheritance, abstract base classes, interfaces and sealed hierarchies correctly, respect the Liskov substitution principle, prefer composition where appropriate, and apply the SOLID principles.
• Recognize and implement the strategy, observer, command, factory and decorator patterns in object-oriented and functional forms, and judge when a pattern adds needless complexity.
• Compare static and dynamic, strong and weak, and nominal and structural typing, use Python type hints with a static checker, and explain generics, variance, option types, inference and ownership types.
• Distinguish expected failures, environmental failures and bugs, and handle them appropriately with exceptions, result and option types, validation at boundaries, assertions and contracts.
• Distinguish concurrency from parallelism and CPU-bound from I/O-bound work, use threads and process pools, identify race conditions by reasoning about interleavings, and explain the effect of the GIL and the free-threaded build.
• Protect critical sections with locks, coordinate threads with queues and other primitives, analyse and prevent deadlock using the Coffman conditions and lock ordering, and design concurrency with channels and actors.
• Write event-driven and asynchronous programs with async and await while avoiding blocking calls, explain unification and backtracking in logic programming, and build dataflow and reactive pipelines.
• Design a multi-paradigm system by mapping requirements to paradigms, using a functional core with an imperative shell, parsing at boundaries, encapsulating stateful entities and parallelizing independent work.