Software Design: Functional Programming in C#

Explore the theoretical basics of functional programming and programming paradigms, including what functional programming is and why FBI concepts matter; learn the importance of functions and the benefits of FBI.

Explore programming paradigms with a focus on functional programming in C#. Learn how generics, Linq expressions, and method extensions enable functional style in an object oriented language, emphasizing immutability.

Explore functional programming as a declarative paradigm that treats computation as the evaluation of mathematical functions, avoids changing state, and uses immutable data for predictable, testable code.

Explore how functional programming centers on functions as first-class citizens, advocates small, single-responsibility functions with no side effects, and limits parameters to three, and aligns with patterns and solid principles.

Discover why to learn functional programming concepts, even without a truly functional language, and see how FP ideas yield shorter, more understandable code, immutability, no side effects, and safer concurrency.

Explore how functional programming treats computation as the evaluation of mathematical functions, avoids changing state and mutable data, and enforces a declarative style for more predictable, maintainable code.

Discover immutability and purity in functional programming, and analyze how side effects influence architecture. Learn how to remove side effects using command-query separation and embrace a declarative style.

Explore immutability in functional programming with C#, compare mutable and immutable objects, and see how returning new instances defeats temporal coupling and improves readability, safety, and predictability.

Explore how immutability and pure functions eliminate temporal coupling by removing shared state and most side effects, improving data flow from creation to startup.

Examine how side effects are observable changes to system state and how purity defines true pure functions, with examples like logging, division by zero, and state mutations.

Explore how side effects and state changes shape software architecture. Contain side effects at UI and data-access boundaries to protect the domain logic.

Apply command query separation by designing functions as either commands that perform actions or queries that return results, avoiding mixed logic in a single function.

Explore immutability and absence of side effects through a declarative expression-based style. See how linq-like operators and extension methods transform a collection while keeping the original unchanged.

Examine expressions with operators in c#, comparing the ternary, null-coalescing, and null-propagation operators to plain code, and showcase string interpolation for clearer, robust output.

Recap immutability and the distinction between pure and impure functions, emphasizing keeping domain logic mutable while isolating side effects at system boundaries through command query separation.

Explore functional programming in C# from a new perspective and master extension methods or properties, expression-bodied members, pattern matching, tuples, deconstruction, and local functions in C# 6 and 7.

Learn how extension methods add functionality to existing types and generics, avoid unwanted inheritance, and apply practical date-time formatting examples while highlighting primitive obsession risks.

Explore autoproperties and immutability in C# via a character armor example, showcasing immutable getter-only properties. See how constructor initialization and inline assignment interact, with priority and expression-bodied members.

Explore expression bodied members in C#, refactor the damage method and properties into concise one liners, understand getter only properties, immutability concerns, and when to avoid overuse for readability.

Explore pattern matching from the functional paradigm in C#, demonstrating how case clauses match on patterns, not constants, and how to handle objects as string or integer.

Explore value tuples in C# 7 and the System.ValueTuple type to return multiple values efficiently. Demonstrate deconstruction and named or anonymous parameters to access results.

Use local functions to define functions within a function, keeping logic cohesive and improving readability during refactoring, including scenarios with yield and async for faster feedback.

Learn functional c sharp features and what functional programming is about. Extend types with read-only methods, use properties for immutability, and apply pattern matching with tuples and local functions.

Learn to achieve immutability in C# to prevent side effects and temporal coupling, using external and internal immutability, shallow and popsicle immutability, and the builder pattern for reduced memory pressure.

Examine a mutable type in C# and the risks of changing the validity range, highlighting data spoilage, stale results, and concurrency issues that immutability in functional programming aims to prevent.

Explore external immutability in C# by turning properties private, enforcing constructor-based initialization, and creating new instances to update values without altering existing objects.

Explain how to achieve internal immutability in a range type by using read-only fields and properties set only in the constructor, preserving external immutability.

Explore shallow immutability in C# by distinguishing read-only properties from mutable internal state, then apply popsicle immutability with a freeze mechanism to prevent further changes.

Demonstrate the builder pattern for immutable objects with a fluent API and a final build, and show testing via mocks for GPS and speed sensors.

Explain why mutable structures can misbehave, highlight the copy-by-value model as the essence of immutability in value types, and compare bad and good struct designs with arrays and indexers.

Explore immutability in C# by creating new instances instead of mutating state, avoiding read-only collections reflecting changes. Implement an immutable stack with a singleton empty instance, separating pop and peek.

Recap the shift from mutable to immutable types, highlighting external or observable immutability and internal immutability, risks of exposing mutable collections, and how the builder pattern enables an immutable API.

Learn practical functional programming in C#, and explore pipelining differences. Extend the disposable interface and string builder, and apply general extensions to compose uncomposable objects and build cold chains.

Explore pipelining: pass a function's output to the next to streamline data flow, avoid intermediate variables, and use method chaining to emulate pipelines in languages lacking a dedicated operator.

Explore extending IDisposable in C# by transforming procedural file parsing into a functional flow using factory methods, using extensions, and composing disposable types for cleaner code.

Explore refactoring a procedural string-building routine into a functional, extension-based approach using string builder extensions and string interpolation, improving readability, validation, and report generation.

Explore general extensions to thread intermediate results through a chain, enabling logging in the middle and type conversions while reducing procedural noise in functional C#.

Explore how extension methods can be powerful yet invite primitive obsession when representing money, and adopt a money value object or struct to encapsulate currency logic.

Summarizes functional programming techniques and pipelining, noting that pipelining feels more natural in F# than C#, and highlights disposable interfaces and extensibility through extensions.

Explore modeling errors and exceptions in C# with guidance on when to use exceptions, validating user input, and managing critical errors, while examining alternatives to exception-based control flow.

Explore the taxonomy of errors in software design, distinguishing recoverable and unrecoverable system and user code errors, and contrasting exceptions with error codes while highlighting stack unwinding.

Explore the historical problems of exceptions, from Java's checked exceptions and their versioning and scaling flaws to C#'s shift to unchecked exceptions, and discuss global handling and corrupted state issues.

Explore practical strategies for handling exceptions in C# apps: catch near the source, avoid assuming you know all possible exceptions, suppress noise when appropriate, consider preconditions, corrupted state, and performance.

Explore three exception handling strategies in C#: known-exception catching, policy-led catch-all with a critical list, and a complete catch-all, weighing reliability, team readiness, and application size.

Explore the command-query separation principle by refactoring a log-on method into a query and a command, and examine failure handling, return types, and caller expectations.

Learn the tester-doer pattern, where a test or property acts as a query and a doer method acts as a command, while noting concurrency risks and temporal coupling.

Discover how exceptions conflict with functional programming and replace them with result types and pipelining, using a general and a value-bearing result.

Embrace functional programming in C# by pipelining methods and employing the result monad to handle recoverable errors with extension methods, then refactor complex code into simple, readable flows.

Examine method signatures in a functional C# style: void commands must not fail, returnable commands may fail and require handling, and queries should return results, addressing exceptions in the BCL.

Explore the built-in bcl exception types and why concrete exceptions trump system exceptions in C#. Learn to throw argument exceptions with the correct parameter names and avoid common misuses.

Prefer the result monad for recoverable errors and avoid custom exception types; if you implement one, inherit from system exceptions, name with invalid or user exception, ensure serializability and constructors.

Conclude by contrasting exceptions with recoverable errors handled via the result glass, adopt functional signatures with command–query separation, and apply pipelining and method changes.

Explore why null values cause exceptions and maintenance pain, and examine strategies like the null object pattern, the maybe monad, and static analysis to check control flow and reduce nulls.

Identify the problems with nulls in code, where defensive null checks clutter the codebase and hinder readability. Understand how weak semantic cohesion and unclear checks lead to null reference exceptions.

Apply the null object pattern to replace nulls with an abstract entity and a do-nothing object, preventing null reference exceptions and enabling safe defaults like a null object cache.

Explore the maybe (option) concept in C#, contrasting nullable versus non-nullable references and using a maybe wrapper to represent a value or absence, with has value and has no value.

Automate null checks at method starts for reference types using an aspect-oriented weaving tool, preserving encapsulation and enforcing non-null inputs.

Learn static analysis as a non-running code approach, using annotations to mark input and output parameters and nullability, and practice with tools that analyze methods and prevent runtime errors.

Return an empty collection when a predicate yields no results, not null, to avoid null reference errors. This clarifies missing information and lets client code safely iterate without checks.

Explore strategies to reduce null values and maintenance costs by using the null object pattern, maybe monad, and nullable value types, plus static analysis tools, and return empty collections.

Bonus lecture invites you to join the mailing list for discounts on faith courses, access links to other video courses, and subscribe to the blog and Facebook updates.