# matlus.com

> Shiv Kumar on how software should be built, and on keeping that judgment
> intact when a language model is doing the typing. Programming With Intent
> (PWI) is operationalized guidance with worked examples in Python and C#.

Every article and chapter has a raw markdown companion with no navigation or sidebar.

## Sections

- [PWI](https://matlus.com/pwi/): Programming With Intent chapters and pillars.
- [Acceptance Testing](https://matlus.com/acceptance-testing/): functional testing at the boundary.
- [Writing](https://matlus.com/writing/): essays and video-based articles.
- [Media](https://matlus.com/media/): articles with video or audio companions.
- [About](https://matlus.com/about/): about Shiv Kumar.

## Writing

- [Verified, Not Trusted: Expense Analysis, Part Two](https://matlus.com/writing/verified-not-trusted-expense-analysis-part-two/): Imperative Python controls expense analysis and verifies model contributions through source evidence, reconciliation, and exact calculations. Jev and LLMs handle bounded judgments. Markdown: https://matlus.com/writing/verified-not-trusted-expense-analysis-part-two.md
- [Pipeline Breadcrumbs](https://matlus.com/writing/pipeline-breadcrumbs/): Make long-running pipelines explain their work through numbered steps, ordered artifacts and a run manifest. Preserve evidence to investigate exceptions and incorrect results. Markdown: https://matlus.com/writing/pipeline-breadcrumbs.md
- [Verified, Not Trusted: Expense Analysis, Part One](https://matlus.com/writing/verified-not-trusted-expense-analysis-part-one/): Expense totals need verifiable source coverage and reproducible calculations. Two prompts show how parsing, category rules, refunds, and code shape the evidence. Markdown: https://matlus.com/writing/verified-not-trusted-expense-analysis-part-one.md
- [Jev: A Practical Reference](https://matlus.com/writing/jev-practical-reference/): Jev makes bounded semantic judgments with Choice, Score, and Noul; code handles exact work and policy, while evaluation and confidence gates determine when to act or escalate. Markdown: https://matlus.com/writing/jev-practical-reference.md
- [Using Jev Compact LLM Context](https://matlus.com/writing/using-jev-compact-llm-context/): Jev can shorten LLM context by scoring which tool events a current question still needs. A recorded Noul response and Python retention code show what stays and why the threshold matters. Markdown: https://matlus.com/writing/using-jev-compact-llm-context.md
- [Stampede at the Gates](https://matlus.com/writing/stampede-at-the-gates/): AI generation exposed an already flawed SDLC: faster code review moves the queue to verification, which needs functional acceptance testing at the boundary. Markdown: https://matlus.com/writing/stampede-at-the-gates.md
- [Skills versus Controlled Workflows](https://matlus.com/writing/skills-versus-controlled-workflows/): When a useful answer is enough, and when you also have to demonstrate that a prescribed procedure was followed. Markdown: https://matlus.com/writing/skills-versus-controlled-workflows.md
- [A Suite the Team Can Keep Trusting](https://matlus.com/writing/a-suite-the-team-can-keep-trusting/): A growing acceptance suite stays trustworthy through explicit scenarios and owned resources. Organize by feature, keep Act visible, review complete comparisons, and retain useful CI failures. Markdown: https://matlus.com/writing/a-suite-the-team-can-keep-trusting.md
- [Arranging Scenarios That Stay True](https://matlus.com/writing/arranging-scenarios-that-stay-true/): Random data must preserve the named test scenario. Constrained catalog sampling, immutable builders, deliberate threshold guards, and owned identities keep arrangements correct. Markdown: https://matlus.com/writing/arranging-scenarios-that-stay-true.md
- [Assertions That Verify the Whole Outcome](https://matlus.com/writing/assertions-that-verify-the-whole-outcome/): Assertions must compare every required field, count, and effect. Pure asserters separate observations from comparisons and report available failures together with verified expectations. Markdown: https://matlus.com/writing/assertions-that-verify-the-whole-outcome.md
- [From a Green Suite to a Release](https://matlus.com/writing/from-a-green-suite-to-a-release/): A green behavioral suite supports release when its evidence belongs to the build being advanced. Preserve execution receipts and verify deployed capabilities, configuration, and other release duties. Markdown: https://matlus.com/writing/from-a-green-suite-to-a-release.md
- [Functional Acceptance Testing at the Boundary](https://matlus.com/writing/functional-acceptance-testing-at-the-boundary/): Functional acceptance tests verify complete outcomes through the assembled system. Correct arrangements, deep assertions, and controlled observations support release confidence. Markdown: https://matlus.com/writing/functional-acceptance-testing-at-the-boundary.md
- [Idempotency and Concurrent Requests](https://matlus.com/writing/idempotency-and-concurrent-requests/): Repeated and concurrent order requests must preserve accepted outcomes without duplicate work. Compare canonical request identity, allowed race outcomes, stored facts, and outgoing effects. Markdown: https://matlus.com/writing/idempotency-and-concurrent-requests.md
- [Knowing Which Scenarios a Feature Requires](https://matlus.com/writing/knowing-which-scenarios-a-feature-requires/): A green suite needs correct scenarios for established requirements. An obligation map connects each rule to its arrangement, expected outcome, independent observation, and assertion. Markdown: https://matlus.com/writing/knowing-which-scenarios-a-feature-requires.md
- [Learning a System Through Its Tests](https://matlus.com/writing/learning-a-system-through-its-tests/): Acceptance tests let teammates learn requirements and production behavior together. Follow one order through Arrange, the visible Act, independent observations, and complete assertions. Markdown: https://matlus.com/writing/learning-a-system-through-its-tests.md
- [One Order, Every Obligation](https://matlus.com/writing/one-order-every-obligation/): One ordering scenario verifies the caller result, stored lines, fulfillment, and confirmation. Follow its complete C# test, independent observations, and accumulated failure reports. Markdown: https://matlus.com/writing/one-order-every-obligation.md
- [Questions About Functional Acceptance Testing at the Boundary](https://matlus.com/writing/questions-about-functional-acceptance-testing-at-the-boundary/): Boundary testing questions concern evidence, isolation, failures, and release confidence. Compare the practice with mocks, TDD, generated checks, formal models, and production observation. Markdown: https://matlus.com/writing/questions-about-functional-acceptance-testing-at-the-boundary.md
- [Refactoring and Adopting Boundary Testing](https://matlus.com/writing/refactoring-and-adopting-boundary-testing/): A stable Domain Facade lets acceptance scenarios and assertions survive internal refactoring. Adapt test support behind unchanged observations and adopt complete boundary tests feature by feature. Markdown: https://matlus.com/writing/refactoring-and-adopting-boundary-testing.md
- [Refusals, Failures, and Work Still Owed](https://matlus.com/writing/refusals-failures-and-work-still-owed/): Failure timing determines what an order still owes. Verify refusal, real transaction rollback, post-commit action failures, and accepted effects whose completion could not be recorded. Markdown: https://matlus.com/writing/refusals-failures-and-work-still-owed.md
- [Testing Against Real Infrastructure](https://matlus.com/writing/testing-against-real-infrastructure/): Real infrastructure must participate when transactions and messages are required outcomes. Provision SQL and broker topology, isolate runs, define observation windows, and verify actual rollback. Markdown: https://matlus.com/writing/testing-against-real-infrastructure.md
- [Testing the Service Interface](https://matlus.com/writing/testing-the-service-interface/): Interface tests verify wire conversion and exception translation at their owning boundaries. Controller Hooks, middleware checks, and hosted HTTP scenarios complement domain acceptance. Markdown: https://matlus.com/writing/testing-the-service-interface.md
- [The Regression Suite the Business Is Paying For](https://matlus.com/writing/the-regression-suite-the-business-is-paying-for/): The maintained regression suite protects earlier business behavior as new features change the system. Keep approved expectations, run the required suite, and preserve lessons as permanent scenarios. Markdown: https://matlus.com/writing/the-regression-suite-the-business-is-paying-for.md
- [The Test Mediator and the Transport Spy](https://matlus.com/writing/the-test-mediator-and-the-transport-spy/): A Test Mediator and transport spy control delivery and expose observations while production gateways run. Capture email content, script retries, and measure bounded response reads. Markdown: https://matlus.com/writing/the-test-mediator-and-the-transport-spy.md
- [AI-native SDLC](https://matlus.com/writing/ai-native-sdlc/): Engineering both gates requires certified code review, functional acceptance tests at the boundary ratified by humans, and verification against the specification. Markdown: https://matlus.com/writing/ai-native-sdlc.md
- [Let's Talk - Null Conditional Operator. No Thank you!](https://matlus.com/writing/null-conditional-operator-no-thank-you/): Use null-conditional calls only when skipping work is correct. Required logging and optional disposal expose the difference between nullable warnings and runtime behavior. Markdown: https://matlus.com/writing/null-conditional-operator-no-thank-you.md
- [Prefer Composition Over Inheritance](https://matlus.com/writing/prefer-composition-over-inheritance/): Composition keeps a configuration provider's capabilities limited to what its project needs. The refactor uses self-contained settings providers, a shallow base, and restrained reuse. Markdown: https://matlus.com/writing/prefer-composition-over-inheritance.md
- [High Performance Logging and Custom Objects](https://matlus.com/writing/high-performance-logging-custom-objects/): An application logging adapter can accept a DTO and expose its fields as structured state. ILogger.Log<TState> separates that context from the formatted message. Markdown: https://matlus.com/writing/high-performance-logging-custom-objects.md
- [To LINQ or Not to LINQ](https://matlus.com/writing/to-linq-or-not-to-linq/): Repeated work can hide inside a short LINQ query. A customer-filtering benchmark separates string conversions, lookup choices, iteration and changed behavior. Markdown: https://matlus.com/writing/to-linq-or-not-to-linq.md
- [Abstraction in Software Design, with Examples](https://matlus.com/writing/abstraction-in-software-design-examples/): Give callers domain operations while collections and gateways own the details: service orchestration, model mapping and translation of recognized failures into domain exceptions. Markdown: https://matlus.com/writing/abstraction-in-software-design-examples.md
- [SOLID IS OLD: Dependency Inversion Needs a Good Abstraction](https://matlus.com/writing/solid-is-old/): Dependency inversion needs domain-owned contracts that hide implementation knowledge. Follow a show query from source dependencies through models to a stored procedure. Markdown: https://matlus.com/writing/solid-is-old.md
- [Abstraction in Software Design](https://matlus.com/writing/abstraction-in-software-design/): Useful abstractions express the caller's needs precisely. Broker, database and charting examples show where SDK types, storage details and excess generality get in the way. Markdown: https://matlus.com/writing/abstraction-in-software-design.md
- [Always Use the "as" Operator? No Thank You!](https://matlus.com/writing/always-use-as-operator-no-thank-you/): Use a cast instead of `as` when the type is expected, so a mismatch raises InvalidCastException. Use `is` when the type genuinely varies and keep only guards backed by a real case. Markdown: https://matlus.com/writing/always-use-as-operator-no-thank-you.md
- [Validating Formal Arguments? No Thank You!](https://matlus.com/writing/validating-formal-arguments-no-thank-you/): Validate and clean data at the front and back doors; skip checks on internal formal arguments. Immutable DTOs preserve trust, one exception reports all errors, and black box tests exercise the doors. Markdown: https://matlus.com/writing/validating-formal-arguments-no-thank-you.md
- [Creating Instances, Using Inheritance: No Thank You!](https://matlus.com/writing/creating-instances-using-inheritance/): Create instances for state or polymorphism and use inheritance for a common consumer. Static behavior and composition can keep testing from dictating every class's shape. Markdown: https://matlus.com/writing/creating-instances-using-inheritance.md
- [Separate State from Behavior? Yes Please!](https://matlus.com/writing/separate-state-from-behavior/): Business operations are easier to trace when immutable DTOs carry facts and stateless managers validate inputs and coordinate work through named methods at the call site. Markdown: https://matlus.com/writing/separate-state-from-behavior.md
- [So You Think You Know C#? ValueTuples and Deconstruction](https://matlus.com/writing/csharp-valuetuples-deconstruction/): Named ValueTuples make small results readable. Positional fields, copy behavior and Deconstruct methods explain the syntax and the limits of tuple return types. Markdown: https://matlus.com/writing/csharp-valuetuples-deconstruction.md
- [Builder Pattern and C# Expressions](https://matlus.com/writing/builder-pattern-csharp-expressions/): Test-data builders keep each scenario's chosen values visible. C# expression trees select model properties, and stored overrides preserve explicit nulls. Markdown: https://matlus.com/writing/builder-pattern-csharp-expressions.md
- [Adapter Design Pattern: Testing Service Bus Using RabbitMQ Locally](https://matlus.com/writing/adapter-pattern-rabbitmq/): The Adapter pattern keeps application messaging independent of broker SDKs by translating messages, callbacks and acknowledgements between RabbitMQ and Service Bus. Markdown: https://matlus.com/writing/adapter-pattern-rabbitmq.md
- [Design Nugget: Evolution To Strategy](https://matlus.com/writing/design-nugget-evolution-to-strategy/): Build a working baseline, then change the design for a concrete benefit; a log parser evolves through a switch, delegates, and Strategy to test that judgment. Markdown: https://matlus.com/writing/design-nugget-evolution-to-strategy.md
- [Custom Data Structure: A One-to-Many Mapping](https://matlus.com/writing/csharp-one-to-many-mapping/): A one-to-many map must enforce unique values and return a key from a value. Shared tests and four implementations show how correctness shapes a benchmark. Markdown: https://matlus.com/writing/csharp-one-to-many-mapping.md
- [So You Think You Know C#? LINQ](https://matlus.com/writing/csharp-linq-execution/): LINQ rewrites can add work while removing repetition. Customer filters expose query projections, lookup choices and why benchmarks must compare equal results. Markdown: https://matlus.com/writing/csharp-linq-execution.md
- [ASP.NET Core Web API by Hand](https://matlus.com/writing/aspnet-core-web-api-by-hand/): A terminal request delegate exposes the work behind an ASP.NET Core endpoint. A movie-service experiment compares a narrow handler with the controller pipeline. Markdown: https://matlus.com/writing/aspnet-core-web-api-by-hand.md
- [So You Think You Know C#? The StringBuilder Myth](https://matlus.com/writing/csharp-stringbuilder-myth/): StringBuilder suits growing results, but can cost more for fixed concatenation. Compiler output, allocations and benchmark checks explain when to choose it. Markdown: https://matlus.com/writing/csharp-stringbuilder-myth.md
- [So You Think You Know C#? Generics Under the Hood](https://matlus.com/writing/csharp-generics-under-the-hood/): .NET generics retain runtime type arguments. Typed lists avoid boxing value-type elements, while CLR specialization and code sharing preserve distinct types. Markdown: https://matlus.com/writing/csharp-generics-under-the-hood.md
- [So You Think You Know C#? Constants and Default Parameter Values](https://matlus.com/writing/csharp-constants-default-parameters/): C# embeds constants and default parameter values in compiled callers. Library-only builds and IL inspection explain why callers must be rebuilt to adopt changed values. Markdown: https://matlus.com/writing/csharp-constants-default-parameters.md
- [So You Think You Know C#? Constructors](https://matlus.com/writing/csharp-constructors/): C# construction order determines which fields are ready. Field initializers, constructor chaining, virtual dispatch and static initialization explain what runs when. Markdown: https://matlus.com/writing/csharp-constructors.md
- [So You Think You Know C#? For vs. Foreach](https://matlus.com/writing/csharp-for-foreach/): The type a foreach loop sees determines its enumeration path. Array lowering, list enumerators and yield state machines explain the work behind the syntax. Markdown: https://matlus.com/writing/csharp-for-foreach.md
- [So You Think You Know C#? Delegates and Higher Order Functions](https://matlus.com/writing/csharp-delegates-higher-order-functions/): Delegates let callers supply behavior to reusable methods. Lambda syntax and SingleElseException show how higher order functions add useful failure details. Markdown: https://matlus.com/writing/csharp-delegates-higher-order-functions.md
- [So You Think You Know C#? Static Classes](https://matlus.com/writing/csharp-static-classes/): Choose static classes when instances serve no purpose. Shared type state, autonomous methods and immutable inputs explain the discipline that makes them useful. Markdown: https://matlus.com/writing/csharp-static-classes.md
- [So You Think You Know C#? The Fundamentals](https://matlus.com/writing/csharp-value-reference-fundamentals/): C# passes arguments by value by default. Integer, string and object examples explain what gets copied, how ref works and which changes reach the caller. Markdown: https://matlus.com/writing/csharp-value-reference-fundamentals.md
- [C# 8 - Async Streams](https://matlus.com/writing/csharp-8-async-streams/): Async streams let callers process database rows before the full result exists. An async iterator combines await and yield return, keeping its reader open during enumeration. Markdown: https://matlus.com/writing/csharp-8-async-streams.md
- [Benchmarking .NET Applications](https://matlus.com/writing/benchmarking-dotnet-applications/): A benchmark tests whether a change improves the same operation. BenchmarkDotNet makes input choice, setup, timing and allocation costs visible for .NET code. Markdown: https://matlus.com/writing/benchmarking-dotnet-applications.md
- [Programming to Exceptions, Part 2: Diagnostics and Boundaries](https://matlus.com/writing/programming-to-exceptions-diagnostics-and-boundaries/): Specific exceptions preserve failure meaning, causes, and context. A shallow C# hierarchy, Gateway translation, and middleware enrichment carry diagnostic records across service boundaries. Markdown: https://matlus.com/writing/programming-to-exceptions-diagnostics-and-boundaries.md
- [Programming to Exceptions, Part 3: Logging and Progress](https://matlus.com/writing/programming-to-exceptions-logging-and-progress/): Structured logs preserve the facts needed to investigate failures. Application Insights custom dimensions make them searchable, while typed progress events track long-running work. Markdown: https://matlus.com/writing/programming-to-exceptions-logging-and-progress.md
- [Programming to Exceptions, Part 1: Method Contracts and Failure](https://matlus.com/writing/programming-to-exceptions-method-contracts/): Method contracts let callers rely on completed work and let failures propagate. C# examples distinguish retrieval from search, validate domain entry points, and assign handling to its owner. Markdown: https://matlus.com/writing/programming-to-exceptions-method-contracts.md
- [Mocking? No Thank You!](https://matlus.com/writing/mocking-no-thank-you/): Test whole features through the public surface so regression tests survive later design changes. Class mocks bind tests to internals; transport doubles cover rare external failures. Markdown: https://matlus.com/writing/mocking-no-thank-you.md
- [Dependency Injection? No Thank You!](https://matlus.com/writing/dependency-injection-no-thank-you/): Dependency injection exposes private collaborators to callers when used for every internal relationship. Keep classes self-contained and let business code choose real variation. Markdown: https://matlus.com/writing/dependency-injection-no-thank-you.md
- [Interfaces? No Thank You!](https://matlus.com/writing/interfaces-no-thank-you/): C# interfaces do not inherently create contracts or loose coupling. Composition handles hierarchy conflicts; capability interfaces and structural typing let consumers see only what they need. Markdown: https://matlus.com/writing/interfaces-no-thank-you.md
- [Extension Methods? No Thank You!](https://matlus.com/writing/extension-methods-no-thank-you/): Keep project-specific helpers as static methods: extension methods hide behavior behind namespaces and can change meaning with imports. Use them when they serve the wider C# community. Markdown: https://matlus.com/writing/extension-methods-no-thank-you.md
- [Factory Pattern: The Enabler of Polymorphism](https://matlus.com/writing/factory-pattern/): A Factory selects and constructs a concrete descendant while callers program to an interface through the base class's public contract. C# thumbnailers show selection and polymorphic dispatch. Markdown: https://matlus.com/writing/factory-pattern.md
- [.NET Memory Allocations and Performance, Part 2](https://matlus.com/writing/dotnet-memory-allocations-part-2/): CPU caches reward useful data kept close together. Pipelines, branch prediction and cache lines explain why memory access patterns matter to .NET performance. Markdown: https://matlus.com/writing/dotnet-memory-allocations-part-2.md
- [The Configuration Provider: Roles and Responsibilities](https://matlus.com/writing/configuration-provider-design-pattern/): A Configuration Provider hides the source and returns validated, typed settings. Useful exceptions and composed settings providers keep configuration rules in one place. Markdown: https://matlus.com/writing/configuration-provider-design-pattern.md
- [The Gateway Design Pattern: Roles and Responsibilities](https://matlus.com/writing/gateway-design-pattern/): A Gateway presents business operations, translates service models and transforms failures into domain exceptions, keeping external service details behind one boundary. Markdown: https://matlus.com/writing/gateway-design-pattern.md
- [.NET Memory Allocations and Performance](https://matlus.com/writing/dotnet-memory-allocations/): .NET allocation costs follow what gets stored and copied. Structs, classes, arrays and strings explain object layout, references and garbage collection. Markdown: https://matlus.com/writing/dotnet-memory-allocations.md
- [Clean Abstractions Around Libraries](https://matlus.com/writing/clean-abstractions-around-libraries/): A library boundary owns the application's contract even when its terms match the library's. It contains provider types, validation, failures, and configuration, and keeps replacement possible. Markdown: https://matlus.com/writing/clean-abstractions-around-libraries.md
- [Intentional Model Design](https://matlus.com/writing/intentional-model-design/): A model should express required fields, genuine absence, and distinct variants in its type. Python unions and C# records encode those promises, while boundaries check external values. Markdown: https://matlus.com/writing/intentional-model-design.md
- [Using LocalDB in Visual Studio Online](https://matlus.com/writing/using-localdb-in-visual-studio-online/): Run database tests on Visual Studio Online by creating a LocalDB instance, publishing a dacpac, and invoking the batch file from the build definition's Pre Test Script. Markdown: https://matlus.com/writing/using-localdb-in-visual-studio-online.md
- [Factory Method Pattern: The Most Beautiful Pattern We Lost](https://matlus.com/writing/factory-method-pattern/): Factory Method lets consumer subclasses choose dependencies through an overridable creation hook. C# examples show its two class families and distinguish it from a separate Factory. Markdown: https://matlus.com/writing/factory-method-pattern.md
- [Async-Await in C#](https://matlus.com/writing/async-await-in-csharp/): Asynchronous I/O frees server threads during waits and can improve capacity under load. IIS request flow, Task.WhenAll, and load tests show where the benefit ends. Markdown: https://matlus.com/writing/async-await-in-csharp.md
- [Azure Startup Tasks – Running as Administrator](https://matlus.com/writing/azure-startup-tasks-running-as-administrator/): Azure role startup configuration affects IIS administration. An OnStart impersonation example and a later elevated Runtime update explain the approaches explored. Markdown: https://matlus.com/writing/azure-startup-tasks-running-as-administrator.md
- [Installing MSMQ in an Azure WebRole instance](https://matlus.com/writing/installing-msmq-in-an-azure-webrole-instance/): Use a local MSMQ queue to move large-file processing out of an Azure WebRole request, then install the queue service with a startup task and deploy its batch file. Markdown: https://matlus.com/writing/installing-msmq-in-an-azure-webrole-instance.md
- [Cross Domain RESTful CRUD Operations using jQuery](https://matlus.com/writing/cross-domain-restful-crud-operations-using-jquery/): Cross-domain CRUD needs changes on both sides: a Web API DelegatingHandler handles origin headers and method overrides while jQuery sends the matching requests. Markdown: https://matlus.com/writing/cross-domain-restful-crud-operations-using-jquery.md
- [jQuery.data()–Assigning objects to dynamic elements](https://matlus.com/writing/jquery-data-assigning-objects-to-dynamic-elements/): Store a complete JSON object in a dynamic element's data attribute, then retrieve it with jQuery.data() to populate a form without extracting each attribute. Markdown: https://matlus.com/writing/jquery-data-assigning-objects-to-dynamic-elements.md
- [A Generic RESTful CRUD HttpClient](https://matlus.com/writing/a-generic-restful-crud-httpclient/): A generic HttpClient wraps asynchronous RESTful CRUD operations and JSON formatting. A MemberRepository and console client show how to use it with typed resources. Markdown: https://matlus.com/writing/a-generic-restful-crud-httpclient.md
- [ASP.NET Web API Supporting RESTful CRUD Operations](https://matlus.com/writing/as-net-web-api-supporting-restful-crud-operations/): Map member CRUD operations to HTTP methods and resource URIs, then implement an ApiController with response status codes, Location headers, and error responses. Markdown: https://matlus.com/writing/as-net-web-api-supporting-restful-crud-operations.md
- [DelegatingHandler for X-HTTP-Method-Override](https://matlus.com/writing/delegatinghandler-for-x-http-method-override/): An X-HTTP-Method-Override header lets POST requests carry PUT or DELETE intent. A Web API DelegatingHandler translates the method before controller dispatch. Markdown: https://matlus.com/writing/delegatinghandler-for-x-http-method-override.md
- [JsonpMediaTypeFormatter–Web API JSONP](https://matlus.com/writing/jsonpmediatypeformatter-web-api-jsonp/): A JsonMediaTypeFormatter subclass wraps JSON in a callback for JSONP responses. Registration and controller-level control explain both the solution and its limits. Markdown: https://matlus.com/writing/jsonpmediatypeformatter-web-api-jsonp.md
- [HttpClient .NET 4.5](https://matlus.com/writing/httpclient-net-4-5/): Use HttpClient to send GET, POST, PUT, and DELETE requests, serialize Customer objects with ObjectContent, and read typed responses from a self-hosted Web API. Markdown: https://matlus.com/writing/httpclient-net-4-5.md
- [Self Host ASP.NET Web API](https://matlus.com/writing/self-host-asp-net-web-api/): Run an ASP.NET Web API in a console process with HttpSelfHostServer, register routes, and exercise a CustomersController backed by an in-memory customer list. Markdown: https://matlus.com/writing/self-host-asp-net-web-api.md
- [ASP.NET Web API with WebForms](https://matlus.com/writing/asp-net-web-api-with-webforms/): Add an ApiController to an ASP.NET WebForms project and register its HTTP route in Global.asax, then test customer requests and inspect JSON or XML responses. Markdown: https://matlus.com/writing/asp-net-web-api-with-webforms.md
- [REST APIs, PUT and DELETE cause HTTP Error 404.0 - Not Found](https://matlus.com/writing/rest-apis-put-and-delete-cause-http-error-404/): PUT and DELETE requests can stop at IIS before reaching a REST API. Add the verbs to the extensionless handler through IIS Manager or IIS Express configuration. Markdown: https://matlus.com/writing/rest-apis-put-and-delete-cause-http-error-404.md
- [C# to Html Syntax Highlighter using Roslyn](https://matlus.com/writing/c-to-html-syntax-highlighter-using-roslyn/): Roslyn syntax trees and semantic information drive a C# to HTML highlighter, with a SyntaxWalker and explicit handling for type names whose definitions are unavailable. Markdown: https://matlus.com/writing/c-to-html-syntax-highlighter-using-roslyn.md
- [Disrupting the World Wide Web - Innovating the World Wide Net](https://matlus.com/writing/innovating-the-world-wide-net/): The World Wide Net vision connects people through programmable devices, native applications, and an operating-system sandbox that reaches beyond the browser. Markdown: https://matlus.com/writing/innovating-the-world-wide-net.md
- [WCF 4.0 Getting Started](https://matlus.com/writing/wcf-4-0-getting-started/): Build a WCF service and client around Customer contracts, then configure transport bindings, create client proxies, and publish metadata through WSDL and MEX. Markdown: https://matlus.com/writing/wcf-4-0-getting-started.md
- [ASP.NET Response.Redirect Performance Issue](https://matlus.com/writing/asp-net-response-redirect-performance-issue/): Use the Response.Redirect overload with endResponse set to false to avoid ThreadAbortException, then structure request handling so execution finishes deliberately. Markdown: https://matlus.com/writing/asp-net-response-redirect-performance-issue.md
- [HttpWebRequest - Asynchronous Programming Model/Task.Factory.FromAsyc](https://matlus.com/writing/httpwebrequest-asynchronous-programming/): HttpWebRequest callbacks and Task.Factory.FromAsync support asynchronous GET and POST calls, with five approaches compared for collecting concurrent responses. Markdown: https://matlus.com/writing/httpwebrequest-asynchronous-programming.md
- [Linq - SelectMany](https://matlus.com/writing/linq-selectmany/): SelectMany flattens related sequences into a single result. Categories and posts explain its collection selector, result selector, joins, and nested foreach behavior. Markdown: https://matlus.com/writing/linq-selectmany.md
- [Data Parallel – Parallel Programming in C#/.NET](https://matlus.com/writing/data-parallel-parallel-programming-in-net/): Data parallelism distributes compute-bound work across cores. Prime-counting examples compare PLINQ, Parallel.For, thread-local state, partitioning, and measured timings. Markdown: https://matlus.com/writing/data-parallel-parallel-programming-in-net.md
- [Getting the No Of CPUs and Cores](https://matlus.com/writing/getting-the-no-of-cpus-and-cores/): WMI queries expose core counts, logical and physical processors, bitness, and architecture in C#, with narrower queries returning only the CPU information required. Markdown: https://matlus.com/writing/getting-the-no-of-cpus-and-cores.md
- [IAsyncResult–Making Existing methods Asnchronous](https://matlus.com/writing/iasyncresult-making-existing-methods-asnchronous/): Expose an existing synchronous method through Begin and End operations using delegates and IAsyncResult, carrying callback state while reusing the original computation. Markdown: https://matlus.com/writing/iasyncresult-making-existing-methods-asnchronous.md
- [UrlEncode –The correct encoding](https://matlus.com/writing/urlencode-the-correct-encoding/): A C# UrlEncode implementation preserves unreserved characters and percent-encodes others, with character-by-character comparisons against HttpUtility.UrlEncode. Markdown: https://matlus.com/writing/urlencode-the-correct-encoding.md
- [Linq Group By - Finding Duplicates](https://matlus.com/writing/linq-group-by-finding-duplicates/): Group lessons by AddedDate and select groups containing more than one item to find duplicates with LINQ, retaining the shared date and all matching lesson objects. Markdown: https://matlus.com/writing/linq-group-by-finding-duplicates.md
- [MSSQL–Reset Identity seed](https://matlus.com/writing/mssql-reset-identity-seed/): DBCC CHECKIDENT resets an identity seed to a chosen value. A table example explains why the reseed value precedes the desired next identifier after test data is deleted. Markdown: https://matlus.com/writing/mssql-reset-identity-seed.md
- [Stop/Start Windows Service](https://matlus.com/writing/stopstart-windows-service/): Start, stop, and restart Windows services from C# using net commands or ServiceController, with redirected process output, error handling, and completion waits. Markdown: https://matlus.com/writing/stopstart-windows-service.md
- [DataContractSerializer-IEnumerable<T>](https://matlus.com/writing/ienumerablet-datacontractserializer/): A JsonSerializer streams IEnumerable<T> directly to JSON, preserving DataMember names and supporting JSONP while a DbDataReader wrapper avoids building an intermediate list. Markdown: https://matlus.com/writing/ienumerablet-datacontractserializer.md
- [svcTraceViewer - Debugging WCF Sevices](https://matlus.com/writing/svctraceviewer-debugging-wcf-sevices/): Configure WCF tracing in Web.config and open the resulting .svclog in svcTraceViewer to find the exception hidden behind a vague service error message. Markdown: https://matlus.com/writing/svctraceviewer-debugging-wcf-sevices.md
- [Fastest Website on the Planet!](https://matlus.com/writing/fastest-website-on-the-planet/): Matlus recorded high YSlow and PageSpeed scores after moving to Orion, with ShowSlow rankings and Google crawl charts illustrating the site's performance in 2011. Markdown: https://matlus.com/writing/fastest-website-on-the-planet.md
- [Orion - A Blog Engine](https://matlus.com/writing/orion/): Orion powered Matlus with Quartz for ASP.NET and Windows Live Writer support. Its original release explains the Visual Studio solution and required Quartz project reference. Markdown: https://matlus.com/writing/orion.md
- [MetaWeblog API C# Library](https://matlus.com/writing/metaweblog-api-c-library/): An IMetaWeblogProvider separates blog operations from XML and HTTP. MetaWeblogManager translates requests, while an IHttpHandler connects the library to a blog engine. Markdown: https://matlus.com/writing/metaweblog-api-c-library.md
- [Data Access Layer CodeGen](https://matlus.com/writing/data-access-layer-codegen/): Stored-procedure metadata drives ADO.NET code generation and typed DbDataReader wrappers, supporting streamed results or materialized lists according to how callers use the data. Markdown: https://matlus.com/writing/data-access-layer-codegen.md
- [OAuth C# Library](https://matlus.com/writing/oauth-c-library/): An OAuth 1.0 C# library handles request and access tokens across providers. A web application demonstrates authorization redirects and a later request for user information. Markdown: https://matlus.com/writing/oauth-c-library.md
- [C# Class Factory - High Performance](https://matlus.com/writing/high-performance-class-factory/): A Factory decouples payment processing from concrete classes, discovers implementations, and caches constructor delegates built with DynamicMethod and ILGenerator. Markdown: https://matlus.com/writing/high-performance-class-factory.md
- [The Purpose and function of a Data Access Layer](https://matlus.com/writing/the-purpose-and-function-of-a-data-access-layer/): A Data Access Layer isolates business logic from the logical data model through domain-specific methods, stored procedures, and results shaped for the business layer. Markdown: https://matlus.com/writing/the-purpose-and-function-of-a-data-access-layer.md
- [ASP.NET Performance-Instantiating Business Layers](https://matlus.com/writing/instantiating-business-layers-asp-net-performance/): Create a BusinessModule in HttpApplication.Init to reuse it across requests. The proposed ASP.NET design relies on application-instance ownership and stateless business layers. Markdown: https://matlus.com/writing/instantiating-business-layers-asp-net-performance.md
- [DataReader Wrappers - TypeSafe](https://matlus.com/writing/datareader-wrappers-typesafe/): Typed DbDataReader wrappers centralize field access and null handling. Examples compare reusing one wrapper through IEnumerable<T> with creating objects for a List<T>. Markdown: https://matlus.com/writing/datareader-wrappers-typesafe.md
- [Quartz for ASP.NET](https://matlus.com/writing/quartz-for-aspnet/): Quartz composes ASP.NET pages through a Builder, reusable HTML templates, and view objects. The walkthrough covers their relationships and Visual Studio templates. Markdown: https://matlus.com/writing/quartz-for-aspnet.md
- [ChangeType<T> - Changing the type of a variable in C#](https://matlus.com/writing/changetypet-changing-the-type-of-a-variable-in-c/): ChangeType<T> converts request strings through registered binders, handling numbers, arrays, enums, and custom DTOs while keeping conversion calls consistent across web pages. Markdown: https://matlus.com/writing/changetypet-changing-the-type-of-a-variable-in-c.md
- [Razor Engine Host](https://matlus.com/writing/razor-engine-host/): A Razor host wrapper parses templates and compiles generated C# outside ASP.NET. A custom base class supplies execution and output methods for a desktop example. Markdown: https://matlus.com/writing/razor-engine-host.md
- [ASP.NET MVC Framework Design Problems](https://matlus.com/writing/problems-with-asp-net-mvc-framework-design/): ASP.NET MVC's indirect access to views spreads responsibilities across controllers and templates. ViewData, child actions, and typed view instances frame the critique. Markdown: https://matlus.com/writing/problems-with-asp-net-mvc-framework-design.md
- [ASP.NET MVC3 - Razor View Engine](https://matlus.com/writing/asp-net-mvc3-razor-view-engine/): Razor makes C# mixed with HTML easier to read through its @ syntax, code blocks, layouts, and sections. Worked templates show the output and the limits of view responsibilities. Markdown: https://matlus.com/writing/asp-net-mvc3-razor-view-engine.md
- [Html5 File Upload with Progress](https://matlus.com/writing/html5-file-upload-with-progress/): XMLHttpRequest and FormData upload files while the page stays open. File metadata, progress events, and completion handlers build a working HTML5 example. Markdown: https://matlus.com/writing/html5-file-upload-with-progress.md
- [IE 9 Beta - What's hot and what's not](https://matlus.com/writing/ie-9-beta-whats-hot-and-whats-not/): IE 9 Beta improves performance and standards support, while its tabs and navigation need work. A 2010 assessment connects browser controls with everyday use. Markdown: https://matlus.com/writing/ie-9-beta-whats-hot-and-whats-not.md
- [Google TV, Apple TV or just a computer](https://matlus.com/writing/google-tv-apple-tv-or-just-a-computer/): Connecting a desktop computer to an HD TV keeps familiar applications and browser access. The setup covers video, audio, wireless controls, and online video quality. Markdown: https://matlus.com/writing/google-tv-apple-tv-or-just-a-computer.md
- [The Future of Flash Player](https://matlus.com/writing/the-future-of-flash-player/): Flash Player needs broader codec support and HTTP Range requests to compete with HTML5 video. The 2010 argument weighs video quality, hardware decoding, and seeking. Markdown: https://matlus.com/writing/the-future-of-flash-player.md
- [Html 5 Video Element Poster](https://matlus.com/writing/html-5-video-element-poster/): The HTML5 video poster should remain until playback begins. A 2010 critique explains why selected thumbnails matter more than automatically showing the first frame. Markdown: https://matlus.com/writing/html-5-video-element-poster.md
- [Finding links on a Web page](https://matlus.com/writing/finding-links-on-a-web-page/): Find links to a target domain with HtmlAgilityPack and C#. A LinkFinder downloads HTML, selects anchor elements, and returns their text and attributes. Markdown: https://matlus.com/writing/finding-links-on-a-web-page.md
- [Expanding Code listings](https://matlus.com/writing/expanding-code-listings/): Expand code listings beyond fixed-width page layouts with jQuery. A wrapper supplies titles and icons, while a temporary overlay displays the full listing. Markdown: https://matlus.com/writing/expanding-code-listings.md
- [H.264 Free for Internet Broadcast](https://matlus.com/writing/h-264-free-for-internet-broadcast/): MPEG LA's 2010 announcement extends royalty-free treatment for Internet video that is free to viewers, while leaving H.264 product and browser licensing distinct. Markdown: https://matlus.com/writing/h-264-free-for-internet-broadcast.md
- [Setting up IIS 7.0 - Ftp 7.5 for IIS Manager Users](https://matlus.com/writing/iis-manager-users/): IIS FTP 7.5 can authenticate IIS Manager Users with isolated directories. Folder permissions, provider settings, and C# user creation complete the setup. Markdown: https://matlus.com/writing/iis-manager-users.md
- [Flash Mobile 10.1 is Slow](https://matlus.com/writing/flash-mobile-10-1-is-slow/): Flash Mobile performance comparisons need equivalent workloads. A 2010 critique separates shared bandwidth, extra downloads, and execution costs from unsupported conclusions. Markdown: https://matlus.com/writing/flash-mobile-10-1-is-slow.md
- [Html 5 Video and Flash](https://matlus.com/writing/html-5-video-and-flash/): HTML5 video playback varied across browsers in 2010. Tests compare HD playback, CPU use, codec support, and full-screen behavior with Flash and native players. Markdown: https://matlus.com/writing/html-5-video-and-flash.md

## PWI chapters

- [Architecture with Intent](https://matlus.com/pwi/architecture-with-intent/): Layers, boundaries, and where responsibility belongs.
- [Programming with Intent](https://matlus.com/pwi/programming-with-intent/): Classes, methods, naming, and the shape of everyday code.
- [Programming to Exceptions](https://matlus.com/pwi/programming-to-exceptions/): Failure as a designed path rather than an afterthought.
- [Architecture with Intent](https://matlus.com/pwi/architecture-layers/): The Domain Facade exposes business operations while internal classes call one level down. Managers orchestrate workflows and own configuration and service boundaries. Markdown: https://matlus.com/pwi/architecture-layers.md
  - [Architecture Layers (csharp)](https://matlus.com/pwi/architecture-layers/csharp/): Structure communicates intent: strict layers from Domain Facade to Gateway, internal by default with a public surface the compiler enforces, and folder depth that marks each class's level of abstraction. Markdown: https://matlus.com/pwi/architecture-layers/csharp.md
  - [Architecture Layers (python)](https://matlus.com/pwi/architecture-layers/python/): Structure communicates intent: strict layers from Domain Facade to Gateway, a public surface declared in the boundary __init__.py, and folder depth that marks each class's level of abstraction. Markdown: https://matlus.com/pwi/architecture-layers/python.md
- [Class Design](https://matlus.com/pwi/class-design/): published examples.
  - [Class Design (csharp)](https://matlus.com/pwi/class-design/csharp/): Internal by default, behavior-only classes against state-only types, the two sanctioned uses of interfaces, and closing concrete descendants. Markdown: https://matlus.com/pwi/class-design/csharp.md
  - [Class Design (python)](https://matlus.com/pwi/class-design/python/): Two kinds of class and why that separation holds, no inheritance for extension, and naming conventions for polymorphic types. Markdown: https://matlus.com/pwi/class-design/python.md
- [Method Design](https://matlus.com/pwi/method-design/): published examples.
  - [Method Design (csharp)](https://matlus.com/pwi/method-design/csharp/): C# methods tell callers what they do through explicit visibility, truthful signatures, and returns that express action, query, and cardinality; their bodies orchestrate at one level. Markdown: https://matlus.com/pwi/method-design/csharp.md
  - [Method Design (python)](https://matlus.com/pwi/method-design/python/): Python methods make work and contracts clear: pass operation data explicitly, orchestrate at one abstraction level, and let ordinary actions return `None` while queries return data or raise. Markdown: https://matlus.com/pwi/method-design/python.md
- [Naming Conventions](https://matlus.com/pwi/naming-conventions/): published examples.
  - [Naming Conventions (csharp)](https://matlus.com/pwi/naming-conventions/csharp/): Deriving names rather than inventing them, domain suffixes over indices, the Async exception, and why Retrieve and Search choose different failure contracts. Markdown: https://matlus.com/pwi/naming-conventions/csharp.md
  - [Naming Conventions (python)](https://matlus.com/pwi/naming-conventions/python/): Naming a thing for what it is: variables named after their type, methods that state the domain outcome, and why inventing a fresh name at each site is where wrong names come from. Markdown: https://matlus.com/pwi/naming-conventions/python.md
- [Type Annotations](https://matlus.com/pwi/type-annotations/): published examples.
  - [Type Annotations (python)](https://matlus.com/pwi/type-annotations/python/): Annotations as intent rather than decoration: None used deliberately, dictionaries kept out of method boundaries, and capability types that tell the truth. Markdown: https://matlus.com/pwi/type-annotations/python.md
- [LINQ Query Semantics](https://matlus.com/pwi/linq-query-semantics/): published examples.
  - [LINQ and Query Semantics (csharp)](https://matlus.com/pwi/linq-query-semantics/csharp/): A query does not run when you write it, and calling it twice may not give the same answer. Deferred execution, materialization, terminal operators, and untranslatable queries. Markdown: https://matlus.com/pwi/linq-query-semantics/csharp.md

## Acceptance Testing

Functional acceptance testing at the boundary, and the surrounding discipline.
This is the Verification with Intent pillar, surfaced at top level.


## Topics

- [Null-Conditional Operator](https://matlus.com/tags/null-conditional-operator/): Conditional member or element access that stops evaluation when its receiver is null. Its use determines whether missing objects legitimately skip work or conceal a broken assumption.
- [Nullable Reference Types](https://matlus.com/tags/nullable-reference-types/): C# annotations and compiler analysis that describe whether references may be null. Initialization, flow analysis and warning suppression determine the promises expressed in source code without adding runtime null checks.
- [Message Brokers](https://matlus.com/tags/message-brokers/): Infrastructure that receives, routes and delivers messages between applications. Publisher and subscriber contracts, message properties, acknowledgements and delivery guarantees determine how applications use a broker.
- [Expression Trees](https://matlus.com/tags/expression-trees/): Representing code as a tree of expressions that a program can inspect, transform or translate. C# can convert supported lambdas into expression trees, exposing their parameters, member accesses and operations without executing the lambda.
- [Dependency Inversion](https://matlus.com/tags/dependency-inversion/): Arranging source dependencies so application policy and implementation details meet through abstractions that are independent of those details. Implementations conform to the contracts rather than requiring policy to depend on concrete infrastructure.
- [CPU Caches](https://matlus.com/tags/cpu-caches/): Processor caches retain nearby copies of instructions and data. Cache lines, locality, sharing and coherence affect the cost of accessing a program's working set.
- [One-to-Many Mapping](https://matlus.com/tags/one-to-many-mapping/): Associating one key with multiple values while defining which keys each value may belong to. Lookup direction, uniqueness constraints and update rules determine the relationship's contract and storage.
- [Adapter Pattern](https://matlus.com/tags/adapter-pattern/): Translating an existing component's interface into the interface its caller needs. The adapter owns the translation while keeping the underlying component's API details inside its implementation.
- [Anonymous Types](https://matlus.com/tags/anonymous-types/): Compiler-generated types created from property names and values without an explicit class declaration. Their inferred identity, read-only properties and value-based equality shape their use in local operations and query projections.
- [Autonomous Methods](https://matlus.com/tags/autonomous-methods/): Methods that operate on information supplied through their signatures without depending on changing state accumulated by their class. They may use fixed information and perform external side effects, distinguishing autonomy from purity.
- [Boxing](https://matlus.com/tags/boxing/): Representing a value-type value inside an object so it can be used through an object or interface reference. Boxing and unboxing affect copying, allocation and the behavior of typed and untyped APIs.
- [Caching](https://matlus.com/tags/caching/): Retaining results or reusable resources to avoid repeating work. Ownership, validity, retention limits and lifetime determine when cached state can safely be reused.
- [Compilation](https://matlus.com/tags/compilation/): Translating source code or intermediate instructions into executable code and metadata. Compiler transformations, specialization and code sharing determine what is produced before deployment or during execution.
- [Constants](https://matlus.com/tags/constants/): Values fixed at compile time and substituted where code uses them. Their declarations, permitted expressions, and treatment across assembly boundaries determine how changes reach consumers.
- [Constructors](https://matlus.com/tags/constructors/): How objects are initialized through constructor bodies, field initializers, and calls between constructors. Inheritance and virtual dispatch determine which state is available while construction proceeds.
- [Deconstruction](https://matlus.com/tags/deconstruction/): Extracting individual values from tuples or objects into separate variables. C# supports positional tuple extraction and Deconstruct methods, including overloads, extension methods and discarded results.
- [Garbage Collection](https://matlus.com/tags/garbage-collection/): Automatically reclaiming storage occupied by objects that are no longer reachable. Allocation volume, object lifetimes and surviving references affect collection frequency, memory use and execution costs.
- [Generics](https://matlus.com/tags/generics/): Types and methods parameterized by other types. Compiler and runtime support determine how type arguments are checked, retained and used to specialize or share executable code.
- [Hash Sets](https://matlus.com/tags/hash-sets/): Collections of distinct values organized for hash-based membership checks. Equality comparers, mutation and set operations determine their behavior and the work required for lookups.
- [Higher Order Functions](https://matlus.com/tags/higher-order-functions/): Functions that accept other functions as arguments, return functions, or both. Passing behavior lets a reusable algorithm delegate particular decisions to its caller.
- [Immutability](https://matlus.com/tags/immutability/): Keeping a value or object's contents unchanged after creation. Operations produce replacement values, while variables may still be reassigned to refer to those replacements.
- [Lambdas](https://matlus.com/tags/lambdas/): Expressions that define anonymous functions where behavior is needed. Parameter inference, statement and expression bodies, captured variables and the required target type determine how they are used.
- [Memory Allocation](https://matlus.com/tags/memory-allocation/): Obtaining storage for values, objects and working data. Allocation size, frequency and lifetime affect copying, memory use and the work required to reclaim storage.
- [Object Layout](https://matlus.com/tags/object-layout/): How a runtime represents objects through field storage, headers and references to shared type information. Layout and allocation overhead depend on the runtime and target architecture.
- [Optional Parameters](https://matlus.com/tags/optional-parameters/): Method parameters with defaults that allow callers to omit corresponding arguments. Binding, overload selection, and the placement of default values affect API use and changes to existing callers.
- [Parameter Passing](https://matlus.com/tags/parameter-passing/): How method parameters receive argument values or access caller variables. Passing by value and passing by reference determine what is copied and which assignments can affect the caller.
- [Static Classes](https://matlus.com/tags/static-classes/): Classes whose members are used without constructing instances. Their language constraints, shared state and responsibilities determine when they suit a design.
- [Static Initialization](https://matlus.com/tags/static-initialization/): Establishing a type's static state through field initializers and static constructors. Runtime timing guarantees and initialization failures determine what subsequent uses of the type can rely on.
- [String Concatenation](https://matlus.com/tags/string-concatenation/): Combining strings into a single result. Fixed expressions, repeated concatenation, formatting and compiler transformations determine the intermediate values, copying and allocations involved.
- [StringBuilder](https://matlus.com/tags/stringbuilder/): The .NET type for accumulating characters in mutable construction storage before producing a string. Append operations, capacity, chunk growth and final copying determine its behavior and costs.
- [Value and Reference Types](https://matlus.com/tags/value-and-reference-types/): The distinction between variables containing values directly and variables containing references to objects. Field storage, assignment and copying determine how values and shared objects behave.
- [Value Tuples](https://matlus.com/tags/value-tuples/): Grouping values into positional elements using .NET ValueTuple types and C# tuple syntax. Element names, assignment, copying, mutation and equality determine how these groups behave.
- [Try-Parse](https://matlus.com/tags/try-parse/): The Try-Parse pattern gives parsing a Boolean answer for defined invalid-input outcomes. Other failures still throw, and callers requiring the result can use the corresponding throwing operation.
- [Progress Reporting](https://matlus.com/tags/progress-reporting/): Reporting the steps, completed work, and elapsed time of a running operation through stable run, item, and step identifiers. Completion events describe work that actually finished, so operators can distinguish progress, stalls, and failures.
- [Structured Logging](https://matlus.com/tags/structured-logging/): Structured logging records named properties alongside an event so people and tools can filter, correlate, and investigate failures without parsing message text.
- [Architecture](https://matlus.com/tags/architecture/): How a system is divided into layers, where each responsibility belongs, and what may legitimately depend on what.
- [Naming](https://matlus.com/tags/naming/): Choosing names that state what a thing is, and keeping those names stable as a value moves through a system.
- [Method Design](https://matlus.com/tags/method-design/): Visibility, return contracts, abstraction levels, and the difference between a method that acts and one that answers.
- [Class Design](https://matlus.com/tags/class-design/): Separating behavior from state, deciding what may be inherited, and keeping types honest about what they hold.
- [Testing](https://matlus.com/tags/testing/): Which layer proves what, how tests are arranged, and what a passing test is actually evidence of.
- [Acceptance Testing](https://matlus.com/tags/acceptance-testing/): Exercising a system through its front door as a black box, with attention to where test data comes from and what keeps a scenario true over time.
- [Error Handling](https://matlus.com/tags/error-handling/): Treating failure as a designed path: validation at boundaries, exception translation, and what a caught exception obliges you to do.
- [Data Access](https://matlus.com/tags/data-access/): Reaching a store without letting its shape leak upward. Language-independent guidance, currently illustrated in Python.
- [LLM Systems](https://matlus.com/tags/llm-systems/): Designing processors, engines, and gateways that call language models, and keeping that machinery testable.
- [Python](https://matlus.com/tags/python/): Material specific to Python, or illustrated with Python examples.
- [C#](https://matlus.com/tags/csharp/): Material specific to C#, or illustrated with C# examples.
- [TypeScript](https://matlus.com/tags/typescript/): Material specific to TypeScript, including this site’s own build.
- [AI-Assisted Development](https://matlus.com/tags/ai-assisted-development/): Working with coding agents: what to delegate, how to review the result, and where the failure modes cluster.
- [Prompting](https://matlus.com/tags/prompting/): Writing instructions that define a language model's task, constraints, evidence requirements, and expected output. Prompt comparisons examine which decisions are specified and which remain open.
- [Verified, Not Trusted](https://matlus.com/tags/verified-not-trusted/): Evidence and reproducible checks for AI-generated claims, with explicit limits on what has been established and what remains uncertain.
- [Verification](https://matlus.com/tags/verification/): Establishing that required work actually happened, rather than accepting a confident report that it did. Coverage, completion, and what evidence supports a claim.
- [Agent Orchestration](https://matlus.com/tags/agent-orchestration/): Coordinating multiple model workers: who decides what, what each one may see, what runs concurrently, and what stops a run.
- [Code Review](https://matlus.com/tags/code-review/): Turning written guidance into rules a reviewer can apply consistently, by machine or by hand.
- [Public Surface](https://matlus.com/tags/public-surface/): The set of types a component exposes to its callers. Everything a caller can receive, pass or must catch belongs on it, and everything else stays internal, so the interior can change without breaking anyone.
- [Levels of Abstraction](https://matlus.com/tags/levels-of-abstraction/): Arranging classes by altitude, so each level states what happens and delegates how to the level below. A class’s depth in the folder tree shows its level, and dependencies run one level down.
- [Service Interface Layer](https://matlus.com/tags/service-interface-layer/): The thin host layer, such as a web API, CLI, worker or cloud function, that connects the outside world to a system. It translates transport input and forwards it to the domain, which must not depend on the host.
- [Design Patterns](https://matlus.com/tags/design-patterns/): Named software design patterns such as Factory, Factory Method, Strategy, Template Method, and Iterator. Articles explain a pattern’s structure or apply it in a worked design.
- [Architectural Patterns](https://matlus.com/tags/architectural-patterns/): Recurring structures for system responsibilities and boundaries, including Domain Facades, Service Locators, Gateways, Data Managers, and Configuration Providers.
- [AI Workflow Patterns](https://matlus.com/tags/ai-workflow-patterns/): Reusable ways to coordinate model judgments with code, including fan-out, confidence gates, composite scoring, and intent routing.
- [Domain Facade](https://matlus.com/tags/domain-facade/): The single public entry point to a domain. It holds no logic of its own, forwards each business operation to a Manager, and hides every internal layer from callers.
- [Service Locator](https://matlus.com/tags/service-locator/): A narrow factory that creates only what must be swappable, such as configuration, loggers and transport handlers, so tests can substitute them. Only the Manager uses it, and only during construction.
- [Configuration Provider](https://matlus.com/tags/configuration-provider/): A typed wrapper over raw configuration that reads and validates settings eagerly and returns typed settings objects. Only the Manager uses it, and it passes values downstream, never the provider.
- [Gateway Pattern](https://matlus.com/tags/gateway-pattern/): A domain-owned boundary to an external service. It presents business-shaped operations and models, and keeps provider types, resource models and failure translation behind it as one deletable unit.
- [Data Manager](https://matlus.com/tags/data-manager/): The component that owns a domain’s whole conversation with a data store. It presents business-shaped operations and keeps store technology, command construction and fault translation behind its seam.
- [Strategy Pattern](https://matlus.com/tags/strategy-pattern/): Selecting one of several interchangeable behaviors through a common role.
- [Delegates](https://matlus.com/tags/delegates/): Using C# delegates to pass behavior and compare that choice with named strategy classes.
- [Composition Over Inheritance](https://matlus.com/tags/composition-over-inheritance/): Building capabilities from collaborating objects while keeping inheritance narrow and deliberate.
- [Dependency Injection](https://matlus.com/tags/dependency-injection/): Passing collaborators into objects and deciding which dependencies callers should control.
- [Factory Pattern](https://matlus.com/tags/factory-pattern/): Creating the right implementation behind a focused construction boundary.
- [Factory Method](https://matlus.com/tags/factory-method/): A creation hook on a consumer base class that subclasses override to choose a dependency from another class family.
- [Polymorphism](https://matlus.com/tags/polymorphism/): Using a shared contract to work with different implementations without making callers name their concrete types.
- [Library Boundaries](https://matlus.com/tags/library-boundaries/): Contracts that let a system request capabilities in its own terms while containing a library’s calls, types, and failure conventions.
- [Model Design](https://matlus.com/tags/model-design/): Defining data types so required fields, genuine absence, and distinct variants are clear to consumers.
- [Template Method](https://matlus.com/tags/template-method/): Defining an operation in a base type while subclasses provide selected steps.
- [Extension Methods](https://matlus.com/tags/extension-methods/): C# methods called as if they belong to a type, and their effect on discoverability and meaning.
- [Data Transfer Objects](https://matlus.com/tags/data-transfer-objects/): Immutable data carriers that keep state separate from the behavior operating on it.
- [Type Casting](https://matlus.com/tags/type-casting/): Choosing casts and type checks according to whether a mismatch is expected or a defect.
- [Mocking](https://matlus.com/tags/mocking/): Replacing collaborators in tests and evaluating the effect on coupling and regression coverage.
- [Test Driven Development](https://matlus.com/tags/test-driven-development/): Using tests to establish behavior before implementation and preserving them through design changes.
- [Interfaces](https://matlus.com/tags/interfaces/): C# interface roles, their costs, and when a consumer needs a narrow capability.
- [Interface Segregation](https://matlus.com/tags/interface-segregation/): Presenting each consumer with only the operations it needs.
- [Boundary Validation](https://matlus.com/tags/boundary-validation/): Checking untrusted input and output at system boundaries while keeping internal flows clear.
- [Async and Await](https://matlus.com/tags/async-await/): C# language features for suspending asynchronous methods and resuming them when awaited work completes.
- [Asynchronous I/O](https://matlus.com/tags/asynchronous-io/): Waiting for files, databases, or network operations without keeping a caller thread blocked for the duration.
- [Task Composition](https://matlus.com/tags/task-composition/): Combining asynchronous operations so independent tasks can overlap and callers can handle their completion and results.
- [Load Testing](https://matlus.com/tags/load-testing/): Measuring throughput, latency, resource use, and dependency capacity as concurrent demand changes.
- [IIS](https://matlus.com/tags/iis/): Microsoft's web-server architecture for receiving HTTP requests, routing them to application pools, running application code in worker processes, and caching eligible responses.
- [Async Streams](https://matlus.com/tags/async-streams/): Asynchronous sequences that let a consumer await each item as it becomes available, including iterator creation, enumeration, cancellation, and resource lifetime.
- [Benchmarking](https://matlus.com/tags/benchmarking/): Measuring an operation under controlled conditions and interpreting elapsed time, allocations, and other resource costs in light of the workload and implementations compared.
- [Iterator Pattern](https://matlus.com/tags/iterator-pattern/): Traversing a sequence one item at a time through a stable iteration contract, with the consumer requesting each next item.
- [Jev](https://matlus.com/tags/jev/): TypeSafe AI’s System One model for typed judgments about supplied text. Choice, Score, and Noul support bounded semantic decisions.
- [Model Evaluation](https://matlus.com/tags/model-evaluation/): Measuring model decisions on representative labeled cases, including error costs, calibration, thresholds, abstention, and performance after changes.
- [Speculative Fan-Out](https://matlus.com/tags/speculative-fan-out/): Asking independent questions about shared state in one request, including answers that some later routes will not use.
- [Confidence-Gated Routing](https://matlus.com/tags/confidence-gated-routing/): Using a model’s answer and tested confidence thresholds to choose between automatic action, another process, and human review.
- [Composite Scoring](https://matlus.com/tags/composite-scoring/): Scoring separate semantic dimensions and combining them with explicit weights to support a decision.
- [Intent Routing](https://matlus.com/tags/intent-routing/): Classifying a request’s intent to choose a handler, such as ordinary code, a specialist model, or a person.
- [Context Compaction](https://matlus.com/tags/context-compaction/): Reducing the material supplied to a language model by selecting relevant source units or summarizing them. Retention decisions must account for current goals, unique evidence, and information that later questions may need.
- [Test Mediator](https://matlus.com/tags/test-mediator/): A testing pattern that carries scenario instructions to observation points and exposes captured results to assertions. It can remain separate from its spies or contain one service's private spy; it is distinct from the GoF Mediator pattern.
- [Transport Spy](https://matlus.com/tags/transport-spy/): A test observation point at a transport boundary that records outgoing requests or incoming responses while retaining production behavior above that boundary. It can follow scenario instructions to forward, redirect, or supply a controlled response.
- [Builder Pattern](https://matlus.com/tags/builder-pattern/): Constructing a model through explicit configuration steps before producing the completed value. Test builders can supply reusable defaults while keeping each scenario's defining values visible and independently owned.
- [Idempotency](https://matlus.com/tags/idempotency/): Defining and verifying the outcome of repeated requests without repeating work that has already been accepted. Request identity, conflicting content, preserved state, and outstanding recovery obligations determine the contract.
- [Concurrency](https://matlus.com/tags/concurrency/): Behavior when operations overlap and contend for shared state or resources. Verification considers allowed outcomes, arbitration, duplicate effects, and the schedules a particular arrangement actually exercises.
- [Refactoring](https://matlus.com/tags/refactoring/): Changing internal organization while preserving established observable behavior. Stable public boundaries and maintained comparisons provide evidence that the reorganization preserves required outcomes.
- [Regression Testing](https://matlus.com/tags/regression-testing/): Continuing to verify previously established behavior as later changes enter a system. Maintained scenarios preserve approved requirements and incorporate discovered defects so future runs check those lessons again.
- [Executable Documentation](https://matlus.com/tags/executable-documentation/): Documentation whose scenarios execute production behavior and check the outcomes they describe. Readers can connect requirements to the current implementation by running and debugging maintained tests.
- [Requirements Traceability](https://matlus.com/tags/requirements-traceability/): Maintaining explicit connections from established requirements to scenarios, expected outcomes, observations, and comparisons. Those connections let reviewers identify missing coverage and distinguish behavioral evidence from structural review.
- [Test Isolation](https://matlus.com/tags/test-isolation/): Keeping records, observations, configuration, and cleanup owned by the test or run that creates them. Isolation lets concurrent developers and CI jobs use infrastructure without consuming, altering, or deleting one another's state.
- [LocalDB](https://matlus.com/tags/localdb/): SQL Server LocalDB instances for local applications and automated tests, including instance creation, connection strings, and database deployment.
- [Continuous Integration](https://matlus.com/tags/continuous-integration/): Automating builds and tests as changes enter a shared codebase, including build definitions, prerequisite setup, and repeatable execution environments.
- [Azure](https://matlus.com/tags/azure/): Deploying and operating applications on Microsoft Azure, including service configuration, role startup, storage, and execution environments.
- [Windows Impersonation](https://matlus.com/tags/windows-impersonation/): Executing work under a different Windows identity through logon tokens and impersonation contexts, including privileges and identity lifetime.
- [MSMQ](https://matlus.com/tags/msmq/): Microsoft Message Queuing for passing work between processes through local or remote queues, including installation and queue-based processing.
- [Background Processing](https://matlus.com/tags/background-processing/): Moving work beyond the initiating request into another execution context, with explicit handoff, processing responsibilities, and completion behavior.
- [REST](https://matlus.com/tags/rest/): Designing and consuming resource-oriented HTTP APIs through resource identifiers, method semantics, representations, and response status codes.
- [Cross-Origin Resource Sharing](https://matlus.com/tags/cors/): The HTTP mechanism through which a server permits browser requests from another origin, including origin headers, preflight requests, and allowed methods or headers.
- [jQuery](https://matlus.com/tags/jquery/): Using jQuery to work with browser elements, events, attached data, and Ajax requests.
- [HTTP Method Override](https://matlus.com/tags/http-method-override/): Carrying an intended HTTP method in a header on another request method, then translating it before dispatch to an application handler.
- [JavaScript](https://matlus.com/tags/javascript/): Material specific to JavaScript, or illustrated with JavaScript examples.
- [JSON](https://matlus.com/tags/json/): Representing structured data with JSON and converting between JSON text and application objects, including serialization and response handling.
- [HttpClient](https://matlus.com/tags/httpclient/): The .NET HttpClient API for sending HTTP requests and consuming responses, including request content, headers, asynchronous calls, and typed data conversion.
- [JSONP](https://matlus.com/tags/jsonp/): Returning JSON inside a JavaScript callback so browser clients can consume script responses across origins, including callback selection and endpoint exposure.
- [Self-Hosting](https://matlus.com/tags/self-hosting/): Running a network service inside an application's own process, with explicit listener configuration, routing, startup, and lifetime management.
- [Quartz for ASP.NET](https://matlus.com/tags/quartz-aspnet/): Shiv Kumar's ASP.NET page-composition framework, where Builders assemble view objects and HTML templates into dynamic pages.
- [HTML Templates](https://matlus.com/tags/html-templates/): Reusable HTML structures whose placeholders receive application data or rendered views, including template selection and separation from rendering code.
- [ASP.NET WebForms](https://matlus.com/tags/webforms/): Building and configuring ASP.NET WebForms applications, including application startup, project structure, and integration with HTTP services.
- [Roslyn](https://matlus.com/tags/roslyn/): The .NET compiler platform exposes syntax trees, symbols, and semantic information for tools that inspect, transform, or generate source code.
- [Syntax Highlighting](https://matlus.com/tags/syntax-highlighting/): Classifying source-code tokens and rendering them with distinct visual styles, including the relationship between syntactic structure and semantic information.
- [Visitor Pattern](https://matlus.com/tags/visitor-pattern/): Applying operations while visiting elements of an object structure, with separate handling for the kinds of elements encountered.
- [Connected Devices](https://matlus.com/tags/connected-devices/): Physical devices connected to computers or networks, with software interfaces that let applications read their state or control their behavior.
- [Sandboxing](https://matlus.com/tags/sandboxing/): Restricting an application's access to system resources and exposing permitted capabilities through controlled interfaces and permissions.
- [WCF](https://matlus.com/tags/wcf/): Windows Communication Foundation services and clients, including contracts, transport bindings, endpoints, hosting, metadata exchange, and diagnostics.
- [Service Proxies](https://matlus.com/tags/service-proxies/): Client-side objects that expose a remote service's operations and translate local calls into messages sent through a transport.
- [ASP.NET](https://matlus.com/tags/asp-net/): Building web applications with ASP.NET, including request processing, handlers, controllers, responses, and framework behavior.
- [HTTP](https://matlus.com/tags/http/): HTTP request and response behavior, including methods, headers, connections, content, and client-server communication.
- [Asynchronous Programming Model](https://matlus.com/tags/asynchronous-programming-model/): The .NET Asynchronous Programming Model exposes Begin and End method pairs, IAsyncResult, callbacks, and state for asynchronous operations.
- [LINQ](https://matlus.com/tags/linq/): Language Integrated Query operations over data, including filtering, projection, joins, grouping, and the relationship between query and method syntax.
- [Parallel Programming](https://matlus.com/tags/parallel-programming/): Dividing computational work so multiple processors or cores execute it at the same time, with attention to partitioning, scheduling, synchronization, and overhead.
- [WMI](https://matlus.com/tags/wmi/): Windows Management Instrumentation exposes management information about Windows systems through queryable classes and properties.
- [CPU Hardware](https://matlus.com/tags/cpu-hardware/): Processor characteristics such as physical packages, cores, logical processors, instruction-set architecture, and address width.
- [URL Encoding](https://matlus.com/tags/url-encoding/): Representing data in URL components through percent encoding, with attention to reserved characters, unreserved characters, and form-encoding conventions.
- [Windows Services](https://matlus.com/tags/windows-services/): Background services managed by Windows, including service discovery, lifecycle commands, status changes, and programmatic control.
- [Process Management](https://matlus.com/tags/process-management/): Launching and controlling operating-system processes, collecting standard output and errors, waiting for completion, and interpreting exit status.
- [SQL Server](https://matlus.com/tags/sql-server/): Microsoft SQL Server databases, including SQL commands, storage features, administration, and application integration.
- [Identity Columns](https://matlus.com/tags/identity-columns/): Database columns whose numeric values are generated from a seed and increment, including how insertion and reseeding affect subsequent values.
- [Duplicate Detection](https://matlus.com/tags/duplicate-detection/): Finding repeated values or records under an explicitly chosen comparison key, including grouping matches and retaining the records that share that key.
- [Serialization](https://matlus.com/tags/serialization/): Converting objects and sequences into representations that can be stored or transmitted, and reconstructing values from those representations. Contracts determine member names, data shape, and stream handling.
- [DataReaders](https://matlus.com/tags/datareaders/): Reading result sets sequentially through ADO.NET DataReaders. Typed wrappers, connection lifetime, and the choice between streaming rows and materializing objects shape their use.
- [Debugging](https://matlus.com/tags/debugging/): Investigating unexpected application behavior with diagnostic tools, traces, and observed execution to identify its cause.
- [Web Performance](https://matlus.com/tags/web-performance/): How quickly websites deliver responses and become usable in a browser. Server processing, transferred resources, caching, and measurement all contribute to the result.
- [Blogging](https://matlus.com/tags/blogging/): The tools and workflows for writing, editing, and publishing blog posts, including blog engines and their authoring interfaces.
- [MetaWeblog API](https://matlus.com/tags/metaweblog-api/): An XML-RPC interface for creating and editing blog posts, retrieving categories, and uploading media. Blog engines implement its operations so compatible authoring clients can publish to them.
- [Code Generation](https://matlus.com/tags/code-generation/): Producing source code from metadata, models, or templates. Generators turn a repeatable structure into code while keeping the inputs and generated responsibilities explicit.
- [ADO.NET](https://matlus.com/tags/ado-net/): .NET data-access APIs for connections, commands, parameters, readers, adapters, and in-memory tables. Provider abstractions support working with different database engines.
- [Stored Procedures](https://matlus.com/tags/stored-procedures/): Named database operations that accept parameters and execute commands close to the stored data. Their result sets and parameters provide contracts for application data access.
- [OAuth](https://matlus.com/tags/oauth/): Delegating access to protected resources through provider-issued credentials and tokens. Applications follow an authorization flow and use the resulting access token for permitted requests.
- [Reflection](https://matlus.com/tags/reflection/): Inspecting types and members at runtime and invoking capabilities that are not fixed in the calling code. In .NET, reflection also supports generating executable methods through Reflection.Emit.
- [Request Binding](https://matlus.com/tags/request-binding/): Mapping HTTP form fields and query parameters into typed values or objects. Binders define conversion, defaults, and how multiple incoming fields populate a model.
- [Type Conversion](https://matlus.com/tags/type-conversion/): Transforming a value from one representation or data type into another, including parsing text, handling numeric formats, and converting collections or custom objects.
- [Razor](https://matlus.com/tags/razor/): Razor combines C# expressions and control flow with text templates. It supports ASP.NET views and layouts as well as hosted template generation outside a web application.
- [Model-View-Controller](https://matlus.com/tags/model-view-controller/): An application structure that separates models, presentation, and the controllers coordinating interactions. Implementations determine how data and control pass between those roles.
- [File Upload](https://matlus.com/tags/file-upload/): Transferring files from clients to servers, including file selection, multipart requests, progress feedback, and completion or failure handling.
- [XMLHttpRequest](https://matlus.com/tags/xmlhttprequest/): The browser API for sending HTTP requests and receiving responses from scripts, including request bodies, upload events, and asynchronous completion.
- [Web Browsers](https://matlus.com/tags/web-browsers/): Browser behavior, standards support, performance, and the controls people use to navigate and interact with websites.
- [User Interface Design](https://matlus.com/tags/user-interface-design/): Arranging controls, content, navigation, and feedback around the tasks people need to perform.
- [Flash Player](https://matlus.com/tags/flash-player/): Adobe's historical runtime for browser multimedia and interactive content, including video playback, SWF execution, and desktop or mobile integration.
- [Video Codecs](https://matlus.com/tags/video-codecs/): Video encoding and decoding formats, including their compression, picture quality, playback support, and hardware requirements.
- [HTTP Range Requests](https://matlus.com/tags/http-range-requests/): HTTP requests for selected portions of a resource, supporting partial downloads and seeking within media without transferring the entire file first.
- [Home Theater PC](https://matlus.com/tags/home-theater-pc/): Using a general-purpose computer with a television and audio system for media playback, browsing, and applications, including display connections and remote input.
- [Online Video](https://matlus.com/tags/online-video/): Delivering and watching video over the Internet, including picture quality, bandwidth, playback devices, and viewing experience.
- [HTML5 Video](https://matlus.com/tags/html5-video/): Native video playback through the HTML video element, including controls, poster images, browser behavior, and supported media formats.
- [Video Posters](https://matlus.com/tags/video-posters/): Representative images shown before video playback, including frame selection, custom thumbnails, and their presentation in video players.
- [HTML Parsing](https://matlus.com/tags/html-parsing/): Reading HTML as a document structure to select elements and extract text, attributes, links, and other information.
- [HtmlAgilityPack](https://matlus.com/tags/html-agility-pack/): A .NET library for loading and parsing HTML documents, navigating their nodes, and extracting information with selectors such as XPath.
- [H.264](https://matlus.com/tags/h264/): The AVC video coding standard, including compression and playback characteristics, implementation support, and licensing distinctions.
- [CSS](https://matlus.com/tags/css/): Stylesheets that control web presentation, including layout, positioning, overflow, colors, typography, and visual states.
- [FTP](https://matlus.com/tags/ftp/): The File Transfer Protocol and its server configuration, including user access, directory isolation, and file-transfer permissions.
- [Authentication](https://matlus.com/tags/authentication/): Establishing the identity of a user or client through credentials and configured identity providers before granting access.
- [ASP.NET Web API](https://matlus.com/tags/asp-net-web-api/): The ASP.NET Web API framework for HTTP services, including ApiController routing, hosting, message handlers, formatters, and response construction.