Verified, Not Trusted: Expense Analysis, Part Four
Evals measure reliability with reference keys, code graders, model judges and pass-rate gates. Expense examples show what to check and how structured output expands coverage.
Software Engineering and Applied AI Engineering
Articles by Shiv Kumar on software architecture, programming, acceptance testing, and building with language models.
Latest articles
New and updated articles, most recent first. Series parts stay together.
Verified, Not Trusted: Expense Analysis, Part Three
Evals are acceptance tests for prompts and skills: repeated isolated runs, a pass rate for each check, and a minimum pass rate as the gate. Code grades extracted facts and traces failures.
Verified, Not Trusted: Expense Analysis, Part Two
Imperative Python controls expense analysis and verifies model contributions through source evidence, reconciliation, and exact calculations. Models handle bounded judgments.
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.
Skills versus Controlled Workflows
Stakes and human verification determine where workflow control belongs. Explicit prompts guide a model; imperative code enforces steps, checks, and use of results.
Updated · Markdown
Logs and Artifacts: 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.
Programming to Exceptions, Part 3: 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.
Updated · Markdown
Programming to Exceptions, Part 2: 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.
Updated · Markdown
Programming to Exceptions, Part 1: Method Contracts and Failure
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.
Updated · Markdown
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.
Updated · Markdown
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.
Updated · Markdown
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.
Updated · Markdown
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.
Updated · Markdown
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.
Updated · Markdown
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.
Updated · Markdown
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.
Updated · Markdown
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.
Updated · Markdown
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.
Updated · Markdown
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.
Updated · Markdown
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.
Updated · Markdown
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.
Updated · Markdown
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.
Updated · Markdown
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.
Updated · Markdown
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.
Updated · Markdown
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.
Updated · Markdown
Separate State from Behavior? Yes Please!
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.
Updated · Markdown
Factory Pattern: The Enabler of Polymorphism
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.
Updated · Markdown
The Configuration Provider: Roles and Responsibilities
A Configuration Provider hides the source and returns validated, typed settings. Useful exceptions and composed settings providers keep configuration rules in one place.
Updated · Markdown
The Gateway Design Pattern: Roles and Responsibilities
A Gateway presents business operations, translates service models and transforms failures into domain exceptions, keeping external service details behind one boundary.
Updated · Markdown
Factory Method Pattern: The Most Beautiful Pattern We Lost
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.
Updated · Markdown
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.
Updated · Markdown
AI-native SDLC
Engineering both gates requires certified code review, functional acceptance tests at the boundary ratified by humans, and verification against the specification.
Updated · Markdown
Jev: A 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.
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.
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.
Updated · Markdown
Always Use the "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.
Updated · Markdown
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.
Updated · Markdown
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.
Updated · Markdown
C# 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.
Updated · Markdown
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.
Updated · Markdown
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.
Updated · Markdown
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.
Updated · Markdown
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.
Updated · Markdown
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.
Updated · Markdown
Async-Await in C#
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.
Updated · Markdown
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.
Updated · Markdown
Let's Talk - 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.
High Performance Logging and 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.
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.
Abstraction in Software Design, with Examples
Give callers domain operations while collections and gateways own the details: service orchestration, model mapping and translation of recognized failures into domain exceptions.
SOLID IS OLD: Dependency Inversion Needs a Good Abstraction
Dependency inversion needs domain-owned contracts that hide implementation knowledge. Follow a show query from source dependencies through models to a stored procedure.
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.
Creating Instances, Using Inheritance: No Thank You!
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.
So You Think You Know C#? ValueTuples and Deconstruction
Named ValueTuples make small results readable. Positional fields, copy behavior and Deconstruct methods explain the syntax and the limits of tuple return types.
Builder Pattern and C# Expressions
Test-data builders keep each scenario's chosen values visible. C# expression trees select model properties, and stored overrides preserve explicit nulls.
Adapter Design Pattern: Testing Service Bus Using RabbitMQ Locally
The Adapter pattern keeps application messaging independent of broker SDKs by translating messages, callbacks and acknowledgements between RabbitMQ and Service Bus.
Custom Data Structure: A 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.
So You Think You Know C#? LINQ
LINQ rewrites can add work while removing repetition. Customer filters expose query projections, lookup choices and why benchmarks must compare equal results.
ASP.NET 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.
So You Think You Know C#? The StringBuilder Myth
StringBuilder suits growing results, but can cost more for fixed concatenation. Compiler output, allocations and benchmark checks explain when to choose it.
So You Think You Know C#? 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.
So You Think You Know C#? Constants and Default Parameter Values
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.
So You Think You Know C#? Constructors
C# construction order determines which fields are ready. Field initializers, constructor chaining, virtual dispatch and static initialization explain what runs when.
So You Think You Know C#? For vs. 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.
So You Think You Know C#? Delegates and Higher Order Functions
Delegates let callers supply behavior to reusable methods. Lambda syntax and SingleElseException show how higher order functions add useful failure details.
So You Think You Know C#? 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.
So You Think You Know C#? The 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.
Benchmarking .NET Applications
A benchmark tests whether a change improves the same operation. BenchmarkDotNet makes input choice, setup, timing and allocation costs visible for .NET code.
.NET Memory Allocations and Performance, 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.
.NET Memory Allocations and Performance
.NET allocation costs follow what gets stored and copied. Structs, classes, arrays and strings explain object layout, references and garbage collection.
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.
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.
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.
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.
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.
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.
ASP.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.
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.
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.
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.
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.
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.
REST APIs, PUT and DELETE cause HTTP Error 404.0 - Not Found
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.
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.
Disrupting the World Wide Web - 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.
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.
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.
HttpWebRequest - Asynchronous Programming Model/Task.Factory.FromAsyc
HttpWebRequest callbacks and Task.Factory.FromAsync support asynchronous GET and POST calls, with five approaches compared for collecting concurrent responses.
Linq - SelectMany
SelectMany flattens related sequences into a single result. Categories and posts explain its collection selector, result selector, joins, and nested foreach behavior.
Data Parallel – Parallel Programming in C#/.NET
Data parallelism distributes compute-bound work across cores. Prime-counting examples compare PLINQ, Parallel.For, thread-local state, partitioning, and measured timings.
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.
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.
UrlEncode –The correct encoding
A C# UrlEncode implementation preserves unreserved characters and percent-encodes others, with character-by-character comparisons against HttpUtility.UrlEncode.
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.
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.
Stop/Start Windows Service
Start, stop, and restart Windows services from C# using net commands or ServiceController, with redirected process output, error handling, and completion waits.
DataContractSerializer-IEnumerable<T>
A JsonSerializer streams IEnumerable<T> directly to JSON, preserving DataMember names and supporting JSONP while a DbDataReader wrapper avoids building an intermediate list.
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.
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.
Orion - A Blog Engine
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.
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.
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.
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.
C# Class Factory - High Performance
A Factory decouples payment processing from concrete classes, discovers implementations, and caches constructor delegates built with DynamicMethod and ILGenerator.
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.
ASP.NET Performance-Instantiating Business Layers
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.
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>.
Quartz for ASP.NET
Quartz composes ASP.NET pages through a Builder, reusable HTML templates, and view objects. The walkthrough covers their relationships and Visual Studio templates.
ChangeType<T> - 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.
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.
ASP.NET MVC Framework Design Problems
ASP.NET MVC's indirect access to views spreads responsibilities across controllers and templates. ViewData, child actions, and typed view instances frame the critique.
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.
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.
IE 9 Beta - What's hot and what's 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.
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.
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.
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.
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.
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.
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.
Setting up IIS 7.0 - Ftp 7.5 for 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.
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.
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.