diff --git a/src/config.ts b/src/config.ts
deleted file mode 100644
index a9d5e4e..0000000
--- a/src/config.ts
+++ /dev/null
@@ -1,22 +0,0 @@
-export const SITE = {
- website: "https://www.millerdatabases.com/",
- author: "Daniel Miller",
- profile: "https://www.millerdatabases.com/",
- desc: "Professional database software services",
- title: "Miller Databases",
- lightAndDarkMode: true,
- postPerIndex: 4,
- postPerPage: 4,
- scheduledPostMargin: 15 * 60 * 1000,
- showArchives: true,
- showBackButton: true,
- editPost: {
- enabled: false,
- text: "Edit page",
- url: "https://github.com/miller-databases/website/edit/main/",
- },
- dynamicOgImage: true,
- dir: "ltr",
- lang: "en",
- timezone: "America/Denver",
-} as const;
diff --git a/src/constants.ts b/src/constants.ts
deleted file mode 100644
index b7584be..0000000
--- a/src/constants.ts
+++ /dev/null
@@ -1,70 +0,0 @@
-import type { Props } from "astro";
-import IconMail from "@/assets/icons/IconMail.svg";
-import IconGitHub from "@/assets/icons/IconGitHub.svg";
-import IconBrandX from "@/assets/icons/IconBrandX.svg";
-import IconWhatsapp from "@/assets/icons/IconWhatsapp.svg";
-import IconFacebook from "@/assets/icons/IconFacebook.svg";
-import IconTelegram from "@/assets/icons/IconTelegram.svg";
-import IconPinterest from "@/assets/icons/IconPinterest.svg";
-import { SITE } from "@/config";
-
-interface Social {
- name: string;
- href: string;
- linkTitle: string;
- icon: (_props: Props) => Element;
-}
-
-export const SOCIALS: Social[] = [
- {
- name: "GitHub",
- href: "https://github.com/miller-databases",
- linkTitle: `${SITE.title} on GitHub`,
- icon: IconGitHub,
- },
- {
- name: "Mail",
- href: "mailto:daniel@millerdatabases.com",
- linkTitle: `Send an email to ${SITE.title}`,
- icon: IconMail,
- },
-] as const;
-
-export const SHARE_LINKS: Social[] = [
- {
- name: "WhatsApp",
- href: "https://wa.me/?text=",
- linkTitle: `Share this post via WhatsApp`,
- icon: IconWhatsapp,
- },
- {
- name: "Facebook",
- href: "https://www.facebook.com/sharer.php?u=",
- linkTitle: `Share this post on Facebook`,
- icon: IconFacebook,
- },
- {
- name: "X",
- href: "https://x.com/intent/post?url=",
- linkTitle: `Share this post on X`,
- icon: IconBrandX,
- },
- {
- name: "Telegram",
- href: "https://t.me/share/url?url=",
- linkTitle: `Share this post via Telegram`,
- icon: IconTelegram,
- },
- {
- name: "Pinterest",
- href: "https://pinterest.com/pin/create/button/?url=",
- linkTitle: `Share this post on Pinterest`,
- icon: IconPinterest,
- },
- {
- name: "Mail",
- href: "mailto:?subject=See%20this%20post&body=",
- linkTitle: `Share this post via email`,
- icon: IconMail,
- },
-] as const;
diff --git a/src/content.config.ts b/src/content.config.ts
deleted file mode 100644
index 6119aa6..0000000
--- a/src/content.config.ts
+++ /dev/null
@@ -1,26 +0,0 @@
-import { defineCollection, z } from "astro:content";
-import { glob } from "astro/loaders";
-import { SITE } from "@/config";
-
-export const BLOG_PATH = "src/data/blog";
-
-const blog = defineCollection({
- loader: glob({ pattern: "**/[^_]*.md", base: `./${BLOG_PATH}` }),
- schema: ({ image }) =>
- z.object({
- author: z.string().default(SITE.author),
- pubDatetime: z.date(),
- modDatetime: z.date().optional().nullable(),
- title: z.string(),
- featured: z.boolean().optional(),
- draft: z.boolean().optional(),
- tags: z.array(z.string()).default(["others"]),
- ogImage: image().or(z.string()).optional(),
- description: z.string(),
- canonicalURL: z.string().optional(),
- hideEditPost: z.boolean().optional(),
- timezone: z.string().optional(),
- }),
-});
-
-export const collections = { blog };
diff --git a/src/data/blog/auditing-data-types-and-column-sizes-in-sql-server.md b/src/data/blog/auditing-data-types-and-column-sizes-in-sql-server.md
deleted file mode 100644
index c44f8fa..0000000
--- a/src/data/blog/auditing-data-types-and-column-sizes-in-sql-server.md
+++ /dev/null
@@ -1,167 +0,0 @@
----
-title: Auditing data types and column sizes in SQL Server
-author: Daniel Miller
-pubDatetime: 2025-07-14T15:22:40.000Z
-modDatetime: 2025-07-14T15:22:40.000Z
-featured: false
-draft: false
-tags:
- - database-administration
- - performance-optimization
-ogImage: ../../assets/images/posts/auditing-data-types-and-column-sizes-in-sql-server/1750523993510.png
-description: Adding a few ounces of sanity to your database schema today can save you from a metric ton of trouble and confusion later.
----
-
-In enterprise software, it's easy for a small decision to go unnoticed — until it creates a big problem. If a long period of time elapses between a small (but poor) decision, and a consequence that leads to large, systemic issues, then troubleshooting can be surprisingly difficult and time-consuming. This is especially true if the staff on your team has changed during that period of time.
-
-Database performance optimization isn't trivial, but there are simple choices that can help to decrease the potential for future problems. One such choice is the data type and maximum character length defined for the columns in a database table that store text. Ultimately, this is a decision about provisioning, and if you are about to embark upon a long and arduous journey, then provisions matter, right?
-
-[Shift iQ](https://www.shiftiq.com/) is a large enterprise system, and the SQL Server database that drives the platform contains over **4,000 columns** in more than **200 tables**. Of these, over half (**2,168 columns**, to be exact) store text data. As you can imagine, the ever-growing volume of data introduces constant pressure on performance, maintainability, and cost.
-
-Therefore, periodically throughout the year, I audit the database column types and sizes, and then identify specific, actionable opportunities to:
-
-- improve query performance,
-- decrease disk-space usage,
-- reduce network load,
-- ensure clean and consistent naming conventions, and
-- confirm the alignment between the deployed implementation and the supporting technical documentation.
-
-A small database doesn't need this level of care and attention, but you can expect significant improvements to the overall performance of a large database if you haven't done this in a while. In the rest of the article here I'll outline some of the reasons why.
-
----
-
-## Overuse of varchar(max) and nvarchar(max)
-
-The data types varchar(max) and nvarchar(max) are designed for unlimited-length text. These types are convenient, but they come with limitations and performance penalties that are easy to under-estimate:
-
-### 1\. Degraded query performance
-
-When a varchar(max) value exceeds 8,000 bytes (or a nvarchar(max) value exceeds 4,000), SQL Server stores the data in [LOB (Large Object) storage](https://learn.microsoft.com/en-us/sql/relational-databases/blob/binary-large-object-blob-data-sql-server?view=sql-server-ver16). This introduces extra I/O operations and removes the data from the main structure of the database record, leading to slower query execution.
-
-### 2\. Constrained indexing
-
-You **cannot index** varchar(max) columns, and this limits the optimizer's ability to generate efficient query plans. This becomes a bottleneck as your application grows.
-
-### 3\. Inefficient storage
-
-SQL Server must allocate additional space to accommodate these types, even if the full capacity isn't used. When you don't need unlimited text, this leads to **wasted storage and increased costs**, especially when dealing with backups and restores.
-
-### 4\. Added pressure on memory
-
-Queries involving large text fields require **more memory buffers**, which can reduce throughput and increase latency under load.
-
-### 5\. Weakened data integrity
-
-When the size of a column is unbounded, it becomes more difficult to validate and enforce clean data. Fields that should have length constraints — like email addresses or URLs — can then become risk vectors for inconsistent input.
-
----
-
-## Overprovisioned character limits
-
-Even when you avoid varchar(max) and nvarchar(max), it's common to define character limits that are **much larger than necessary** — often out of caution or habit. While this avoids the most extreme issues of unlimited-length fields, it still creates meaningful technical and business problems.
-
-### 1\. Poor query plan estimates
-
-SQL Server's query optimizer makes assumptions about the **average size** of data in fixed-length columns. For example, if a column is defined as varchar(4000) but most of the values it stores are only 100 characters long, then the optimizer assumes far more data than is actually used. This can lead to inefficient query plans, excessive memory allocation, and suboptimal performance.
-
-### 2\. Inflated index and memory usage
-
-Indexing a column with an overly generous limit means SQL Server allocates more space per index entry than needed. This bloats the size of the index, increases I/O, and adds unnecessary pressure to memory and CPU.
-
-### 3\. Reduced data quality
-
-Generous field limits remove an important layer of data validation. For example, allowing 4,000 characters in an email address or postal code invites inconsistent, malformed, or unexpected data — leading to downstream complications in reporting, integrations, and user interface.
-
-### 4\. Hidden maintenance costs
-
-Wide columns increase the size of data pages and backups, even if they rarely hold large values. This translates into longer maintenance windows for index rebuilds, higher backup storage needs, and longer restore times — all of which become more noticeable at scale.
-
-### 5\. Missed optimization opportunities
-
-When realistic limits are not applied, SQL Server can't take advantage of features like row compression or optimized buffer usage as effectively. Every overly wide column represents a missed chance to optimize.
-
----
-
-## Business Impact
-
-The technical challenges I outlined above translate directly into business risks:
-
-- **Scalability limits**: As the number of concurrent users interacting with the system increases, performance issues that relate to unbounded and overprovisioned text fields become more pronounced.
-- **Operational costs**: Increased backup size, longer maintenance windows, and heavier I/O all translate to higher infrastructure and staffing costs.
-- **Poor user experience**: Slow queries result in slower applications, which impacts customer satisfaction and user retention.
-- **Regulatory and data quality issues**: Without enforced constraints, it becomes harder to maintain compliance or perform reliable data analytics.
-
----
-
-## Solution Strategy
-
-We take a proactive and data-driven approach to optimization here.
-
-### Step 1: Audit and analyze
-
-Inspect every text column to determine:
-
-- The actual size of the largest value currently stored in the column.
-- The context and purpose of the data stored in the column (e.g., user input, or external integration).
-- Whether or not a varchar(max) type is a mandatory business and/or technical requirement.
-
-### Step 2: Calculate optimal limits
-
-For every varchar and nvarchar column:
-
-- Given the actual number of characters in the largest value, add a 20% buffer.
-- Round up to the nearest 100 characters.
-- If the result is less than 8K (varchar) or 4K (nvarchar), then adjust the [MAXIMUM\_CHARACTER\_LENGTH](https://learn.microsoft.com/en-us/sql/relational-databases/system-information-schema-views/columns-transact-sql?view=sql-server-ver16) accordingly.
-
-For example, if the largest text value is 1,200 characters → Add 20% → 1,440 → Round up to the nearest 100 → Final column size = varchar(1500)
-
-### Step 3: Apply industry standards
-
-- Ensure columns that store email addresses are set to varchar(254), as per the [standard RFC recommendations discussed here](https://www.directedignorance.com/blog/maximum-length-of-email-address).
-- Ensure columns that store URLs are set to varchar(2000), as per the [recommendations discussed here](https://stackoverflow.com/questions/417142/what-is-the-maximum-length-of-a-url-in-different-browsers).
-
-### Step 4: Upgrade and align the platform
-
-After database schema changes are made, update [Object-Relational Mapping](https://en.wikipedia.org/wiki/Object%E2%80%93relational_mapping) (ORM) configuration classes in the source code for the persistence layer, and then synchronize business rules in the user interface layer with Maximum Length input validation attributes.
-
----
-
-## Provisioning Best Practices
-
-Defining character limits should be intentional and based on actual usage, not guesswork. Here are some recommended guidelines to your database schema design with real-world needs:
-
-### Use varchar(max) and nvarchar(max) only when truly necessary
-
-Reserve these types for fields where values are expected to **exceed 8,000 characters** (varchar) or **4,000 characters** (nvarchar). Most application data does not meet this requirement.
-
-### Define realistic, evidence-based character limits
-
-Choose a reasonable size limit for each varchar and nvarchar column. If a column value is never expected to exceed 100 characters, for example, then specify a limit between 100 and 200 characters — and don't allow SQL Server to believe it can expect values with 400 characters!
-
-### Avoid multiple varchar(max) columns in the same table
-
-If you really need a varchar(max) column or an nvarchar(max) column, then ensure **only one such column exists per table**. This prevents excessive weight in out-of-row LOB storage and maintains better row-level performance.
-
-### Prefer nvarchar only when Unicode is required
-
-Use nvarchar only if you need to support **multiple languages or character sets**. For English-only or single-language applications, varchar is more efficient.
-
-### Support validation at every layer
-
-Enforce limits in the **database schema**, reflect them in **ORM configuration**, and surface them in the **UI with appropriate validation messages**.
-
-### Let data drive the limits
-
-This is it in a nutshell. Know (and understand!) your data, and regularly review the database schema to ensure it enforces tight, data-informed constraints. You'll improve performance, strengthen data integrity, improve resource utilization, and simplify maintenance.
-
----
-
-## Closing Thoughts
-
-Sometimes it's easy to believe provisioning database columns properly is a low-value, low-impact concern, but the shape of your data matters. Especially when it's [big data](https://en.wikipedia.org/wiki/Big_data).
-
-When your platform grows, the consequences of poor and uninformed decisions echo across time and space — quite literally. Making deliberate and informed choices about database column types and size constraints is about much more than technology improvement: it’s a strategic business investment to help ensure a leaner, faster, and more robust platform.
-
-When was the last time you did an audit of the text columns in your SQL Server database? You might be surprised by the positive impact of a small, well-informed change. And a few hours of analysis today could save you days of troubleshooting tomorrow!
-
-#DatabaseDesign #DataIntegrity #Scalability #SoftwareArchitecture #PerformanceOptimization
diff --git a/src/data/blog/automate-your-website-content-migration-with-the-ghost-admin-api.md b/src/data/blog/automate-your-website-content-migration-with-the-ghost-admin-api.md
deleted file mode 100644
index 9a92cae..0000000
--- a/src/data/blog/automate-your-website-content-migration-with-the-ghost-admin-api.md
+++ /dev/null
@@ -1,103 +0,0 @@
----
-title: Automate your website content migration with the Ghost Admin API
-author: Daniel Miller
-pubDatetime: 2025-06-25T17:10:00.000Z
-modDatetime: 2025-06-25T17:10:00.000Z
-featured: false
-draft: false
-tags:
- - api-integration
-ogImage: ../../assets/images/posts/automate-your-website-content-migration-with-the-ghost-admin-api/ghost-integration.jpg
-description: Recently we migrated over a hundred pages from a custom website content management system into Ghost with a simple homegrown ETL utility — and it took less…
----
-
-Recently we migrated over a hundred pages from a custom website content management system into Ghost with a simple homegrown ETL utility — and it took less than a day.
-
-## Why Ghost?
-
-In a [previous article](/posts/structuring-documentation-that-scales/), I mentioned [Ghost](https://ghost.org/) as part of my software system documentation initiative. Last week we took the first steps by migrating over a hundred pages and blog posts from a custom web site content management system into the Ghost platform.
-
-Ghost is an open-source content management system that is especially well-suited to web sites with a blog or newsletter focus, and its [Admin API](https://ghost.org/docs/admin-api/) provides an excellent set of tools for bulk-import of content from other sites and systems.
-
-My team created a simple [Extract, Transform, Load](https://en.wikipedia.org/wiki/Extract,_transform,_load) (ETL) utility to help automate the migration between platforms. A copy of the source code for the ETL utility is available on [GitHub](https://github.com/daniel-miller/ghost-integration), and in this article I'll summarize how it works.
-
-## A simple two-step migration
-
-The migration process is a simple two-step.
-
-### Step 1: Export your existing content
-
-First, you'll need to export the content from the system you're using now. Most website content management systems make this easy to do. You'll probably need to get your hands a little muddy with some scripting, but that's a one-time problem with plenty of resources and solutions available to help.
-
-I consolidated the content this particular project into a single text file, which is also handy as an emergency backup for the company's archive.
-
-The content is prepared and structured into JSON file format, so it is "machine-friendly" for the next step. Here's a quick example of how it looks:
-
-```
-[
- {
- "Name": "2025-06-21-safety-compliance",
- "Day": "21",
- "Month": "June 2025",
- "Date": "2025-06-21T10:15:00-06:00",
- "Title": "New Safety Compliance Course!",
- "Summary": "A new safety compliance course has been released and is mandatory for all field technicians.",
- "Content": "### New Safety Compliance Course Now Available\n\nThe new **Safety Compliance for Field Operations** course is now live. This e-learning module focuses on updated safety protocols and response procedures.\n\nThis course is *mandatory* for all field technicians and must be completed by **July 15, 2025**.\n\n#### How to Access the Course:\n1. Go to the **Homepage**.\n2. Click your **Training Plan**.\n3. Locate **Safety Compliance for Field Operations**.\n\nIf it\u2019s not listed, use the search bar under **e-Learning**.\n\n> **Note**: Completion of this course replaces the previous version and unlocks updated site access credentials.\n\nFor help, contact the Training Coordinator.\n\nStay safe,\n\n**Your HSE Team**"
- },
- {
- "Name": "2025-06-24-maintenance-alert",
- "Day": "24",
- "Month": "June 2025",
- "Date": "2025-06-24T08:00:00-06:00",
- "Title": "Scheduled Maintenance - June 28",
- "Summary": "The platform will undergo scheduled maintenance on June 28. Expect temporary downtime.",
- "Content": "### Scheduled Maintenance on June 28\n\nWe are performing **system maintenance** on the platform:\n\n- \ud83d\uddd3 **Date**: Saturday, June 28, 2025 \n- \ud83d\udd57 **Time**: 08:00 AM \u2013 04:00 PM (MDT)\n\nDuring this period, **access to training modules and dashboards will be unavailable**.\n\n#### What You Need to Know:\n- Please complete any required training **before June 28**.\n- No data will be modified during this maintenance window.\n\nIf you experience issues after maintenance, clear your browser cache or contact the support team.\n\nWe appreciate your understanding!"
- }
-]
-```
-
-### Step 2: Import your content into Ghost
-
-Sign in to your Ghost dashboard and navigate to Your Profile page. Scroll to the bottom and look for the Staff Access Token. All you need is a copy of your token, and you're all set.
-
-The command to import your content will look like this:
-
-```
-dotnet run --project src -- import-pages --url --key --input
-```
-
-The programming is easy to understand. The main part of the logic is implemented in one simple method that looks like this:
-
-I battle-tested this code with a site that contains more than 7000 pages, and it worked flawlessly, so the odds are good that it can handle whatever you want to throw at it.
-
-It is important to note the Ghost Admin API endpoint for creating a new page requires a list of items, rather than a single item, which means you can migrate pages individually or in batches.
-
-And you can import a lot more than just pages. If you need to bulk-load blog posts, subscription tiers, newsletters, discount offers, members, images, and/or webhooks... the API includes features to support all of that.
-
-## Ghost and Spectre
-
-I can't resist a brief technical tangent here...
-
-I discovered [Spectre.Console](https://spectreconsole.net/) not long ago. It's a [open-source library](https://github.com/spectreconsole/spectre.console) that makes it easier to build beautiful console applications.
-
-Spectre is no relation to Ghost, but I love the synchronicity. 👻
-
-Speaking very generally for just a moment, the topic of console applications is a growing interest for me. Console applications might seem like ancient relics, created by dinosaurs for other dinosaurs... but there is growing evidence to support the argument that "command-line-first" development is a valuable software architecture pattern — and may become the primary software development paradigm of the future.
-
-It's a topic for another article another day, but some experts believe [CLI-based development could change software development forever](https://www.danielfullstack.com/article/cli-based-development-could-change-software-development-forever).
-
-## Resources
-
-The [Ghost Admin API Docs](https://ghost.org/docs/admin-api/) are excellent. The content management UI for the Ghost platform uses the Admin API, which means everything Ghost Admin can do is also possible with the API.
-
-The [**Ghost Resources**](https://ghost.org/resources/) page is another excellent place to get started building and publishing content. If you're looking for a new platform to host and manage the content for your site, then I encourage you to check out it.
-
-### Our source code
-
-The source code for our Ghost Integration project is available here: [**https://github.com/daniel-miller/ghost-integration**](https://github.com/daniel-miller/ghost-integration)
-
-Fair warning: it isn't plug-and-play. You’ll need to look after Step One yourself, and to implement Step Two you'll need to modify the code so it fits with your Ghost configuration. So it's only a lightweight starter kit for your Ghost integration, but if you need an example of the programming steps to connect to the API and bulk-import your content, then you might find it helpful.
-
-If you need a hand getting your content loaded into a Ghost-powered site then send me a note. And, of course, you can create a fork of my GitHub repository and make the project your own.
-
-#GhostCMS #ContentMigration #DotNetDevelopers #CommandLineTools #ETL #BuildInPublic
diff --git a/src/data/blog/build-your-own-c-code-analyzer.md b/src/data/blog/build-your-own-c-code-analyzer.md
deleted file mode 100644
index 3b5ae55..0000000
--- a/src/data/blog/build-your-own-c-code-analyzer.md
+++ /dev/null
@@ -1,343 +0,0 @@
----
-title: Build your own C# code analyzer
-author: Daniel Miller
-pubDatetime: 2025-07-20T23:36:00.000Z
-modDatetime: 2025-07-20T23:36:00.000Z
-featured: false
-draft: false
-tags:
- - software-development
-ogImage: ../../assets/images/posts/build-your-own-c-code-analyzer/code-analyzer.jpg
-description: Code quality analysis is essential as AI transforms development workflows. With developers working faster and trusting AI autocomplete, subtle bugs and…
----
-
-I wrote this article to highlight at least one of the reasons why **static code analysis** matters more than ever before, especially in an era of [vibe coding](https://tomaszs2.medium.com/what-is-vibe-coding-5511ff0c29ff) with AI agents.
-
-As developers move faster and trust autocomplete more, the risk of subtle, compounding issues grows exponentially. Tools that automatically perform code quality analysis can help catch troublesome patterns early… before they snowball into serious technical debt.
-
-### A name for the edges
-
-Tolkien gave a name to the most notable weapons in The Lord of the Rings. That has always fascinated me. Aragorn’s sword was named Andúril; Thorin’s sword was named Orcrist; Frodo’s dagger was named Sting. A sword is double-edged, of course, but as far as I know, Tolkien never gave a different name to each of the two edges.
-
-If I wrote a story about a fearless elven software developer on a quest in the wilderness of Middle Earth… then I would not name the sword. Instead, I’d name each of the double edges.
-
-I would name them **Async** and **Await**.
-
-
-
-There is little doubt (in my mind, at least) the [async](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/async) and [await](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/operators/await) keywords in the C# programming language are a double-edged sword: a blessing and a curse that can make your software run like a bat out of hell — or make you feel like you _are_ in hell, trying to dig your way out through miles of dirt and gravel with a plastic spoon… with that same bat duct-taped to the side of your head.
-
-In an article I wrote years ago, I joked that [async/await is evil](/posts/how-do-you-build-a-fast-lightweight-solution-for-cqrs-and-event-sourcing/), and I am no less inclined to joke about it now. For those of us slinging serious code at serious problems, [asynchronous programming](https://learn.microsoft.com/en-us/dotnet/csharp/asynchronous-programming/async-scenarios) is a textbook example of a necessary evil.
-
-> There are many great articles on the performance benefits of asynchronous code. Here is one that provides an excellent summary: [Optimizing Performance and Responsiveness with C#](https://medium.com/@robertdennyson/demystifying-async-await-in-c-net-8-optimizing-performance-and-responsiveness-b04f5e32d0d2)
-
-If you are new to software development then you’ll notice the mystical keywords `async` and `await` littered everywhere, because the moment the async/await pattern is introduced into your codebase, those two words spread like a crazy-contagious virus.
-
-And if you are anything like me, then you’ll learn the hard way: the spread of this particular virus is another necessary evil, because when you forget an await keyword somewhere that it’s expected (and you _will_ forget, believe me) you can spend hours trying to understand why your code suddenly starts behaving like a drunken schizophrenic.
-
-### Allow me to demonstrate…
-
-If you are unclear what I mean, then here is a bare-bones example:
-
-```csharp
-var simon = new Robot("Simon");
-simon.Say("I have awaken.");
-simon.Work();
-simon.Say("I am returning to sleep.");
-
-public class Robot(string name)
-{
- public string Name { get; private set; } = name;
-
- public void Say(string something)
- => Console.WriteLine($"{DateTime.Now:HH:mm:ss} {Name} says: {something}");
-
- public async Task Work()
- {
- Say("I am starting an important task.");
- Say("Hold your breath until my work is complete.");
- await Task.Delay(3000);
- Say("My work is complete.");
- Say("You may breathe again.");
- }
-}
-```
-
-This example is drop-dead simple, with only 21 lines of code, so it is easy to read and understand the intent. The output we expect (obviously) is this:
-
-```
-08:00:00 Simon says: I have awaken.
-08:00:00 Simon says: I am starting an important task.
-08:00:00 Simon says: Hold your breath until my work is complete.
-08:00:03 Simon says: My work is complete.
-08:00:03 Simon says: You may breathe again.
-08:00:03 Simon says: I am returning to sleep.
-```
-
-Simon the robot wakes up and starts his work, you hold your breath for 3 seconds until he completes his work, then you resume breathing, and Simon returns to sleep.
-
-However… this is not what happens...
-
-Many of you astute readers spotted the mistake instantly, probably because it’s a painful mistake you’ve made as many times as I have. For those of you who did not spot the mistake, the actual output is surprising:
-
-```
-08:00:00 Simon says: I have awaken.
-08:00:00 Simon says: I am starting an important task.
-08:00:00 Simon says: Hold your breath until my work is complete.
-08:00:00 Simon says: I am returning to sleep.
-```
-
-It looks like our robot Simon has gone AWOL. You don’t know if he finished his work; you don’t know if he encountered a problem with his important task; and if you follow his instructions then you’ll be holding your breath for a long, long time.
-
-_Maybe_ he finished his work… Maybe he didn’t… Simon never says.
-
-The mistake is tiny:
-
-```csharp
-simon.Work(); // <== The await operator is missing from the invocation here
-```
-
-If you execute this code using `dotnet run` and if you carefully read the output from dotnet then you’ll notice it _does_ offer a helpful hint on line 3: “Consider applying the ‘await’ operator to the result of the call.”
-
-It is easy to miss this, and you’ll kick yourself when you do.
-
-By default, the VS Code IDE shows a squiggly yellow line under the offending line of code, and if you hover over it, the tooltip reads: “Because this call is not awaited, execution of the current method continues before the call is completed.”
-
-It is easy to miss this too, and you’ll kick yourself when you do.
-
-Of course, you’ll catch this kind of mistake quickly enough in a project with only 21 lines of code. But if you’re working in a solution with thousands of lines of code, spanning dozens of projects and libraries, some written by you , some written by others , and some generated by a growing multitude of AI agents — then mistakes in asynchronous code can be fiendishly difficult to diagnose and debug.
-
-> And just for the record: I **have** seen AI agents make this mistake.
-
-### One simple solution
-
-If you are using VS Code or Visual Studio then the simplest solution is to configure the built-in code analyzer warning [CS4014](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/compiler-messages/cs4014?f1url=%3FappId%3Droslyn%26k%3Dk%28CS4014%29) so it halts the compiler with an error message.
-
-If you are working on a new project, or if you are working in a new environment, then this can be easy to forget, so make it a part of your standard checklist whenever you switch environments or start on a new project.
-
-This simple solution is a good solution, and I recommend it.
-
-If you want something a little different, or a little more, then .NET makes it quite easy to implement a code analyzer of your own.
-
-### An alternative, more sophisticated solution
-
-I wanted something more, so I worked with some friends and colleagues at [Shift iQ](http://www.shiftiq.com) to build a code analyzer that enforces a few specific coding rules. (Special thanks to [Oleg](https://github.com/oleg-terzi) and [Aleksey](https://github.com/aleksey-terzi) for their help on this.)
-
-1. Source code files must have one and only one top-level class declaration. This promotes better code organization and maintainability.
-2. Variable names with an “ID” suffix should use “Id” rather than “ID”. This promotes consistent naming conventions.
-3. Asynchronous method names must end with “Async”. This ensures asynchronous methods are clearly identifiable.
-4. Namespace declarations must match the folder structure, and must allow partial matches without necessarily requiring an exact match.
-5. Last, but not least, asynchronous methods must never be invoked without being awaited. This prevents potential issues with fire-and-forget async calls, like we’ve just seen.
-
-### EyeSpy: A custom code analyzer
-
-The [Roslyn](https://github.com/dotnet/roslyn) compiler makes it easy for C# developers to write your own custom code analyzers that integrates directly into your build pipeline.
-
-The analyzer we developed is small and simple, and I named it **EyeSpy**, as a nod to the game we used to play as children.
-
-> “I spy, with my little eye, something in your code that will make you miserable.”
-
-It enforces only the five coding rules I listed above. The source is open and [published on GitHub](https://github.com/daniel-miller/eyespy), so you can dive into the code if you’re interested. Or you can fork the source and make whatever changes and improvements your heart so desires. Alternatively, if you don’t want to be bothered with any of that, you can just add the package to your project directly and run with it as is:
-
-`dotnet add package EyeSpy`
-
-I’ll use the rest of this article to provide more details.
-
----
-
-### What is it?
-
-EyeSpy is a small set of custom Roslyn-based analyzers for C# projects. It enforces a specific set of coding rules by generating a compile-time error when the rules are broken. The rules are designed to be pragmatic and opinionated, suitable for use in both greenfield and legacy projects.
-
-### Why does it matter?
-
-The rationale is straightforward enough. I want to:
-
-- Promote clear and consistent naming conventions
-- Avoid mistakes in async programming practices
-- Align namespace hierarchies and folder structures
-
-### What are the rules?
-
-Version 1.0.5 enforces five distinct rules. The naming convention for these rules is `SPYXX`, where XX is a unique number assigned to the rule. (I don’t expect we’ll need more than 99 analyzers in the foreseeable future, but we can easily update the convention if needed.)
-
-### SPY01: One top-level class per file
-
-This rule ensures that each C# source code file contains one top-level class declaration. Placing multiple classes in a single file often leads to maintainability issues and violates widely accepted conventions for file organization, and this rule safeguards against all that.
-
-#### Examples
-
-```csharp
-public class FirstClass { }
-public class SecondClass { } // ❌ Move SecondClass to a separate file
-```
-
-Limiting files to one class improves traceability and version control diffs, particularly in large teams and open-source projects.
-
-### SPY02: Disallow “ID” as an identifier name suffix
-
-This rule enforces a .NET-recommended naming convention by requiring the replacement of uppercase “ID” suffixes with the more idiomatic Pascal Case “Id”.
-
-#### Examples
-
-```csharp
-public int UserID { get; set; } // ❌ Should be UserId
-private string customerID; // ❌ Should be customerId
-void ProcessOrder(int orderID) { } // ❌ Should be orderId
-```
-
-This is purely cosmetic, of course, but consistent casing always improves readability and aligns with .NET design guidelines. This is especially valuable when working with shared APIs, domain models, and libraries.
-
-### SPY03: Async method naming
-
-Async method names must end with the `Async` suffix. This is a standard convention that clearly signals to developers they are invoking asynchronous code.
-
-#### Examples
-
-```csharp
-public async Task ProcessData() { } // ❌ Should be ProcessDataAsync
-public async Task GetUser() { } // ❌ Should be GetUserAsync
-```
-
-This helps avoid confusion when invoking async methods, especially if sync and async calls are intermixed.
-
-### SPY04: Namespace-folder alignment
-
-When you are navigating a large codebase, it’s essential to have consistency between a namespace and the folder structure in which its class files are organized. This rule requires namespace declarations that aligns to the directory structure.
-
-#### Examples
-
-```csharp
-// Assume file path C:\Projects\MyApp\Controllers\Api\UserController.cs
-namespace MyApp.Controllers.Api // ✅ Valid
-namespace MyApp.Controllers // ✅ Valid
-namespace MyApp // ✅ Valid
-namespace Controllers.Api // ❌ Missing project name as root
-namespace Foo.Bar // ❌ Entirely mismatched
-namespace MyApp.Services // ❌ Diverges from folder structure
-```
-
-This alignment encourages predictable project layout and reduces friction for developers navigating code for the first time (and for developers navigating old code for the first time in a long time).
-
-VS Code and Visual Studio provide support for a similar rule in [IDE0130](https://learn.microsoft.com/en-us/dotnet/fundamentals/code-analysis/style-rules/ide0130), but I find Microsoft’s implementation here too strict. I prefer to allow some flexibility, so that shallow namespaces are permitted for deeper folder structures.
-
-### SPY05: Async calls must be awaited
-
-Un-awaited async calls are a frequent source of nasty bugs, especially when a task is silently dropped or exception-handling behavior is not triggered. This rule identifies `async` method calls that are missing the `await` keyword.
-
-#### Example
-
-```csharp
-public async Task ProcessDataAsync()
-{
- WorkAsync(); // ❌ Should be: await WorkAsync();
- var result = WorkAsync(); // ❌ Should be: var result = await WorkAsync();
-}
-```
-
-This rule helps catch fire-and-forget errors and makes async flows more transparent.
-
----
-
-### Installation options
-
-EyeSpy supports multiple integration approaches depending on your project setup and build preferences.
-
-#### 1\. NuGet package
-
-Add it as a package reference to your `.csproj` project file.
-
-```xml
-
-```
-
-This ensures analyzers are available during build and analysis phases, without polluting the runtime.
-
-#### 2\. Project reference
-
-Add the project directly to your solution for local development:
-
-```xml
-
- Analyzer
-
-```
-
-#### 3\. Analyzer reference
-
-When using the compiled `.dll` you can include the analyzer directly:
-
-```xml
-
-```
-
-This option is useful for build pipelines or custom tooling scenarios.
-
----
-
-### Configuration and suppression
-
-You can configure or suppress diagnostics for individual rules as needed.
-
-#### .editorconfig
-
-Disable or demote specific analyzers:
-
-```editorconfig
-[*.cs]
-dotnet_diagnostic.SPY01.severity = none # Disable file structure rule
-dotnet_diagnostic.SPY02.severity = suggestion # Make casing a suggestion
-```
-
-#### Project file
-
-Suppress multiple warnings in bulk:
-
-```xml
-
- $(NoWarn);SPY01;SPY02
-
-```
-
-#### Pragma directives
-
-Suppress diagnostics around a specific block of code:
-
-```csharp
-#pragma warning disable SPY01
-public class FirstClass { }
-public class SecondClass { } // No error
-#pragma warning restore SPY01
-```
-
-### Platform requirements
-
-Ensure your project targets at least:
-
-- .NET Standard 2.0
-- Microsoft.CodeAnalysis.CSharp 4.14.0
-- Microsoft.CodeAnalysis.Analyzers 4.14.0
-
-These dependencies ensure compatibility with modern tooling while remaining accessible to legacy projects.
-
-We use this library in our .NET Standard projects, our .NET (Core) projects, and our .NET Framework projects.
-
----
-
-### Closing thoughts
-
-EyeSpy is intended to be a clean and clear demonstration of static code analysis in C#. It shows how coding conventions can be enforced without overwhelming developers with a lot of noise and complexity.
-
-By enforcing a carefully curated set of high-impact rules at compile time, a tool like this can really improve the maintainability, readability, and correctness of a codebase.
-
-“Fail Fast” is a great philosophy in software development. If there’s a mistake (or a potential mistake) in your code, then you want a flashing neon sign over it as early as possible — before it can slink off into the dark and hide… where it’s apt to wait until the least opportune time to leap out and sink its teeth into your backside.
-
-If you have read all the way to this point, then it’s a sure sign you care about the quality of your code as much as I do about mine — so I’d be interested in your thoughts on the article and on the project.
-
-Check it out! [https://github.com/daniel-miller/eyespy](https://github.com/daniel-miller/eyespy)
-
-
-
----
-
-This article was originally posted on Medium: [https://medium.com/@daniel-miller/build-your-own-csharp-code-analyzer-0c3cd23f5dbf](https://medium.com/@daniel-miller/build-your-own-csharp-code-analyzer-0c3cd23f5dbf)
diff --git a/src/data/blog/code-of-ethics-and-professional-practice.md b/src/data/blog/code-of-ethics-and-professional-practice.md
deleted file mode 100644
index fe6c83d..0000000
--- a/src/data/blog/code-of-ethics-and-professional-practice.md
+++ /dev/null
@@ -1,50 +0,0 @@
----
-title: Code of ethics and professional practice
-author: Daniel Miller
-pubDatetime: 2025-05-20T12:59:07.000Z
-modDatetime: 2025-05-20T12:59:07.000Z
-featured: false
-draft: false
-tags:
- - business-philosophy
-ogImage: ../../assets/images/posts/code-of-ethics-and-professional-practice/code-of-ethics.png
-description: This code of ethics was developed by the IEEE-CS/ACM joint task force on Software Engineering Ethics and Professional Practices . It was jointly approved by…
----
-
-This code of ethics was developed by the IEEE-CS/ACM joint task force on Software Engineering Ethics and Professional Practices . It was jointly approved by the ACM and the IEEE-CS as the standard for teaching and practicing software engineering.
-
-This summary version of the code of ethics summarizes aspirations at a high level of abstraction. The clauses included in the [full version](https://www.acm.org/code-of-ethics/software-engineering-code) of this code give examples and details of how these aspirations change the way we act as software engineering professionals. Without the aspirations, the details can become legalistic and tedious; without the details, the aspirations can become high sounding but empty; together, the aspirations and the details form a cohesive code.
-
-Software engineers shall commit themselves to making the analysis, specification, design, development, testing, and maintenance of software a beneficial and respected profession. In accordance with their commitment to the health, safety and welfare of the public, software engineers shall adhere to the following eight principles:
-
-#### 1\. PUBLIC
-
-Software engineers shall act consistently with the public interest.
-
-#### 2\. CLIENT
-
-Software engineers shall act in a manner that is in the best interests of their client and employer, consistent with the public interest.
-
-#### 3\. PRODUCT
-
-Software engineers shall ensure that their products and related modifications meet the highest professional standards possible.
-
-#### 4\. JUDGMENT
-
-Software engineers shall maintain integrity and independence in their professional judgment.
-
-#### 5\. MANAGEMENT
-
-Software engineering managers and leaders shall subscribe to and promote an ethical approach to the management of software development and maintenance.
-
-#### 6\. PROFESSION
-
-Software engineers shall advance the integrity and reputation of the profession consistent with the public interest.
-
-#### 7\. COLLEAGUES
-
-Software engineers shall be fair to and supportive of their colleagues.
-
-#### 8\. SELF
-
-Software engineers shall participate in lifelong learning regarding the practice of their profession and shall promote an ethical approach to the practice of the profession.
diff --git a/src/data/blog/color-coding-folders-in-vs-code.md b/src/data/blog/color-coding-folders-in-vs-code.md
deleted file mode 100644
index d9b6b90..0000000
--- a/src/data/blog/color-coding-folders-in-vs-code.md
+++ /dev/null
@@ -1,205 +0,0 @@
----
-title: Color-coding folders in VS Code
-author: Daniel Miller
-pubDatetime: 2025-07-17T04:32:00.000Z
-modDatetime: 2025-07-17T04:32:00.000Z
-featured: false
-draft: false
-tags:
- - software-development
-ogImage: ../../assets/images/posts/color-coding-folders-in-vs-code/color-coding-in-vscode.webp
-description: You can add a little semantic organization to the folders in a large VS Code project directory without nesting them into subfolders. It’s easy to do with a…
----
-
-You can add a little semantic organization to the folders in a large [VS Code](https://code.visualstudio.com/docs) project directory without nesting them into subfolders. It’s easy to do with a little color-coding, and it’s a strategy that works nicely even if you have a bit of color-blindness, thanks to the iconography in the [Material UI](https://mui.com/material-ui/material-icons/).
-
-Every software system architect has been in the same place: staring at a long list of identically-styled folders in the Explorer, trying to mentally parse which directories contain domain logic versus infrastructure code, or distinguishing between test assemblies and production modules.
-
-Of course, the traditional approach to solving this problem quickly leads down the rabbit hole of a deeply nested folder structure. That can become unwieldy in a hurry, but even more problematic than that: it requires one (and only one) answer to the many questions about how to decide the hierarchical structure.
-
-Alternatively, a less traditional approach can leave the project directory exactly as it is, and use the [Material Icon Theme](https://marketplace.visualstudio.com/items?itemName=PKief.material-icon-theme) extension to encode semantic meaning directly into the appearance of each folder in that directory. This permits a flatter structure while preserving important architectural metadata at a glance.
-
-### Why flatten your folder structure?
-
-Before diving into implementation, let’s establish why this approach matters for enterprise development:
-
-Reduced Cognitive Load: Senior developers spend significant time navigating codebases. Visual cues eliminate the mental overhead of remembering what each folder contains.
-
-Architectural Clarity: Color coding can represent architectural layers (presentation, application, domain, infrastructure) without forcing artificial nesting that doesn’t align with your assembly structure.
-
-Team Consistency: When the entire team uses the same visual language, onboarding can be a little easier, and code reviews can be a little more efficient.
-
-Build Performance: Flatter structures result in shorter file paths, which can improve build times in large solutions.
-
-### Configuration Steps
-
-#### Prerequisites
-
-Ensure you have the Material Icon Theme extension installed:
-
-1. Open VS Code
-2. Navigate to Extensions (Ctrl+Shift+X)
-3. Search for “Material Icon Theme” by Philipp Kief
-4. Install and set as your file icon theme
-
-#### Step 1: Access your settings
-
-Open your VS Code settings.json file:
-
-- Press Ctrl+Shift+P (Windows/Linux) or Cmd+Shift+P (Mac)
-- Type “Preferences: Open Settings (JSON)”
-- Select the option to open your user settings.json
-
-#### Step 2: Configure folder associations
-
-Here’s a real-world example from [Shift iQ](https://www.shiftiq.com/), one of the enterprise applications I helped to design. This example demonstrates component type organization without traditional nested structures:
-
-{
-"material-icon-theme.folders.associations": {
-
-"bin": "Batch",
-"obj": "Batch",
-"Properties": "Batch",
-
-"System": "Scala",
-"Orchestration": "Scala",
-"Internal": "Scala",
-
-"Feature": "Project",
-"Assessment": "Project",
-"Billing": "Project",
-"Booking": "Project",
-"Competency": "Project",
-"Content": "Project",
-"Directory": "Project",
-"Feedback": "Project",
-"Job": "Project",
-"Learning": "Project",
-"Location": "Project",
-"Messaging": "Project",
-"Progress": "Project",
-"Reporting": "Project",
-"Workflow": "Project",
-"Workspace": "Project",
-
-"Plugin": "Middleware",
-"Integration": "Middleware",
-"Variant": "Middleware",
-
-"Utility": "Drizzle",
-"Metadata": "Drizzle",
-"Platform": "Drizzle",
-"Security": "Drizzle",
-"Timeline": "Drizzle"
-}
-}
-
-This configuration demonstrates a specific component classification system:
-
-**Build Artifacts** (Batch icons in grey): Standard .NET build outputs that can be safely ignored during development.
-
-**System Components** (Scala icons in red): Core system-level functionality including orchestration services and internal helpers.
-
-**Feature Modules** (Project icons in blue): Business domain features that are organized into independent modules. Rather than creating a “Features” parent folder, each platform feature (Assessment, Billing, Booking, etc.) stands as a peer. You’ll notice this lends itself very well to [vertical slice architecture](https://www.milanjovanovic.tech/blog/vertical-slice-architecture) patterns.
-
-**Integration Layer** (Middleware icons in purple): Components that handle external integrations and custom variants. These typically handle the interoperation between features and external systems.
-
-**Utility Services** (Drizzle icons in green): Cross-cutting concerns and platform utilities that support multiple features without belonging to any specific domain.
-
-Here’s an excerpt to show how it looks in the VS Code Explorer:
-
-
-
-#### Step 3: Understanding the component classification strategy
-
-This approach eliminates the need for traditional component-type parent folders like “Features/”, “Utilities/”, or “Plugins/”. Instead of a structure like:
-
-├── Features/
-│ ├── Billing/
-│ ├── Booking/
-│ └── Assessment/
-├── Utilities/
-│ ├── Security/
-│ └── Platform/
-└── Plugins/
-└── Integration/
-
-You achieve the same semantic organization with a flat structure:
-
-├── Billing/ (blue project icon)
-├── Booking/ (blue project icon)
-├── Assessment/ (blue project icon)
-├── Security/ (green drizzle icon)
-├── Platform/ (green drizzle icon)
-└── Integration/ (purple middleware icon)
-
-The visual encoding preserves the same architectural information with smaller and simpler paths, which improves discoverability. (“Discoverability” is a term you’ll see a lot in API documentation; it’s especially important in web API libraries and open-source platforms.) A developer who is new to the project can immediately distinguish between feature modules, utility services, and integration components without having to mentally parse folder hierarchies.
-
-#### Step 4: Customize for your architecture
-
-The beauty of this approach lies in its flexibility. Adapt the associations to match your specific architectural patterns:
-
-For Clean Architecture projects:
-
-"Core": "core",
-"UseCases": "command",
-"Gateways": "interface",
-"Adapters": "connection"
-
-For Domain Driven Design projects:
-
-"Aggregates": "cluster",
-"ValueObjects": "class",
-"DomainServices": "functions",
-"Specifications": "rules"
-
-For microservice projects:
-
-"ApiGateways": "router",
-"EventHandlers": "event",
-"MessageBrokers": "queue",
-"HealthChecks": "health"
-
-#### Advanced semantic encoding
-
-Beyond basic folder types, you can encode additional metadata. For example, you might decide to encode priority levels:
-
-- Critical components: “Auth”: “secure”
-- Performance-sensitive: “Cache”: “temp”
-- Legacy code: “Legacy”: “archive”
-
-… or team ownership:
-
-- “Frontend”: “public”
-- “Backend”: “private”
-- “DevOps”: “tools”
-
-… or environment-specificity:
-
-- “Development”: “environment”
-- “Staging”: “staging”
-- “Production”: “dist”
-
-### A few recommendations to get started
-
-There are a few things to keep in mind.
-
-**Establish team standards**. Document your conventions in a README at the directory root. Consistency is important for this approach to provide value.
-
-**Start gradually**. Begin with high-level architectural distinctions before diving into granular categorizations. Too many associations could become counterproductive.
-
-**Review regularly**: As your codebase evolves, revisit and refine your folder associations. What made sense six months ago might need adjustment.
-
-### In closing…
-
-Applying iconography to the folders of a large project in VS Code is a small investment with some (potentially) big returns — especially for senior software development teams. By encoding architectural semantics directly into the visual presentation of your IDE, you can eliminate a little cognitive overhead while maintaining clean, flat project structures that align well with modern development practices.
-
-The key is to treat folder icons/colors as architectural documentation that lives alongside your code, evolving with your system’s complexity while keeping navigation intuitive and efficient.
-
-Start with a basic configuration, then refine it over time to match the patterns and conventions that make sense for your project and your team. Your future self — and your teammates — will appreciate the added clarity.
-
-#VSCode #SoftwareArchitecture #DeveloperExperience #CleanArchitecture #CognitiveLoad #DevTeamProductivity
-
----
-
-This article was originally posted on Medium: [https://medium.com/@daniel-miller/color-coding-folders-in-vs-code-45006fb32473](https://medium.com/@daniel-miller/color-coding-folders-in-vs-code-45006fb32473)
diff --git a/src/data/blog/determine-the-length-of-the-largest-text-value-in-every-database-table-column.md b/src/data/blog/determine-the-length-of-the-largest-text-value-in-every-database-table-column.md
deleted file mode 100644
index e7d9059..0000000
--- a/src/data/blog/determine-the-length-of-the-largest-text-value-in-every-database-table-column.md
+++ /dev/null
@@ -1,105 +0,0 @@
----
-title: Determine the length of the largest text value in every database table column
-author: Daniel Miller
-pubDatetime: 2025-05-24T02:48:04.000Z
-modDatetime: 2025-05-24T02:48:04.000Z
-featured: false
-draft: false
-tags:
- - performance-optimization
-ogImage: ../../assets/images/posts/determine-the-length-of-the-largest-text-value-in-every-database-table-column/db-optimization.png
-description: Whenever I inherit a database from another developer, I always start by analyzing its size and schema to identify any immediate quick wins to improve its…
----
-
-Whenever I inherit a database from another developer, I always start by analyzing its size and schema to identify any immediate quick wins to improve its performance - and/or decrease its drag on the underlying server infrastructure.
-
-For example, I remember one database in particular that contained about 8 million rows in 22 tables. Despite the large number of rows, the data was entirely plain text (English and French only), and the number of columns per table was relatively small, so the amount space the database occupied on the disk surprised me: more than 6 GB.
-
-After further analysis, I discovered the developer had used the `NVARCHAR` data type for every text column in every table.
-
-`NVARCHAR` is a Unicode, variable-length character data type, which requires 2 bytes per character. This data type isn't needed for storing English or French plain text, because both languages are fully supported by the standard `VARCHAR` data type.
-
-`VARCHAR` is a non-Unicode, variable-length character data type, which requires 1 byte per character.
-
-In other words, using `VARCHAR` rather than `NVARCHAR` saves storage space and improves performance without any downside in this usage scenario. The `NVARCHAR` data type is designed to store a wide range of global characters, such as Chinese or Arabic, which require Unicode. Since English and French use standard Latin characters, there is no need for the extra overhead of Unicode.
-
-Put simply, I decreased the size of every database table by more than 50% simply by converting the data type for all `NVARCHAR` columns to `VARCHAR`. This improved disk utilization by a factor of more than 2X.
-
-At the same time, it was an ideal opportunity to adjust the size of every `VARCHAR` column so its maximum length more closely matched the size of the largest text value it contained. This does not contribute to decreasing the size of the database, but it does bring the schema into closer alignment with the actual data that it stores, and this can lead to query performance improvements in SQL Server. (In the future I will post a separate article on this topic.)
-
-To determine an appropriate size for every text column in every database table, I needed a T-SQL query to list the tables and calculate `MAX(LEN())` for every `VARCHAR` column. I could not find anything to do exactly what I wanted, so I wrote a query that turned out to do the job nicely.
-
-## Using the code
-
-The SQL query looks like this:
-
-```sql
-DECLARE @TableName NVARCHAR(100);
-
-DECLARE X CURSOR READ_ONLY LOCAL FOR
- SELECT '[' + TABLE_SCHEMA + '].[' + TABLE_NAME + ']'
- FROM INFORMATION_SCHEMA.TABLES
- WHERE TABLE_TYPE = 'BASE TABLE'
- AND TABLE_SCHEMA = 'accounts'
- ORDER BY TABLE_SCHEMA, TABLE_NAME;
-
-OPEN X;
-FETCH FROM X INTO @TableName;
-
-WHILE @@FETCH_STATUS = 0
-BEGIN
- DECLARE @Query NVARCHAR(MAX);
-
- SELECT @Query = N'SELECT ''' + @TableName + N''' as TableName, ' +
- STUFF((
- SELECT
- ', MAX(LEN([' + COLUMN_NAME + '])) as [' + COLUMN_NAME +
- ' (' +
- CASE
- WHEN CHARACTER_MAXIMUM_LENGTH = -1 THEN 'max'
- ELSE CAST(CHARACTER_MAXIMUM_LENGTH AS VARCHAR(10))
- END + ')]'
- FROM INFORMATION_SCHEMA.COLUMNS
- WHERE DATA_TYPE IN ('nvarchar', 'varchar')
- AND '[' + TABLE_SCHEMA + '].[' + TABLE_NAME + ']' = @TableName
- FOR XML PATH('')
- ), 1, 1, '') +
- N' FROM ' + @TableName
- FROM INFORMATION_SCHEMA.COLUMNS
- WHERE DATA_TYPE IN ('nvarchar', 'varchar');
-
- EXEC sp_executesql @sql = @Query;
-
- FETCH NEXT FROM X INTO @TableName;
-END;
-
-CLOSE X;
-DEALLOCATE X;
-```
-
-Executing the query returns a result that looks like this:
-
-
-
-The output isn't beautiful, but it provides all the information I needed. At one glance, I can see the maximum length of the actual values in every column in every table for the entire database. I can also see the maximum character length already defined for each column: this appears in brackets beside the column name.
-
-Then, I can adjust the size of each column as (if) needed:
-
-```sql
--- Resize the column, leaving extra space for future outliers.
-ALTER TABLE accounts.TDeveloper
-ALTER COLUMN OrganizationCode VARCHAR(10)
-```
-
-## Points of interest
-
-I don't see the [STUFF](https://msdn.microsoft.com/en-us/library/ms188043.aspx) function very frequently, so it did not occur to me initially. This function inserts a string into another string by deleting a specified length of characters in the first string at the start position, and then inserting the second string into the first string at the start position. This can be handy for string-manipulation, especially when we want to generate a dynamic SQL statement that hits the database only once per table.
-
-Additional steps to reduce the size of the database included rebuilding the indexes on all tables, and shrinking the database with [DBCC](https://learn.microsoft.com/en-us/sql/t-sql/database-console-commands/dbcc-transact-sql).
-
-At the end of the day, the size of the database was less than 1.5 GB, for an overall reduction of more 75 percent!
-
----
-
-This article originally appeared on CodeProject:
-[How to calculate the length of the largest text value in every table column](https://www.codeproject.com/Tips/1042832/How-to-Calculate-the-Length-of-the-Largest-Text-Va)
diff --git a/src/data/blog/extract-time-entry-worklogs-from-jira-and-tempo.md b/src/data/blog/extract-time-entry-worklogs-from-jira-and-tempo.md
deleted file mode 100644
index f4d0172..0000000
--- a/src/data/blog/extract-time-entry-worklogs-from-jira-and-tempo.md
+++ /dev/null
@@ -1,53 +0,0 @@
----
-title: Extract time entry worklogs from Jira and Tempo with .NET API integration
-author: Daniel Miller
-pubDatetime: 2025-05-26T03:16:55.000Z
-modDatetime: 2025-05-26T03:16:55.000Z
-featured: false
-draft: false
-tags:
- - api-integration
-ogImage: ../../assets/images/posts/extract-time-entry-worklogs-from-jira-and-tempo/office.jpg
-description: Jira API + Tempo API + .NET 9 = Extract the data you need! Jira and Tempo are incredibly powerful together. Jira gives you customizable workflows and issue…
----
-
-**Jira API + Tempo API + .NET 9 = Extract the data you need!**
-
-Jira and Tempo are incredibly powerful together. Jira gives you customizable workflows and issue tracking. Tempo brings in robust time tracking, resource planning, and cost analysis. Together, they offer a flexible platform for managing projects and understanding how your teams work.
-
-But here's the challenge: That **flexibility** can become a limitation when it comes to **reporting**. You can capture almost any kind of data — but try to generate a specific summary of hours by worker or by a custom field on issues with the built-in UI alone, and you might hit a few speed bumps.
-
-I created a simple open-source project to help: [**Jira-Tempo Integration**](https://github.com/daniel-miller/jira-tempo-integration)
-
-This tool connects to both the **Jira API** and the **Tempo API** to extract detailed time entries — including issue details and custom fields — and generates clean **CSV outputs** that are easy to drop into Excel. It’s built for real-world needs like:
-
-- Summarizing hours by **account** (from a Jira custom field)
-- Breaking down hours per **team member**
-- Handling **API pagination** and custom field identifiers
-- Supporting **date range inputs**
-
-It's not plug-and-play — you’ll need to adjust it for your Jira/Tempo configuration — but it is transparent, extensible, and battle-tested in a live environment. It’s a great place to start if you’re stuck trying to figure out how to extract specific data for reporting that goes beyond what the UI can deliver.
-
-Want to see how the logic works? The main code is clean and easy to modify:
-
-```
-var jira = new JiraClient(settings);
-
-var tempo = new TempoClient(settings, jira);
-
-var entries = await tempo.GetTimeEntries(settings.Since, settings.Until);
-
-var list = entries.OrderBy(x => x.Date)
- .ThenBy(x => x.Worker)
- .ThenBy(x => x.Account)
- .ThenBy(x => x.Type)
- .ThenBy(x => x.Issue)
- .ToList();
-
-BuildReports(list);
-```
-
-Get the source code here:
-🔗 [https://github.com/daniel-miller/jira-tempo-integration](https://github.com/daniel-miller/jira-tempo-integration)
-
-If you need a hand trying to get that _one_ report out from your Jira and Tempo setup then drop me a note. Or create your own fork of the repository on GitHub and make it your own!
diff --git a/src/data/blog/headless-software-is-a-growing-trend.md b/src/data/blog/headless-software-is-a-growing-trend.md
deleted file mode 100644
index c99c291..0000000
--- a/src/data/blog/headless-software-is-a-growing-trend.md
+++ /dev/null
@@ -1,20 +0,0 @@
----
-title: Headless software is a growing trend
-author: Daniel Miller
-pubDatetime: 2025-07-02T17:55:00.000Z
-modDatetime: 2025-07-02T17:55:00.000Z
-featured: false
-draft: false
-tags:
- - software-development
-ogImage: ../../assets/images/posts/headless-software-is-a-growing-trend/headless-cms.jpg
-description: The first time I saw the term "Headless CMS", I thought of the horseman in The Legend of Sleepy Hollow. Needless to say, the term "headless" means something…
----
-
-The first time I saw the term "Headless CMS", I thought of the horseman in The Legend of Sleepy Hollow.
-
-Needless to say, the term "headless" means something quite different in software architecture. 🙂
-
-Headless applications are a growing trend—it's a pattern I see more and more often these days, especially in the world of content management systems.
-
-[What is a Headless application?](https://medium.com/aasaan-blog/what-is-a-headless-application-920f424b6a1e)
diff --git a/src/data/blog/how-do-you-build-a-fast-lightweight-solution-for-cqrs-and-event-sourcing.md b/src/data/blog/how-do-you-build-a-fast-lightweight-solution-for-cqrs-and-event-sourcing.md
deleted file mode 100644
index 7e073e2..0000000
--- a/src/data/blog/how-do-you-build-a-fast-lightweight-solution-for-cqrs-and-event-sourcing.md
+++ /dev/null
@@ -1,1050 +0,0 @@
----
-title: How do you build a fast, lightweight solution for CQRS and event sourcing?
-author: Daniel Miller
-pubDatetime: 2025-06-30T02:11:00.000Z
-modDatetime: 2025-06-30T02:11:00.000Z
-featured: false
-draft: false
-tags:
- - software-development
-ogImage: ../../assets/images/posts/how-do-you-build-a-fast-lightweight-solution-for-cqrs-and-event-sourcing/cqrs-es-1.jpg
-description: CQRS+ES is a software architecture pattern based on the principle of cause and effect, and it guarantees an audit log with perfect fidelity. Commands write…
----
-
-## Preamble
-
-I published this article for [Code Project](https://www.codeproject.com/) in 2020. It's tough to believe five years have passed since then. I guess time flies when you're having fun...
-
-The Code Project site has been in a state of flux for the past several months, and I don't know when (or if) it will return to normal operation again. Sites like Code Project and [Stack Overflow](https://stackoverflow.com/) seem to be struggling to gain a toe-hold in the sheet of glass that AI and Large Language Models have paved over the entire Q&A landscape. In case Code Project goes dark, I decided to re-publish the original article here on LinkedIn. Five years is an eon in the software industry, but the content here stands the test of time quite well — so far, at least!
-
-The source code for the article is available here [https://github.com/daniel-miller/timeline](https://github.com/daniel-miller/timeline)
-
----
-
-## Introduction
-
-If you are reading this article, then you probably already know something about Command Query Responsibility Segregation ([CQRS](https://learn.microsoft.com/en-us/azure/architecture/patterns/cqrs)) and Event Sourcing ([ES](https://learn.microsoft.com/en-us/azure/architecture/patterns/event-sourcing)). There is some very good material available online, if you are looking for background information. For example:
-
-- [CQRS in Practice](https://www.pluralsight.com/courses/cqrs-in-practice)
-- [CQRS by Martin Fowler](https://martinfowler.com/bliki/CQRS.html)
-- [Event Sourcing Pattern (](https://microservices.io/patterns/data/event-sourcing.html)[Microservices.io](http://microservices.io/)[)](https://microservices.io/patterns/data/event-sourcing.html) or [Event Sourcing Pattern (](https://docs.microsoft.com/en-us/azure/architecture/patterns/event-sourcing)[Microsoft.com](http://microsoft.com/)[)](https://docs.microsoft.com/en-us/azure/architecture/patterns/event-sourcing)
-- [Event Sourcing: The Good, the Bad, and the Ugly](https://www.continuousimprover.com/2017/11/event-sourcing-good-bad-and-ugly.html)
-- [What They Don't Tell You About Event Sourcing](https://medium.com/@hugo.oliveira.rocha/what-they-dont-tell-you-about-event-sourcing-6afc23c69e9a)
-
-In my view, the key benefits of CQRS+ES are these:
-
-- Data is never modified or deleted.
-- The change/audit log for your system has perfect integrity.
-- It enables rollbacks and other time-based features, such as running analyses on previous states.
-- It can improve application performance and scalability - at least, in theory!
-- It can also (in theory) improve code quality and testability.
-
-In this article I won't explain the rationale behind CQRS+ES in any more detail than that, and I won't dive into reasons why you might want to use it (or avoid it).
-
-The purpose of this article is to present the pattern for a fast and lightweight implementation using the C# programming language and the .NET Framework.
-
-This implementation is very simple, but still relatively full-featured, including support for SQL Server persistence of commands and events, scheduled commands, snapshots, sagas (i.e., process managers), and plug-and-play overrides for multitenant customization.
-
-I will describe how the code is structured and illustrate how it works with a sample program that follows Clean Architecture principles.
-
-Please note: I do not expect (or recommend) that you take this source code and incorporate it directly into any software system you are developing. This "implementation" is only a prototype, intended to illustrate one potential application for a theoretical pattern; it is not intended to serve as a reusable library or finished product - and the code is not suitable for integration into any live, production system.
-
-## Why Bother?
-
-This is almost certain to be your first question.
-
-If you are researching options and evaluating alternatives to make a build-vs-buy decision for a CQRS+ES solution, then there are some existing commercial and open-source products to consider. For example:
-
-- [Event Store](https://eventstore.com/)
-- [EventFlow](http://geteventflow.net/)
-- [CQRSlite](https://github.com/gautema/CQRSlite)
-- [SimpleCQRS](https://github.com/tyronegroves/SimpleCQRS)
-
-Why implement a solution when those options are available? Why start from scratch and develop your own?
-
-I have studied CQRS and ES patterns for several years now. I have worked with some commercial and open-source solutions, and I have used them to build and/or improve real-world production systems. If your background and experience is similar to mine, then you probably know the answer to this question already, but you might not want to believe it's true (as I did not for a long time):
-
-**If you are serious about adopting a CQRS+ES architecture, then you might have no choice except to build your own.**
-
-As Chris Kiehl says in his article, "[Event Sourcing is Hard](https://chriskiehl.com/article/event-sourcing-is-hard)":
-
-> _... you're probably going to be building the core components from scratch. Frameworks in this area tend to be heavyweight, overly prescriptive, and inflexible in terms of tech stacks. If you want to get something up and running ... then rolling your own is the way to go (_[_and a suggested approach_](https://youtu.be/LDW0QWie21s?t=1926)_)._
-
-If that's the case, then how does it help you for me to write this article?
-
-Simple: It's another example, with source code, so you can see my approach to solving some of the problems that arise in a CQRS+ES implementation. If you are starting out on your first CQRS+ES project, then you should study all the examples you can find.
-
-My intent is to provide such an example, from which you can draw ideas - and perhaps (if I do a decent job of this) some small inspiration - for your own project.
-
-## Priorities
-
-It is important to begin with a list of the priorities driving this implementation, because there are significant trade-offs to many of the design decisions I have made.
-
-CQRS+ES purists will object to some of my decisions, and flatly condemn others. I can live with that. I have been designing and developing software for a long time (longer than I am prepared to admit here). I have shed more than a little blood, sweat, and tears - and a few gray hairs too - so I am acutely aware of the cost associated with a poor choice in the face of a trade-off.
-
-The following priorities help to inform and guide those decisions. They are listed in rough order of importance, but _all_ are requirements, so pour yourself a drink and settle in, because the preamble here is going to be a long one...
-
-### 1\. Readability
-
-The code must be _readable_.
-
-The more readable the code, the more usable and maintainable and extensible it is.
-
-In some implementations I have used (and in some I have developed myself), the code for the underlying CQRS+ES backbone is virtually impossible for anyone to understand except the original author. We cannot allow that here. It must be possible - and relatively easy - for a small team of developers to share and use the code, with a full understanding of how it works and why it is written in the way that it is.
-
-It is especially important to keep the code for registering command handlers and event handlers as simple and explicit as possible.
-
-Many CQRS+ES frameworks use a mix of reflection and dependency injection to automate the registration of subscribers for handling commands and events. While this is often very clever, and often decreases the overall number of lines of code in the project, it hides the relationships between a command (or an event) and its subscriber(s), moving those relationships into an opaque, magical black-box. Many inversion-of-control (IoC) containers make this easy to do, hence the understandable temptation, but I believe it's a mistake.
-
-To be clear: it is not a mistake to use an IoC container in your project. Dependency injection is an excellent best practice and an important technique to perfect. However, the [dependency injection pattern](https://en.wikipedia.org/wiki/Dependency_injection) is not itself a [publish-subscribe pattern](https://en.wikipedia.org/wiki/Publish%E2%80%93subscribe_pattern), and conflating the two can lead to a lot of misery and woe. It is a mistake (I have made myself) to use highly specialized features in an IoC container library to automate functionality that is on the outside edge of that library's intended purpose, and then tightly couple the most critical components in your software architecture to that. When something in your application behaves unexpectedly, this can make it extraordinarily difficult and time-consuming to troubleshoot and debug.
-
-Therefore, as part of this readability goal, the registration of command handlers and event handlers must be defined _explicitly_ in the code, and not _implicitly_ via convention or automation.
-
-### 2\. Performance
-
-The code must be _fast_.
-
-Handling commands and events is at the heart of any system developed on a CQRS+ES architecture, so throughput optimization is a key performance indicator.
-
-The implementation must handle the maximum possible volume, in terms of concurrent users and systems issuing commands and observing the effect of published events.
-
-In some of my previous implementations, a lot of pain and suffering was caused by concurrency violations that occurred when commands were sent to large aggregates (e.g., long-lived aggregates with massive event streams). More often than not, the root cause was poor-performing code. Therefore algorithm optimization is critical.
-
-Snapshots are integral to satisfying this requirement, therefore must be integral to the solution. The implementation must have built-in support for automated snapshots on every aggregate root.
-
-In-memory cache is another important part of run-time optimization, therefore must be integral to the solution as well.
-
-### 3\. Debuggability
-
-It must be easy to trace the code and follow its execution using a standard debugger like the Visual Studio IDE debugger.
-
-Many CQRS+ES implementations seem to rely on complex algorithms for dynamic registration, lookup, and invocation of methods for handling commands and events.
-
-Again, many of these algorithms are extremely clever: they pack a lot of power and flexibility, and can significantly decrease the number of lines of code in the solution.
-
-For example, I have used a [DynamicInvoker](https://gist.github.com/Daniel-Miller/902a7b435a7409941696c07eb5dd87e1) class in some of my own past projects. It's an ingenious bit of code - less than 150 lines - and it works beautifully. (I didn't write it, so I'm not boasting when I say that.) However, if something goes haywire in code you've written that calls methods on this kind of class, and if you need to step through it with a debugger, then you'll need to be especially adept at the mental gymnastics required to follow what's going on. I am not, so if any dynamic invocation is used, then it must be trivially easy to understand the code and follow the thread of its execution when using a debugger.
-
-### 4\. Minimal Dependencies
-
-External dependencies must be kept to an absolute bare-metal minimum.
-
-Too many dependencies lead to code that is slower, heavier, and more brittle than you are likely to want in any critical components of your system. Minimizing dependencies helps to ensure your code is faster, lighter, and more robust.
-
-Most important, minimizing dependencies helps to ensure the solution is not tightly coupled with any external assembly, service, or component unless that dependency is critical.
-
-If the fundamental architecture of your software is dependent upon some external third-party component, then you must be prepared for the potential that changes to it might someday have an impact on your project. Sometimes this is an acceptable risk, other times it is not.
-
-In this particular implementation, tolerance for this risk is very, very low.
-
-Therefore, you will notice the core Timeline assembly (which implements the CQRS+ES backbone in my solution) has one and only one external dependency: i.e., the System namespace in the .NET Framework.
-
-> Just a quick aside here, because it is an interesting article that illustrates my point: At the time [this article](https://www.techrepublic.com/article/why-its-finally-time-for-developers-to-address-the-chaos-of-node-js-and-npm/) was written in 2018, the NPM JavaScript package "is-odd" had over 2.8 million installations in a single week. Rather than write the basic code for a function to return true if a number is odd, all those developers chose to incorporate the is-odd package into their solutions, along with its chain of 300+ dependencies!
-
-### 5\. Separate Commands and Events
-
-Many CQRS+ES frameworks implement a Command class and an Event class in such a way that both derive from a common base class.
-
-The rationale for this is obvious: it is natural to think of both Commands and Events as subtypes of a general-purpose Message. Both are "sent" using some form of "service bus", so why not implement common features in a shared base class, and write one dual-purpose class for routing messages - rather than write a lot of duplicate code?
-
-This is an approach I have taken in the past, and there are good arguments for it.
-
-However, I now believe it might be a mistake. To quote [Robert C. Martin](https://www.informit.com/authors/bio/361a5e70-f1e2-432b-9928-b30b4742ae80):
-
-> Software developers often fall into a trap - a trap that hinges on their fear of duplication. Duplication is generally a bad thing in software. But there are different kinds of duplication. There is true duplication, in which every change to one instance necessitates the same change to every duplicate of that instance. Then there is false or accidental duplication. If two apparently duplicated sections of code evolve along different paths - if they change at different rates, and for different reasons - then they are not true duplicates... When you are vertically separating use cases from one another, you will run into this issue, and your temptation will be to couple the use cases because they have similar user interfaces, or similar algorithms, or similar database schemas. Be careful. Resist the temptation to commit the sin of knee-jerk elimination of duplication. Make sure the duplication is real.
-
-Commands and events are sufficiently different from one another to warrant separate paths along which they can evolve and adapt to the requirements of your system.
-
-I have not (yet) experienced any scenario in which code quality, performance, or readability is improved by eliminating "duplicate" code for A) sending/handling commands, and B) publishing/handling events.
-
-Therefore commands and events must **not** have any shared base class, and the mechanism used to send/publish commands/events must **not** be a shared queue.
-
-### 6\. Multitenancy
-
-Multitenancy must be integral to the solution, and not a feature or facility that is bolted on after-the-fact.
-
-These days I build and maintain enterprise, multitenant systems exclusively. That means I have a single instance of a single application serving multiple concurrent tenants with multiple concurrent users.
-
-There are several reasons for making multitenancy a priority in this implementation:
-
-- Every aggregate must be assigned to a tenant. This makes ownership of data clear and well-defined.
-- Sharding must be easy to implement when the need arises to scale up. Sharding is the distribution of aggregates to multiple write-side nodes, and "tenant" is the most natural boundary along which to partition aggregates.
-- Tenant-specific customizations must be easy to implement. Every application has core default behavior for every command and every event, but in a large and complex application that serves many different organizations and/or stakeholders, different tenants are certain to have a variety of specific needs. Sometimes the differences are slight; sometimes they are significant. The solution here must allow the developer to override the default handling of a command and/or event with functionality that is custom to a specific tenant. Overrides must be explicit, so they are easy to identify and enable or disable.
-
-### 7\. Sagas / Process Managers
-
-The number of steps required to implement a process manager must be relatively small, and the code for a process manager must be relatively easy to write.
-
-A process manager (sometimes called a saga) is an independent component that reacts to domain events in a cross-aggregate, eventually consistent manner. A process manager is sometimes purely reactive, and sometimes represents a workflow.
-
-> From a technical perspective, a process manager is a state machine driven forward by incoming events, which might be published from multiple aggregates. Each state can have side effects (e.g., sending commands, communicating with external web services, sending emails).
-
-I have worked with some CQRS+ES frameworks that do not support process managers at all, and others that support the concept but not in a way that is easy to understand or configure.
-
-> For example, in one of my own past implementations, an event was published _by the event store_ immediately after the event was appended to the database log. It was not published by the aggregate or by the command handler. This made it unusually difficult to implement even the most basic workflow: I could not send a synchronous command to an aggregate from within an event handler, because the event store's Save method executed inside a synchronization lock (to maintain thread-safety), and new events could not be published without creating a deadlock.
-
-Regardless of how simple or complex the state-machine for a workflow happens to be, coordinating the events in that process requires code that has side effects, such as sending commands to other aggregates, sending requests to external web services, or sending emails. Therefore, the solution here must have native, built-in support for achieving this.
-
-### 8\. Scheduling
-
-The scheduling of commands must be integral to the solution.
-
-It must be easy to send a command with a timer, so the command executes only after the timer elapses. This enables the developer to indicate a specific date and time for the execution of any command.
-
-This is useful for commands that must be triggered on a time-dependency.
-
-It is also useful for commands that must be executed "offline", in a background process outside the normal flow of execution. This type of totally asynchronous operation is ideal for a command that is expected to require a long time to complete.
-
-> For example, suppose you have a command that requires the invocation of a method on some external third-party web service, and suppose that service often takes more than 800,000 milliseconds to respond. Such a command must be scheduled to execute during off-peak hours, and/or outside the main thread of execution.
-
-### 9\. Aggregate Expiration
-
-The solution must have native, built-in support for aggregate expiration and cleanup.
-
-I need a CQRS+ES solution that makes it easy to copy an aggregate event stream from the online structured log to offline storage, and purge it from the event store.
-
-> Event sourcing purists will red-flag this immediately and say the event stream for an aggregate must never be altered or removed. They'll say that events (and therefore aggregates) are immutable by definition.
-
-However, I have scenarios in which this is a non-negotiable business requirement.
-
-- First: When a customer does not renew their subscription to a multitenant application, the service provider hosting the application often has a contractual obligation to remove that customer's data from its systems.
-- Second: When a project team runs frequent integration tests to confirm system functions are operating correctly, the data input to and output from those tests is temporary by definition. Permanent storage of the event streams for test aggregates is a waste of disk space with no current or future business value; we need a mechanism for removing it.
-
-Therefore, the solution here must provide an easy way to move aggregates out of the operational system and into "cold storage", so to speak.
-
-### 10\. Async/Await is Evil
-
-I am joking, of course.
-
-But not really.
-
-The [async/await](https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/concepts/async/) pattern in C# produces _very_ high-performance code. There is no question about this. In some cases, I have seen it boost performance by an order of magnitude or more.
-
-The async/await pattern may be applied in a future iteration of this solution, but - despite the second priority in this list - it is disallowed in this solution, because it breaks the first priority.
-
-As soon as you introduce async/await into a method, you are forced to transform its callers so they use async/await (or you are forced to start wrapping clean code in dirty threading blocks), and then you are forced to transform the callers of those callers so they use async/await... and the async/await keywords spread throughout your entire code base like a contagious zombie virus. The resulting asynchronous mess is almost certain to be faster, but at the same time much more difficult to read, and even more difficult to debug.
-
-Readability is the highest priority here, therefore I am avoiding async/await until it is the only remaining option for boosting performance (and that added boost is itself a non-negotiable business requirement).
-
-## Clean Architecture
-
-[Matthew Renze](https://github.com/matthewrenze) has an excellent [Pluralsight course](https://www.pluralsight.com/courses/clean-architecture-patterns-practices-principles) on the topic of clean architecture. The source code for this solution contains five assemblies and it follows the clean architecture pattern that he advocates. This is overkill for a sample application, obviously, but it helps to establish the pattern that the larger enterprise implementation needs to follow.
-
-### Timeline Project
-
-The Timeline assembly implements the CQRS+ES backbone. This assembly has no upstream dependencies, and therefore it is not specific to any application. It can be unplugged from the sample application and integrated into a new solution to develop an entirely different application.
-
-The other four assemblies (_Sample.\*_) implement the layers in a console application using the Timeline assembly to demonstrate my approach to common programming tasks in a CQRS+ES software system.
-
-The project dependency diagram is illustrated here:
-
-
-
-### Sample Projects
-
-Notice the Timeline assembly has no references to any Sample assembly.
-
-Also notice the domain-centric approach: the Domain layer has no dependencies on the Presentation, Application, or Persistence layers.
-
-The entity relationship diagram for the sample domain is illustrated in Figure 2:
-
-
-
-In this basic data model:
-
-- a Person had 0..N bank Accounts;
-- a Transfer withdraws money from one account and deposits it in another account;
-- a User may be an administrator with no personal data, or someone with personal data owned by multiple tenants
-
-Keep in mind: every Person, Account, and Transfer is an aggregate root, therefore each of these entities has a Tenant attribute.
-
-### Overview
-
-The overall approach to CQRS+ES in this solution is illustrated in Figure 3:
-
-
-
-Notice the Write Side (Commands) and Read Side (Queries) are well-delineated.
-
-You can also see that Event Sourcing is very much like a plug-in to the Write Side. Although it is not demonstrated in this solution, you can see how a CQRS solution _without_ Event Sourcing might look, and sometimes that (CQRS-alone) is a better pattern, depending on the requirements for your project.
-
-Here are the key characteristics of the architecture:
-
-- The command queue saves commands (required for scheduling) in a structured log.
-- A command subscriber listens for commands on the command queue.
-- A command subscriber is responsible for creating an aggregate and invoking methods on an aggregate when commands are executed.
-- A command subscriber saves an aggregate (as an event stream) in a structured log.
-- A command subscriber publishes events on the event queue.
-- Published events are handled by event subscribers and process managers.
-- A process manager can send commands on the command queue, in response to events.
-- An event subscriber creates and updates projections in a query store.
-- A query search is a lightweight data access layer for reading projections.
-
-## Getting Started
-
-Before you compile and execute the source code:
-
-1. Execute the script "Create Database.sql" to create a local SQL Server database.
-2. Update the connection string in _Web.config_.
-3. Update the appSetting value in _Web.config_ for OfflineStoragePath.
-
-### Usage
-
-Rather than start at the bottom, and describe how the Timeline assembly works, I will start at the top and demonstrate how to use it, then work my way down through the application stack to the nuts and bolts of the CQRS+ES backbone.
-
-If I have held your attention this long, then I owe you more than a little reward for staying with me thus far...
-
-### Scenario A: How to Create and Update a Contact
-
-This is the simplest possible usage.
-
-Here we create a new contact person, then perform a name-change, simulating a use case in which Alice gets married:
-
-```
-public static void Run(ICommandQueue commander)
-{
- var alice = Guid.NewGuid();
- commander.Send(new RegisterPerson(alice, "Alice", "O'Wonderland"));
- commander.Send(new RenamePerson(alice, "Alice", "Cooper"));
-}
-```
-
-Following this run the read-side projection looks good, just as expected:
-
-
-
-### Data Flow
-
-The steps performed by the system in this scenario are illustrated in the following diagram:
-
-
-
-### Scenario B: How to Take a Snapshot of an Aggregate
-
-Snapshots are automated by the Timeline assembly; they are enabled for every aggregate by default, so you don't have to do anything at all to get this working.
-
-In this next test run, the Timeline assembly is configured to take a snapshot after every 10 events. We register a new contact person, then rename him 20 times. This produces a snapshot on event number 20, which is the second-to-last rename operation.
-
-```
-public static void Run(ICommandQueue commander)
-{
- var henry = Guid.NewGuid();
- commander.Send(new RegisterPerson(henry, "King", "Henry I"));
- for (int i = 1; i <= 20; i++)
- commander.Send(new RenamePerson(henry, "King", "Henry " + (i+1).ToRoman()));
-}
-```
-
-As expected, we have a snapshot at version 20, and the current-state projection after event number 21:
-
-
-
-### Scenario C: How to Take an Aggregate Offline
-
-In my solution the terms "boxing" and "unboxing" are used for taking an aggregate offline and bringing it back online.
-
-When you send a command to **box** an aggregate, the Timeline assembly:
-
-1. creates a snapshot; then
-2. copies that snapshot and the entire aggregate event stream to a JSON file stored in a directory on the file system; then
-3. deletes the snapshot and the aggregate from the SQL Server structured log tables.
-
-This makes it a highly destructive operation, of course, and it should never be used except in circumstances where it is a mandatory business/legal requirement.
-
-In the next test run, we register a new contact person, rename him 7 times, then box the aggregate.
-
-```
-public static void Run(ICommandQueue commander)
-{
- var hatter = Guid.NewGuid();
- commander.Send(new RegisterPerson(hatter, "Mad", "Hatter One"));
- for (int i = 2; i <= 8; i++)
- commander.Send(new RenamePerson(hatter, "Mad", "Hatter " + i.ToWords().Titleize()));
- commander.Send(new BoxPerson(hatter));
-}
-```
-
-As you can see, the aggregate no longer exists in the event store, and an offline copy of the final snapshot (along with the entire event stream) has been made on the file system.
-
-
-
-### Scenario D: How to Create a New User With a Unique Login Name
-
-The question I encounter most frequently online from developers trying to understand CQRS+ES is this:
-
-> "How do I enforce referential integrity to guarantee new users have unique login names?"
-
-I asked this same question myself (more than once) in the early days of my research on the CQRS+ES pattern.
-
-A lot of the answers from experienced practitioners look something like this:
-
-> "Your question indicates you do not understand CQRS+ES."
-
-This is true (I realize now) but completely unhelpful, especially to someone who is making an effort to learn.
-
-Some of the answers are slightly better, offering a high-level recommendation in summary form, but loaded with CQRS+ES terminology, which is not always helpful either. One of my favorite recommendations was this (from the good folks at [Edument](https://cqrs.nu/Faq)):
-
-> "Create a reactive saga to flag down and inactivate accounts that were nevertheless created with a duplicate user name, whether by extreme coincidence or maliciously or because of a faulty client."
-
-The first time I read that I had only a vague sense of what it meant, and no idea at all how to begin to implement such a recommendation.
-
-The next test run shows one way (but not the only way) to create a new user with a unique name, using real, working code as an example.
-
-In this scenario, the trick is to realize that you do in fact need a _saga_ (or _process manager_, as I prefer to call it). Creating a new user account is not a single-step operation; it is a process, and therefore requires coordination. The flowchart (or _state machine_, if you prefer) might be very complex in your application, but even in the simplest of all possible cases, it looks something like this:
-
-
-
-The code that relies on a process manager to implement this functionality is shown in the next figure:
-
-```
-public void Run()
-{
- var login = "jack@example.com";
- var password = "Let_Me_In!";
-
- if (RegisterUser(Guid.NewGuid(), login, password)) // succeeds.
- System.Console.WriteLine($"User registration for {login} succeeded");
-
- if (!RegisterUser(Guid.NewGuid(), login, password)) // fails; duplicate login.
- System.Console.WriteLine($"User registration for {login} failed");
-}
-
-private bool RegisterUser(Guid id, string login, string password)
-{
- bool isComplete(Guid user) { return _querySearch.IsUserRegistrationCompleted(user); }
- const int waitTime = 200; // ms
- const int maximumRetries = 15; // 15 retries (~3 seconds)
-
- _commander.Send(new StartUserRegistration(id, login, password));
-
- for (var retry = 0; retry < maximumRetries && !isComplete(id); retry++)
- Thread.Sleep(waitTime);
-
- if (isComplete(id))
- {
- var summary = _querySearch.SelectUserSummary(id);
- return summary?.UserRegistrationStatus == "Succeeded";
- }
- else
- {
- var error = $"Registration for {login} has not completed after
- {waitTime * maximumRetries} ms";
- throw new IncompleteUserRegistrationException(error);
- }
-}
-```
-
-Notice the caller in the example above does not assume synchronous handling of the command StartUserRegistration. Instead, it polls the status of the registration, waiting for it to complete.
-
-Knowing the code in the Timeline assembly is **synchronous**, we can refactor the method RegisterUser so it is even simpler:
-
-```
-private bool RegisterUserNoWait(Guid id, string login, string password)
-{
- bool isComplete(Guid user) { return _querySearch.IsUserRegistrationCompleted(user); }
-
- _commander.Send(new StartUserRegistration(id, login, password));
-
- Debug.Assert(isComplete(id));
-
- return _querySearch.SelectUserSummary(id).UserRegistrationStatus == "Succeeded";
-}
-```
-
-The code for the process manager itself is simpler than you might guess:
-
-```
-public class UserRegistrationProcessManager
-{
- private readonly ICommandQueue _commander;
- private readonly IQuerySearch _querySearch;
-
- public UserRegistrationProcessManager
- (ICommandQueue commander, IEventQueue publisher, IQuerySearch querySearch)
- {
- _commander = commander;
- _querySearch = querySearch;
-
- publisher.Subscribe(Handle);
- publisher.Subscribe(Handle);
- publisher.Subscribe(Handle);
- }
-
- public void Handle(UserRegistrationStarted e)
- {
- // Registration succeeds only if no other user has the same login name.
- var status = _querySearch
- .UserExists(u => u.LoginName == e.Name
- && u.UserIdentifier != e.AggregateIdentifier)
- ? "Failed" : "Succeeded";
-
- _commander.Send(new CompleteUserRegistration(e.AggregateIdentifier, status));
- }
-
- public void Handle(UserRegistrationSucceeded e) { }
-
- public void Handle(UserRegistrationFailed e) { }
-}
-```
-
-There you have a basic, reactive saga that flags inactivate accounts created with a duplicate user name. And there was much rejoicing.
-
-As expected, the first registration succeeds and the second fails:
-
-
-
-### Scenario E: How to Schedule a Command
-
-Scheduling a command to run at a future date/time is easy:
-
-```
-public static void Run(ICommandQueue commander)
-{
- var alice = Guid.NewGuid();
- var tomorrow = DateTimeOffset.UtcNow.AddDays(1);
- commander.Schedule(new RegisterPerson(alice, "Alice", "O'Wonderland"), tomorrow);
-
- // After the above timer elapses, any call to Ping() executes the scheduled command.
- // commander.Ping();
-}
-```
-
-Notice this creates no aggregate in the event log, and the command log now contains a scheduled entry:
-
-
-
-### Scenario F: How to Update Multiple Aggregates With One Command
-
-This is another common question asked by developers who are trying to understand how to implement the CQRS+ES pattern. It is another question I asked (many, many times) when I was learning it myself.
-
-Practitioners often answer by saying:
-
-> "You can't."
-
-This is not enormously helpful.
-
-Some will offer a little more guidance with a statement that goes like this:
-
-> "The factoring of your aggregates and command handlers will make this idea impossible to express in code."
-
-The first several times you read that statement it seems cryptic, and in the end you discover it can be quite helpful for validating your implementation, but in the beginning it isn't super instructive.
-
-More helpful is an example with real, working code, which implements the type of functionality that motivated the question in the first place:
-
-- Suppose I have two bank accounts, each of which is an aggregate root, and I want to transfer money from one account to the other. How do I achieve this using CQRS+ES?
-
-The next test run shows one way (and not the only way) this can be done.
-
-In this scenario, the trick is to realize you need another aggregate root - i.e., a money Transfer, which is not itself an Account - and you _also_ need a process manager to coordinate the workflow.
-
-The simplest possible flowchart is illustrated in the next figure. (An accounting system obviously needs something more sophisticated than this.)
-
-
-
-The code that relies on a process manager to implement the workflow illustrated above is easy, once you have all the pieces in place:
-
-```
-public void Run()
-{
- // Start one account with $100.
- var bill = Guid.NewGuid();
- CreatePerson(bill, "Bill", "Esquire");
- var blue = Guid.NewGuid();
- StartAccount(bill, blue, "Bill's Blue Account", 100);
-
- // Start another account with $100.
- var ted = Guid.NewGuid();
- CreatePerson(ted, "Ted", "Logan");
- var red = Guid.NewGuid();
- StartAccount(ted, red, "Ted's Red Account", 100);
-
- // Create a money transfer for Bill giving money to Ted.
- var tx = Guid.NewGuid();
- _commander.Send(new StartTransfer(tx, blue, red, 69));
-}
-
-private void StartAccount(Guid person, Guid account, string code, decimal deposit)
-{
- _commander.Send(new OpenAccount(account, person, code));
- _commander.Send(new DepositMoney(account, deposit));
-}
-
-private void CreatePerson(Guid person, string first, string last)
-{
- _commander.Send(new RegisterPerson(person, first, last));
-}
-```
-
-After that test executes, Bill's blue account has a balance of $31, and Ted's red account has a balance of $169, as expected:
-
-
-
-The code for the money transfer process manager is not too difficult either:
-
-```
-public class TransferProcessManager
-{
- private readonly ICommandQueue _commander;
- private readonly IEventRepository _repository;
-
- public TransferProcessManager
- (ICommandQueue commander, IEventQueue publisher, IEventRepository repository)
- {
- _commander = commander;
- _repository = repository;
-
- publisher.Subscribe(Handle);
- publisher.Subscribe(Handle);
- publisher.Subscribe(Handle);
- }
-
- public void Handle(TransferStarted e)
- {
- var withdrawal = new WithdrawMoney(e.FromAccount, e.Amount, e.AggregateIdentifier);
- _commander.Send(withdrawal);
- }
-
- public void Handle(MoneyWithdrawn e)
- {
- if (e.Transaction == Guid.Empty)
- return;
-
- var status = new UpdateTransfer(e.Transaction, "Debit Succeeded");
- _commander.Send(status);
-
- var transfer = (Transfer) _repository.Get(e.Transaction).State;
-
- var deposit = new DepositMoney(transfer.ToAccount, e.Amount, e.Transaction);
- _commander.Send(deposit);
- }
-
- public void Handle(MoneyDeposited e)
- {
- if (e.Transaction == Guid.Empty)
- return;
-
- var status = new UpdateTransfer(e.Transaction, "Credit Succeeded");
- _commander.Send(status);
-
- var complete = new CompleteTransfer(e.Transaction);
- _commander.Send(complete);
- }
-}
-```
-
-### Scenario G: How to Implement a Custom Event Handler
-
-In this next example, I demonstrate how to define a custom event handler that is intended for use by one and only one tenant in a multitenant system.
-
-In this scenario, Umbrella Corporation is one of our tenants, and the organization wants all the existing core functionality in our system. However, the company also wants an additional custom feature:
-
-- When a money transfer is started from or to any Umbrella account, if the dollar amount exceeds $10,000, then an email notification must be sent directly to the company owner.
-
-To satisfy this requirement, we implement a process manager for the tenant. The calling code that relies on this process manager is no different than it was in the previous scenario.
-
-```
-public void Run()
-{
- // Start one account with $50,000.
- var ada = Guid.NewGuid();
- CreatePerson(ada, "Ada", "Wong");
- var a = Guid.NewGuid();
- StartAccount(ada, a, "Ada's Account", 50000);
-
- // Start another account with $25,000.
- var albert = Guid.NewGuid();
- CreatePerson(albert, "Albert", "Wesker");
- var b = Guid.NewGuid();
- StartAccount(albert, b, "Albert's Account", 100);
-
- // Create a money transfer for Ada giving money to Albert.
- var tx = Guid.NewGuid();
- _commander.Send(new StartTransfer(tx, a, b, 18000));
-}
-
-private void StartAccount(Guid person, Guid account, string code, decimal deposit)
-{
- _commander.Send(new OpenAccount(account, person, code));
- _commander.Send(new DepositMoney(account, deposit));
-}
-
-private void CreatePerson(Guid person, string first, string last)
-{
- _commander.Send(new RegisterPerson(person, first, last));
-}
-```
-
-Here is a snapshot from the Visual Studio debugger, looking at the code for the process manager, with a breakpoint on the line that sends the email notification. Notice the body of the message in the popup is what we expect:
-
-
-
-### Scenario H: How to Override a Command With a Custom Handler
-
-This final example is a variation on the preceding one. Umbrella Corporation wants to disable a core application feature entirely, and replace it with behavior that is entirely custom. The new business requirement looks like this:
-
-- Changing the name of a contact person in our system is not permitted. Ever.
-
-To satisfy this requirement, we make a few simple changes to the process manager. We add one line of code to the constructor, specifying the override, and we add the replacement function:
-
-```
-public class UmbrellaProcessManager
-{
- private IQuerySearch _querySearch;
-
- public UmbrellaProcessManager
- (ICommandQueue commander, IEventQueue publisher, IQuerySearch querySearch)
- {
- _querySearch = querySearch;
-
- publisher.Subscribe(Handle);
- commander.Override(Handle, Tenants.Umbrella.Identifier);
- }
-
- public void Handle(TransferStarted e) { }
-
- public void Handle(RenamePerson c)
- {
- // Do nothing. Umbrella does not permit renaming people.
-
- // Throw an exception to make the consequences even more severe
- // for any attempt to rename a person...
- // throw new DisallowRenamePersonException();
- }
-}
-```
-
-Here is a basic test run to demonstrate this works as expected:
-
-```
-public static class Test08
-{
- public static void Run(ICommandQueue commander)
- {
- ProgramSettings.CurrentTenant = Tenants.Umbrella;
-
- var alice = Guid.NewGuid();
- commander.Send(new RegisterPerson(alice, "Alice", "Abernathy"));
- commander.Send(new RenamePerson(alice, "Alice", "Parks"));
- }
-}
-```
-
-Notice just one event in the log, and no change to the person's name:
-
-
-
-## Presentation
-
-The presentation layer in the sample application is a console application intended only for writing and running test-case scenarios.
-
-There is nothing here that warrants special attention. You will notice I have not used a third-party component for dependency injection; instead I have written a very basic in-memory service-locator.
-
-This is done only for the sake of keeping the sample application as small and as focused as possible. In your own presentation layer, you'll implement dependency injection in whatever way works best for you, using whatever IoC container you prefer.
-
-## Application
-
-The application layer is divided into two distinct parts: a Write side for commands, and a Read side for queries. This division helps to ensure we don't accidentally mix write-side and read-side functionality.
-
-Notice there are no references to external third-party assemblies here:
-
-
-
-### Write Side
-
-Commands are Plain Old C# Object (POCO) classes, so they can be easily used as Data Transfer Objects (DTOs) for easy serialization:
-
-```
-public class RenamePerson : Command
-{
- public string FirstName { get; set; }
- public string LastName { get; set; }
-
- public RenamePerson(Guid id, string firstName, string lastName)
- {
- AggregateIdentifier = id;
- FirstName = firstName;
- LastName = lastName;
- }
-}
-```
-
-> **Note**: I prefer the term "Packet" to "Data Transfer Object", and I know many readers will object to that, so choose terminology that works for you and your team.
-
-The registration of a command handler method is **explicit** in the constructor for a command subscriber class, and events are published **after** they have been saved to the event store:
-
-```
-public class PersonCommandSubscriber
-{
- private readonly IEventRepository _repository;
- private readonly IEventQueue _publisher;
-
- public PersonCommandSubscriber
- (ICommandQueue commander, IEventQueue publisher, IEventRepository repository)
- {
- _repository = repository;
- _publisher = publisher;
-
- commander.Subscribe(Handle);
- commander.Subscribe(Handle);
- }
-
- private void Commit(PersonAggregate aggregate)
- {
- var changes = _repository.Save(aggregate);
- foreach (var change in changes)
- _publisher.Publish(change);
- }
-
- public void Handle(RegisterPerson c)
- {
- var aggregate = new PersonAggregate { AggregateIdentifier = c.AggregateIdentifier };
- aggregate.RegisterPerson(c.FirstName, c.LastName, DateTimeOffset.UtcNow);
- Commit(aggregate);
- }
-
- public void Handle(RenamePerson c)
- {
- var aggregate = _repository.Get(c.AggregateIdentifier);
- aggregate.RenamePerson(c.FirstName, c.LastName);
- Commit(aggregate);
- }
-}
-```
-
-### Read Side
-
-Queries are POCO classes also, making them lightweight and easy to serialize.
-
-```
-public class PersonSummary
-{
- public Guid TenantIdentifier { get; set; }
-
- public Guid PersonIdentifier { get; set; }
- public string PersonName { get; set; }
- public DateTimeOffset PersonRegistered { get; set; }
-
- public int OpenAccountCount { get; set; }
- public decimal TotalAccountBalance { get; set; }
-}
-```
-
-The registration of an event handler method is also **explicit** in the constructor for an event subscriber class:
-
-```
-public class PersonEventSubscriber
-{
- private readonly IQueryStore _store;
-
- public PersonEventSubscriber(IEventQueue queue, IQueryStore store)
- {
- _store = store;
-
- queue.Subscribe(Handle);
- queue.Subscribe(Handle);
- }
-
- public void Handle(PersonRegistered c)
- {
- _store.InsertPerson(c.IdentityTenant, c.AggregateIdentifier,
- c.FirstName + " " + c.LastName, c.Registered);
- }
-
- public void Handle(PersonRenamed c)
- {
- _store.UpdatePersonName(c.AggregateIdentifier, c.FirstName + " " + c.LastName);
- }
-}
-```
-
-## Domain
-
-The domain contains only aggregates and events. Again, you'll see the list of References here is as bare-metal as possible:
-
-
-
-Each aggregate root class contains a function for each of the commands it accepts as a request to change its state:
-
-```
-public class PersonAggregate : AggregateRoot
-{
- public override AggregateState CreateState() => new Person();
-
- public void RegisterPerson(string firstName, string lastName, DateTimeOffset registered)
- {
- // 1. Validate command
- // Omitted for the sake of brevity.
-
- // 2. Validate domain.
- // Omitted for the sake of brevity.
-
- // 3. Apply change to aggregate state.
- var e = new PersonRegistered(firstName, lastName, registered);
- Apply(e);
- }
-
- public void RenamePerson(string firstName, string lastName)
- {
- var e = new PersonRenamed(firstName, lastName);
- Apply(e);
- }
-}
-```
-
-Notice the aggregate state is implemented in a class that is separate from the aggregate root.
-
-This makes serialization and snapshots easier to manage, and it helps with overall readability because it forces a stronger delineation between command-related functions and event-related functions:
-
-```
-public class Person : AggregateState
-{
- public string FirstName { get; set; }
- public string LastName { get; set; }
- public DateTimeOffset Registered { get; set; }
-
- public void When(PersonRegistered @event)
- {
- FirstName = @event.FirstName;
- LastName = @event.LastName;
- Registered = @event.Registered;
- }
-
- public void When(PersonRenamed @event)
- {
- FirstName = @event.FirstName;
- LastName = @event.LastName;
- }
-}
-```
-
-Events, like commands and queries, are lightweight POCO classes:
-
-```
-public class PersonRenamed : Event
-{
- public string FirstName { get; set; }
- public string LastName { get; set; }
-
- public PersonRenamed(string first, string last) { FirstName = first; LastName = last; }
-}
-```
-
-## Persistence
-
-At the persistence layer, we begin to see a larger number of dependencies on external third-party components. For example, here we rely on:
-
-- [Json.NET](http://json.net/) for JSON serialization and deserialization;
-- [System.Data](http://system.data/) for logging commands and events and snapshots in SQL Server using [ADO.NET](http://ado.net/); and
-- [Entity Framework](https://docs.microsoft.com/en-us/ef) for query projections.
-
-
-
-The source code in this project implements a standard run-of-the-mill data access layer, and there should be nothing in this layer that it is new, or especially innovative, or surprising to any experienced developer - so it needs no special discussion.
-
-## CQRS+ES Backbone
-
-And at long (_long_) last, ladies and gentlemen, comes the part of the evening you've been waiting for: the Timeline assembly that actually implements the CQRS+ES pattern, which makes all of the above possible.
-
-The funny thing is... now that we have arrived at the nuts and bolts, there should be very little mystery remaining.
-
-
-
-The first thing you'll notice is the Timeline assembly has **no** dependencies on external third-party components (besides the .NET Framework itself, obviously).
-
-### Commands
-
-There are just a few things to note here.
-
-The Command base class contains properties for the aggregate identifier and version number, as you'd expect. It also contains properties for the identity of the tenant and user sending the command.
-
-```
-///
-/// Defines the base class for all commands.
-///
-///
-/// A command is a request to change the domain. It is always are named with a verb in
-/// the imperative mood, such as Confirm Order. Unlike an event, a command is not a
-/// statement of fact; it is only a request, and thus may be refused. Commands are
-/// immutable because their expected usage is to be sent directly to the domain model for
-/// processing. They do not need to change during their projected lifetime.
-///
-public class Command : ICommand
-{
- public Guid AggregateIdentifier { get; set; }
- public int? ExpectedVersion { get; set; }
-
- public Guid IdentityTenant { get; set; }
- public Guid IdentityUser { get; set; }
-
- public Guid CommandIdentifier { get; set; }
- public Command() { CommandIdentifier = Guid.NewGuid(); }
-}
-```
-
-The CommandQueue implements the ICommandQueue interface, which defines a small set of methods to register subscribers and overrides, as well as send and schedule commands. You can think of this as the [service bus](https://en.wikipedia.org/wiki/Enterprise_service_bus) for your commands.
-
-
-
-### Events
-
-The Event base class contains properties for the aggregate identifier and version number, as well as properties for the identity of the tenant and user for whom the event was raised/published. This ensures every event log entry is associated with a specific tenant and user.
-
-
-
-You can think of the EventQueue as the service bus for your events.
-
-### Aggregates
-
-There is one small bit of black magic in the AggregateState class. The Apply method uses reflection to determine which method to invoke when an event is applied to the aggregate state. I don't especially like this, but I cannot find any way to avoid it. Fortunately, the code is very easy to read and understand:
-
-```
-///
-/// Represents the state (data) of an aggregate. A derived class should be a POCO
-/// (DTO/Packet) that includes a When method for each event type that changes its
-/// property values. Ideally, the property values for an instance of this class
-/// should be modified only through its When methods.
-///
-public abstract class AggregateState
-{
- public void Apply(IEvent @event)
- {
- var when = GetType().GetMethod("When", new[] { @event.GetType() });
-
- if (when == null)
- throw new MethodNotFoundException(GetType(), "When", @event.GetType());
-
- when.Invoke(this, new object[] { @event });
- }
-}
-```
-
-### Snapshots
-
-The source code to implement Snapshots is cleaner and simpler than I imagined it could be when I first started this project. The logic is somewhat intricate, but the Snapshots namespace contains only ~240 lines of code, so I won't add details on that here. I leave that as an exercise for you, the most patient of readers, if there are any of you still left at this point. :-)
-
-## Metrics
-
-I will close the article with a few basic metrics. (More to come later.)
-
-Here is the analysis report produced by [NDepend](https://www.ndepend.com/) on the Timeline assembly:
-
-
-
-The source code is not perfect, as you can see, but does get an "A" rating, with technical debt estimated at only 1.3%. The project is also very compact, with only 439 lines of code, at the time I write this.
-
-> **Note**: NDepend counts [lines of code (LOC)](https://www.ndepend.com/docs/code-metrics#NbLinesOfCode) from the number of sequence points per method in the .pdb symbol file for an assembly. Visual Studio counts LOC differently; on the Timeline project it reports 1,916 lines of Source code, with 277 lines of Executable code.
-
-When time permits, I plan to update this article with run-time performance results.
-
-## Closing Thoughts
-
-This design and sample implementation demonstrates that building a custom CQRS+ES solution, while requiring careful consideration of trade-offs, can yield significant benefits in terms of readability, performance, and maintainability.
-
-The project's small size, with minimal dependencies, proves that a complex architectural pattern need not be heavyweight or overly prescriptive — and by prioritizing explicit command and event handler registration, native support for multitenancy, process managers, and aggregate lifecycle management, it can establish the foundation for a solution that addresses many real-world challenges that developers encounter when implementing CQRS+ES in a production system.
-
-Of course, none of this source code is intended as a drop-in library. It's only a prototype, intended to serve as a reference for someone embarking on their own CQRS+ES journey.
-
-The clean architecture approach and emphasis on debuggability make this solution particularly suitable for teams that value code clarity and maintainability over framework magic, ultimately supporting the long-term evolution of enterprise systems built on event-driven architectures.
-
-Anyone experienced with CQRS+ES implementations can tell you: it's a non-trivial pattern, and there are thousand ways to get it wrong. If you have thoughts, critiques, or questions about my approach — then please feel free to reach out!
-
-#CQRS #EventSourcing #SoftwareArchitecture #DotNet #SoftwareDesign #EnterpriseArchitecture #DomainDrivenDesign #TechLeadership #BackendDevelopment #DeveloperCommunity
diff --git a/src/data/blog/migrating-from-ghost-to-astro-with-claude-code.md b/src/data/blog/migrating-from-ghost-to-astro-with-claude-code.md
deleted file mode 100644
index 04f1799..0000000
--- a/src/data/blog/migrating-from-ghost-to-astro-with-claude-code.md
+++ /dev/null
@@ -1,51 +0,0 @@
----
-title: We moved this site from Ghost to Astro — in an afternoon, using an AI agent
-author: Daniel Miller
-pubDatetime: 2026-04-30T18:00:00.000Z
-modDatetime: 2026-04-30T18:00:00.000Z
-featured: true
-draft: false
-tags:
- - news
- - software-development
-description: Today we migrated millerdatabases.com from Ghost to a static Astro site, with a Claude Code agent doing most of the keystroking. Here's how it went.
----
-
-If you're a regular reader, you may notice the site looks a little different today. We moved millerdatabases.com from [Ghost](https://ghost.org/) to a static site built with [Astro](https://astro.build/). The content is the same; the plumbing is simpler, faster, and cheaper to operate.
-
-What might surprise you: most of the migration work wasn't done by hand. We handed the job to an AI coding agent — [Claude Code](https://www.anthropic.com/claude-code) — and supervised.
-
-## The procedure, in plain terms
-
-We approached this like any other client engagement. The work broke down into eight phases, each ending in a reviewable commit:
-
-1. **Scaffold.** Stand up a fresh Astro site using the [AstroPaper](https://github.com/satnaing/astro-paper) theme. Verify the empty site builds.
-2. **Build a one-shot migration script.** Read Ghost's JSON export, convert each post's HTML to Markdown, queue every embedded image for download.
-3. **Map the metadata.** Translate Ghost's post fields (title, publish date, tags, feature image) into the frontmatter Astro expects.
-4. **Convert the bodies.** Handle Ghost's custom "card" patterns — code blocks with language hints, image figures with captions, callouts, embeds — so the new Markdown reads cleanly.
-5. **Migrate the images.** Download every Ghost-hosted image to the new repo, rewrite each post to point at the local copy.
-6. **Preserve the URLs.** Move the post route from `/posts//` to `//` so existing links — and Google's index — keep working.
-7. **Wire up deployment.** Add a GitHub Actions workflow that builds and publishes to GitHub Pages on every push, with a `CNAME` for the custom domain.
-8. **Verify.** Build the site clean, check the post count matches the export, spot-check three articles side-by-side with the live Ghost site, validate every internal link.
-
-We wrote the plan first — a single Markdown document — then asked Claude Code to follow it. The agent did the typing: reading the Ghost export, writing the migration script, running it, fixing the broken edges, committing each phase, building, and re-running until everything was green.
-
-Total wall-clock time, from "let's do this" to "site is built and deployed": a few hours. The agent flagged decisions that needed a human (which header text to use, which images had expired signed URLs we'd need to replace by hand) and kept moving on the rest.
-
-## What's under the hood
-
-Every article on this site — including the one you're reading — is a plain [Markdown](https://en.wikipedia.org/wiki/Markdown) file in a Git repository. No database, no admin panel, no login screen. Editing a post is just editing a text file.
-
-When we push a change to the `main` branch, [GitHub Actions](https://github.com/features/actions) automatically builds the site and publishes the new version to [GitHub Pages](https://pages.github.com/). No manual deploy step. No "did I remember to click publish?" The article you're reading went live the same way.
-
-The whole repository is public. If you'd like to see how the site is built, browse the source, or borrow the migration script for your own move off Ghost, the code is at [github.com/miller-databases/website](https://github.com/miller-databases/website). Pull requests welcome.
-
-## Why this matters for our clients
-
-This wasn't a stunt. It was a small, real example of how we're working now.
-
-Miller Databases is increasingly leaning on **agentic programming** — AI agents that don't just suggest snippets but actually execute the boring, structured parts of software work — carefully guided by a senior developer - to deliver faster and at lower cost for our clients. Database migrations, ETL utilities, code analyzers, schema audits, integration scripts: the kind of work that once required a week of typing can now be planned, executed, and reviewed in a fraction of the time.
-
-The role of the consultant doesn't go away. It shifts. We spend less time typing boilerplate and more time on the parts that actually require judgement: understanding the business problem, designing the right approach, and verifying the result.
-
-If you have a database project that's been sitting in the "someday" column because it looked like too much effort, this is a good time to ask us about it.
diff --git a/src/data/blog/structuring-documentation-that-scales.md b/src/data/blog/structuring-documentation-that-scales.md
deleted file mode 100644
index 6bee847..0000000
--- a/src/data/blog/structuring-documentation-that-scales.md
+++ /dev/null
@@ -1,344 +0,0 @@
----
-title: Structuring documentation that scales
-author: Daniel Miller
-pubDatetime: 2025-06-15T14:41:30.000Z
-modDatetime: 2025-06-15T14:41:30.000Z
-featured: false
-draft: false
-tags:
- - software-development
- - process-improvement
-ogImage: ../../assets/images/posts/structuring-documentation-that-scales/documentation.jpg
-description: This article presents the structure for a consolidated documentation portal to support multiple audiences and promote the long-term maintainability of a…
----
-
-This article presents the structure for a consolidated documentation portal to support multiple audiences and promote the long-term maintainability of a large and ever-evolving software system.
-
-## Big systems...
-
-I work on some pretty big systems. [Shift iQ](https://www.shiftiq.com/) is one of them - it's a learning management platform, also known as the Competency Management and Development System ([CMDS](https://www.keyeracmds.com/)) in the Canadian oil and gas industry.
-
-And it is a big system. Of course, "big" is always a relative term, because it begs the question: "big compared to what?"
-
-It's a multitenant platform that manages hundreds of millions of records for tens of thousands of users, working in multiple enterprises with multiple companies comprised of multiple offices, departments, and teams.
-
-The codebase contains over two million lines, implementing functionality in more than twenty integrated application subsystems - including assessments, achievements, registrations, programs, courses, gradebooks, logbooks, surveys, and competency frameworks.
-
-No, it isn't managing trillions of rows of data, and it isn't handling millions of transactions per minute, but - comparatively speaking - it's a big system.
-
-## And a bit of history...
-
-The product was launched in 2010, fifteen years ago, so it is well-established as a mature and proven platform.
-
-As you can imagine, with all its size and history, documentation for the system exists in many different places, authored and managed using many different tools and applications - including (to name just a few) integrated help topics, SharePoint sites, Word and PDF documents, website content management systems (custom, commercial, and open-source), Confluence wikis, Jira support tickets, Excel spreadsheets, YouTube videos, Vimeo clips, OpenAPI specifications, Postman collections, and (of course) developer comments written into the source code.
-
-Several years ago we took the first few steps toward opening the source code. There are countless technical and business advantages to open source. Open source systems promote transparency, flexibility, and community-driven innovation. They allow developers from all over the world to participate in the development, improvement, and quality assurance of the code. They reduce vendor lock-in and lead to more secure and more cost-effective software solutions that evolve and adapt more quickly than closed source systems.
-
-However... before publishing the source code to the world, we need to get a better handle on the documentation! Great documentation is essential for an open source system because it encourages and facilitates adoption by new users and contributors, making the project more accessible and sustainable. Clear and thorough docs enable everyone who is interested in the system to understand it, use it, and build upon it without relying on the original developers - which is key to community growth and long-term success.
-
-### And a little extra rationale...
-
-Open source or closed source, documentation is important. Everyone knows the reasons for this, so rationale doesn't need a lot of discussion or debate. No one with any experience needs a lesson on the benefits of having good documentation, or the risks of missing documentation, or (worse) the dangers of having bad documentation.
-
-Even so, it's worthwhile to mention one thing: Good product documentation is more than just helpful. It's a strategic advantage.
-
-- It empowers users and administrators,
-- reduces support overhead,
-- accelerates developer onboarding, and
-- keeps complex systems maintainable over time.
-
-Clear, well-structured docs bridge the gap between design intent and real-world use, enabling teams to work faster and with greater confidence.
-
-To quote the researchers at Gitbook in their [2025 State of the Docs](https://www.stateofdocs.com/2025/) report:
-
-> Documentation is no longer just a support tool - it's a real business asset. And good documentation doesn't just support a product - it makes the whole experience better, from the moment someone first hears about it, through onboarding, and into advanced usage.
-
-It's also increasingly evident that good documentation improves the scalability (and saleability!) of a software system. It establishes credibility and demonstrates the system is ready for real-world use with a robust and stable foundation.
-
-## Deciding an approach
-
-Content authors tend to be quite fond of the tools they currently use, whatever they are, and if it's possible to avoid too much disruption to that, then it's always a wise approach. This means the consolidation effort needs to be oriented more toward "publication" of content, and less toward "authoring" it.
-
-A consolidated documentation portal needs authoring capabilities, obviously, but it shouldn't prohibit the use of authoring tools outside it, and it needs to support easy navigation to content that might need to be hosted outside it (for whatever reason).
-
-This means we need a documentation platform that is designed - first and foremost - to serve as an information hub.
-
-In the end, with regard to platform, I decided on a two-pronged approach:
-
-1. The website for the product should be the primary starting point for access to all its documentation. Content pages on the site should provide information about the product at a high level, with a focus on promoting its benefits. Blog posts and newsletters should be integral to website, including announcements, release notes, feature highlights, case studies, and so on.
-2. All other documentation related to the product should be managed in, coordinated through, and accessed via a user-friendly and collaborative platform with excellent features for content creation, editing, and sharing.
-
-## Selecting the platform(s)
-
-There is a staggering number of options available today for website content management systems and software documentation portals. In fact, there are so many alternatives that if you dive too deep down the rabbit hole you might never emerge with a selection. The [paradox of choice](https://www.youtube.com/watch?v=VO6XEQIsCoM) can easily paralyze even the very best of us.
-
-So do your own research on this, of course, and find a platform that works for you and your team. But try not to spend too much time on the research. All the best platforms include excellent features that support the export and import of content, so if you select a platform and then later decide another option might be a better fit, then the odds are good you can make the switch if/when it's needed.
-
-In the end I decided on two platforms, rather than one: a website content management system for promotional material (to include blog posts and newsletters), and a documentation system for everything else.
-
-### Content management system
-
-If budget is not a driving constraint then there are many (many!) excellent commercial options. [HubSpot](https://www.hubspot.com/) is certainly a frontrunner in this space. Other great options include [Framer](https://www.framer.com/), [Webflow](https://webflow.com/), [Hashnode](https://hashnode.com/), [YCode](https://www.ycode.com/), [Wix](https://www.wix.com/), and [Squarespace](https://www.squarespace.com/).
-
-If budget is more of a driver, then [Ghost](https://ghost.org/) is a simple, lightweight, budget-friendly, open-source solution for websites, blogs, and newsletters. [WordPress](https://wordpress.org/) is the most popular content management system in the world today, so you really can't go wrong if you select this for a large and/or complex site - especially if your organization has extensive plugin requirements.
-
-HubSpot and Ghost are my personal Top Two favorites here. Budget will decide the winner for our team.
-
-> Static site generators and headless content management systems are growing in popularity. If you're interested (and tech savvy) then you may want to check out tools like [Eleventy](https://www.11ty.dev/), [Strapi](https://strapi.io/), [Contentful](https://www.contentful.com/), [Hygraph](https://hygraph.com/), and [Sanity](https://www.sanity.io/).
-
-### Documentation and knowledge base system
-
-I have a lot of experience with [Confluence](https://www.atlassian.com/software/confluence) (which I love) and [SharePoint](https://support.microsoft.com/en-us/office/what-is-sharepoint-97b915e6-651b-43b2-827d-fb25777f446f) (which I love less), and I hear a lot of great things about [Notion](https://www.notion.com/), but in the end I selected [GitBook](https://www.gitbook.com/) for our documentation portal.
-
-GitBook is a modern platform that enables teams to write, organize, and share knowledge in a clean, collaborative user interface. It supports [Markdown](https://www.markdownguide.org/) and version control, and it integrates very nicely with tools like [GitHub](https://github.com/), which makes it especially ideal for technical documentation and open source projects.
-
-After choosing GitBook, I discovered it is the platform used by the [Linux Foundation](https://docs.linuxfoundation.org/) for its documentation. This bodes well, but time will tell if it is best-suited to the job for which I selected it...
-
-## Structuring the Docs
-
-And now, for those who have powered through my rambling commentary thus far, here are the gritty details (proposed and not yet implemented!) for the structure of our documentation and knowledge base.
-
-At the highest level, the documentation will be structured into seven parts:
-
-1. Website
-2. Guides
-3. Help Topics
-4. Public API Reference
-5. Internal Developer Reference
-6. Infrastructure and Operations
-7. Open Source and Samples
-
-I did not select seven for its esoteric significance, but it is a happy coincidence if you're inclined toward mysticism. (For the benefit of the majority who are probably not: many traditions view 7 as a number of divine perfection and completeness.)
-
-### Outlining the table of contents
-
-The seven parts will be divided into sections, as follows:
-
-**1 - Website**
-
-- Product Information
-- Blog/Newsletter
-- Community Information
-
-**2 - Guides**
-
-- Getting Started
-- Use Cases
-- Best Practices
-- Integration Guides
-
-**3 - Help Topics**
-
-- Troubleshooting
-- Frequently Asked Questions
-- Known Issues
-- Error Codes and Messages
-
-**4 - Public API Reference**
-
-- Overview
-- Authentication and Authorization
-- Endpoints Reference
-- Request and Response Formats
-- Rate Limits and Throttling
-- API Change Log
-- SDKs & Tools
-
-**5 - Internal Developer Reference**
-
-- Code Reference
-- Domain Model Overview
-- Service Architecture
-- Internal APIs
-- Contributor Guide
-
-**6 - Infrastructure and Operations**
-
-- Configuration Management
-- Deployment Pipeline
-- Monitoring and Alerts
-- Disaster Recovery and Backup
-- Scaling and Performance
-
-**7 - Open Source and Samples**
-
-- Quick-Start Samples
-- Demo Web Apps
-- CLI Tools
-- GitHub Repositories
-
----
-
-## More details on the structure
-
-Here is a (tentative) description for each part and section, to help guide and direct the team as we collect and compile our documentation into the structure outlined above.
-
----
-
-## 1 - Website
-
-- **Purpose:** Provide visitors, prospective users, and contributors with general, promotional, and corporate information.
-- **Audience:** Potential customers, partners, developers, media, and casual visitors.
-- **Value:** This section shapes the first impression of the product. It generates and supports interest and awareness.
-
-### Product Information
-
-The website is the starting point and the primary hub to access all product documentation. Content pages describe the system at a high level. Promotional content includes case studies, product overview videos, feature highlights, and FAQs.
-
-### Blog/Newsletter
-
-System updates, product announcements, release notes, feature spotlights, usage tips, and community highlights.
-
-### Community Information
-
-About the community, leadership, contact details, partnership information, and other community/corporate resources.
-
----
-
-## 2 - Guides
-
-- **Purpose:** Help users and developers understand how to get started and use the system effectively.
-- **Audience:** Users, administrators, operators, and developers.
-- **Value:** This section reduces onboarding time and help readers build mental models quickly.
-
-### Getting Started
-
-Includes account creation, workspace setup, initial registration and sign-in, and general configuration settings.
-
-### Use Cases
-
-Step-by-step workflows for solving real business problems using the system, aligned with real-world scenarios.
-
-### Best Practices
-
-Recommendations for scalable and secure implementation, covering architectural patterns, performance tips, and secure configuration.
-
-### Integration Guides
-
-Detailed instructions for connecting with third-party systems, APIs, or other platforms.
-
----
-
-## 3 - Help Topics
-
-- **Purpose:** Provide immediate support for common issues and questions.
-- **Audience:** End users, administrators, developers, and support teams seeking fast answers.
-- **Value:** This section reduces support burden and enables user self-service.
-
-### Troubleshooting
-
-Diagnostic steps and resolutions for common problems, errors, or unexpected behavior.
-
-### Frequently Asked Questions
-
-Straightforward answers to high-frequency user and developer questions.
-
-### Known Issues
-
-Current product limitations, confirmed bugs, and workarounds (as applicable).
-
-### Error Codes and Messages
-
-Catalog of error messages with explanations, causes, and suggested resolutions.
-
----
-
-## 4 - Public API Reference
-
-- **Purpose:** Provide developers with the technical documentation needed to integrate their system with the public APIs.
-- **Audience:** External developers, technical partners, and integration teams.
-- **Value:** This section drives adoption and reduces friction for integrators.
-
-### Overview
-
-Introduction to the API: what it does, how it’s structured, and how to start using it.
-
-### Authentication and Authorization
-
-Guidance on using API tokens, OAuth flows, scopes, and managing client credentials.
-
-### Endpoints Reference
-
-Detailed technical specifcations for all public endpoints, with parameters, examples, and expected responses.
-
-### Request and Response Formats
-
-Conventions for HTTP verbs, pagination, JSON payload structures, status codes, and standard headers.
-
-### Rate Limits and Throttling
-
-Explanation of usage limits, retry behavior, and headers for tracking rate usage.
-
-### API Change Log
-
-Versioned record of updates, deprecations, and important behavioral changes.
-
-### SDKs and Tools
-
-Links to client SDKs, code generators, and Postman/Insomnia collections to test and explore the API.
-
----
-
-## 5 - Internal Developer Reference
-
-- **Purpose:** Expose internal system architecture and implementation details to development and engineering teams.
-- **Audience:** Internal developers, technical leads, QA engineers, and contributors.
-- **Value:** This section enables maintainability, onboarding, and internal knowledge sharing.
-
-### Code Reference
-
-Docs auto-generated from source code using DocFX, including all interfaces, classes, methods, and properties.
-
-### Domain Model Overview
-
-Explanation of core business entities and how they relate.
-
-### Service Architecture
-
-System diagrams and descriptions of services, inter-service communication, and boundaries.
-
-### Internal APIs
-
-Documentation of internal-only REST endpoints used across services.
-
-### Contributor Guide
-
-Instructions for local development environment setup, branching strategy, code style, tests, and CI/CD pipeline contributions.
-
----
-
-## 6 - Infrastructure and Operations
-
-- **Purpose:** Document operational procedures and infrastructure configuration.
-- **Audience:** DevOps engineers, site reliability engineers, platform engineers, and those responsible for deployment and system health.
-- **Value:** This section supports smooth deployment, reliability, disaster readiness, and long-term scalability.
-
-### Configuration Management
-
-Details about managing environment-specific configurations, secret storage, feature flags, etc.
-
-### Deployment Pipeline
-
-Overview of CI/CD workflows, staging/production releases, and rollback procedures.
-
-### Monitoring and Alerts
-
-Dashboards, logs, thresholds, and incident response procedures using the observability stack.
-
-### Disaster Recovery and Backup
-
-Backup strategies, restore procedures, and disaster recovery playbooks.
-
-### Scaling and Performance
-
-Guidance on system performance tuning, load testing tools, and scaling strategies for high availability.
-
----
-
-## In closing...
-
-Whew, that was a much longer article than I planned. If you made it all the way through then I'll say what Stephen King sometimes says in the afterword to his books: "Thank you, gentle reader."
-
-If you have indeed read this article from start to finish, then I expect you care about communication, in its written form, as deeply as I do - and I'd welcome your feedback on the structure I have presented.
-
-I'm committed to making the results of our documentation initiative as helpful, accurate, and comprehensive as possible. I'll post updates periodically, to let you know how it goes.
diff --git a/src/data/blog/the-28-principles-of-attraction.md b/src/data/blog/the-28-principles-of-attraction.md
deleted file mode 100644
index 71aa0e5..0000000
--- a/src/data/blog/the-28-principles-of-attraction.md
+++ /dev/null
@@ -1,130 +0,0 @@
----
-title: The 28 principles of attraction
-author: Daniel Miller
-pubDatetime: 2025-05-23T01:25:00.000Z
-modDatetime: 2025-05-23T01:25:00.000Z
-featured: false
-draft: false
-tags:
- - business-philosophy
-ogImage: ../../assets/images/posts/the-28-principles-of-attraction/attraction.png
-description: Attraction isn't about luck or charm - it's about alignment. In his book, The Portable Coach, Thomas Leonard lays out a bold, practical framework for…
----
-
-Attraction isn't about luck or charm - it's about alignment. In his book, [_The Portable Coach_](https://www.amazon.ca/Portable-Coach-Strategies-Business-Personal/dp/0684850419), [Thomas Leonard](https://en.wikipedia.org/wiki/Thomas_J._Leonard) lays out a bold, practical framework for creating a life so compelling that success and opportunity are naturally drawn to it.
-
-Here is the list of foundational principles of attraction, as Leonard saw them, with a particular thematic emphasis on clarity, integrity, simplicity, and energy.
-
-When these elements are in place, attraction becomes less of a mystery and more of a system: one you can deliberately design.
-
-#### 1\. Become incredibly selfish
-
-Without you, there is nothing, and attraction isn't possible.
-
-#### 2\. Unhook yourself from the future
-
-Attraction works in the present, not in the future.
-
-#### 3\. Overrespond to every event
-
-By over-responding instead of overreacting, you evolve, which is very attractive.
-
-#### 4\. Build a super-reserve in every area
-
-Having enough is not nearly enough for you to be irresistibly attractive.
-
-#### 5\. Add value just for the joy of it
-
-When you add value because you enjoy it, people are naturally attracted to you.
-
-#### 6\. Affect others profoundly
-
-The more you touch others, the more attractive you'll become.
-
-#### 7\. Market your talents shamelessly
-
-If you're embarrassed about what you do well, you won't be very attractive.
-
-#### 8\. Become irresistibly attractive to yourself
-
-How can you attract others if you don't feel irresistibly attractive to you?
-
-#### 9\. Get a fulfilling life, not just an impressive lifestyle
-
-A great life is attractive; a lifestyle is usually seductive.
-
-#### 10\. Deliver twice what you promise
-
-When you consistently deliver more than was expected, new customers are drawn to you.
-
-#### 11\. Create a vacuum that pulls you forward
-
-Being pulled forward is attractive; pushing forward is not.
-
-#### 12\. Eliminate delay
-
-Time is expensive and thus is very unattractive.
-
-#### 13\. Get your personal needs met, once and for all
-
-If you have unmet needs, you'll attract others in the same position.
-
-#### 14\. Thrive on the details
-
-Subtleties, details and nuances are more attractive than the obvious.
-
-#### 15\. Tolerate nothing
-
-When you put up with something, it costs you. Costs are expensive and thus unattractive.
-
-#### 16\. Show others how to please you
-
-Don't make them guess.
-
-#### 17\. Endorse your worst weaknesses
-
-When you can accept and honor the worst part of yourself, you are more accepting of others.
-
-#### 18\. Sensitize yourself
-
-The more you feel, the more you'll notice and respond to the many opportunities in the present.
-
-#### 19\. Perfect your environment
-
-The attraction OS is a sophisticated system that requires a first-class environment.
-
-#### 20\. Develop more character than you need
-
-Integrity is not enough to become irresistibly attractive.
-
-#### 21\. See how perfect the present really is
-
-Especially when it is clearly not.
-
-#### 22\. Become unconditionally constructive
-
-High levels of respect are very attractive.
-
-#### 23\. Orient exclusively around your values
-
-When you spend your days doing what fulfills you, you are attractive.
-
-#### 24\. Simplify everything
-
-Abandoning the non-essentials leaves more room for you to attract.
-
-#### 25\. Master your craft
-
-Being the best at what you do is the easiest way to become successful.
-
-#### 26\. Recognize and tell the truth
-
-The truth is the most attractive thing of all, but it requires skills and awareness.
-
-#### 27\. Have a vision
-
-When you can see what's coming, you don't need to create a future.
-
-#### 28\. Be more human
-
-When you are genuine, you are attractive.
diff --git a/src/data/blog/the-copilot-delusion.md b/src/data/blog/the-copilot-delusion.md
deleted file mode 100644
index b30b1b7..0000000
--- a/src/data/blog/the-copilot-delusion.md
+++ /dev/null
@@ -1,22 +0,0 @@
----
-title: The Copilot Delusion
-author: Daniel Miller
-pubDatetime: 2025-06-21T22:56:00.000Z
-modDatetime: 2025-06-21T22:56:00.000Z
-featured: false
-draft: false
-tags:
- - software-development
-ogImage: ../../assets/images/posts/the-copilot-delusion/copilot-delusion.png
-description: I enjoy watching chess grandmasters who stream their games online. It is especially fascinating when they encounter an opponent who tries to win by cheating…
----
-
-I enjoy watching chess grandmasters who stream their games online.
-
-It is especially fascinating when they encounter an opponent who tries to win by cheating with an AI engine, because a grandmaster always recognizes the difference in gameplay between a human and a machine. A grandmaster's commentary on this sort of thing can sometimes become very colorful – and it is always entertaining.
-
-Writers and developers who have achieved a certain level of mastery in their craft are no different in this regard. If you decide to use an AI agent to cheat in your own writing – in word or in code – then just remember: they'll always know.
-
-Jj writes a _fantastic_ article on this, and I enjoyed it immensely.
-
-[The Copilot Delusion](https://deplet.ing/the-copilot-delusion/)
diff --git a/src/data/blog/the-high-cost-of-low-software-estimates.md b/src/data/blog/the-high-cost-of-low-software-estimates.md
deleted file mode 100644
index db5b904..0000000
--- a/src/data/blog/the-high-cost-of-low-software-estimates.md
+++ /dev/null
@@ -1,40 +0,0 @@
----
-title: The high cost of low software estimates
-author: Daniel Miller
-pubDatetime: 2025-05-21T12:44:31.000Z
-modDatetime: 2025-05-21T12:44:31.000Z
-featured: false
-draft: false
-tags:
- - process-improvement
-ogImage: ../../assets/images/posts/the-high-cost-of-low-software-estimates/high-cost-of-low-estimates-1.png
-description: When you plan the cost and effort for a new software development project, there is often a lot of motivation (some of it good, some of it bad) to…
----
-
-When you plan the cost and effort for a new software development project, there is often a lot of motivation (some of it good, some of it bad) to under-estimate.
-
-The stronger the temptation seems, the more important it becomes for you to resist that temptation, because estimating too low can ruin your schedule and destroy your budget.
-
-It's not what you'd expect, but estimating too high is an excellent way to manage and minimize risk, helping to ensure the project's success.
-
-Here's the reason why:
-
-Estimates at the beginning of a software project are rarely accurate, because everyone's knowledge of the project is limited.
-
-- Stakeholders don't yet have a complete (or necessarily correct) understanding of business requirements for the system to be developed.
-- The project team does not yet have full and complete technical specifications.
-- Developers might not yet know everything they need to know about the domain and environment in which the solution will operate.
-
-Building software is a process of continuous refinement and improvement. A well-run project tackles the areas of highest variability first, to eliminate uncertainties as quickly as possible. Ideally, your estimate for a software project is allowed to evolve along with the software itself.
-
-And remember: the potential for an exponential overrun on cost and/or schedule increases the lower you set your targets.
-
-On the other hand, when targets are set too high, even in a worst-case scenario the probability of an overrun is linear (_not exponential_).
-
-In other words, your risk/reward and cost/benefit ratios are much better for an over-estimate than they are for an under-estimate.
-
-
-
-An accurate estimate is always best, of course, but an estimate that is too low can be much worse for your bottom line, so if you need to err on one side or the other, then you are better off to estimate high.
-
-As the old saying goes, "Always hope for the best, but prepare for the worst."
diff --git a/src/data/draft/appsettings-json-in-asp-net-web-forms.md b/src/data/draft/appsettings-json-in-asp-net-web-forms.md
deleted file mode 100644
index a9f89bc..0000000
--- a/src/data/draft/appsettings-json-in-asp-net-web-forms.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: appsettings.json in ASP.NET Web Forms
-author: Daniel Miller
-pubDatetime: 2025-08-29T02:46:56.000Z
-modDatetime: 2025-08-29T02:46:56.000Z
-featured: false
-draft: true
-tags:
- - others
-description: (draft — no description yet)
----
-
-_Draft body is empty in the Ghost export._
diff --git a/src/data/draft/database-column-size-provisioning.md b/src/data/draft/database-column-size-provisioning.md
deleted file mode 100644
index 7bc5fc2..0000000
--- a/src/data/draft/database-column-size-provisioning.md
+++ /dev/null
@@ -1,80 +0,0 @@
----
-title: Database Column Size Provisioning
-author: Daniel Miller
-pubDatetime: 2025-06-20T03:44:58.000Z
-modDatetime: 2025-06-20T03:44:58.000Z
-featured: false
-draft: true
-tags:
- - others
-description: Currently, the database for the Shift iQ platform contains 3,976 columns in 214 tables. Here is a summary of the number of columns that store each type of…
----
-
-Currently, the database for the Shift iQ platform contains 3,976 columns in 214 tables. Here is a summary of the number of columns that store each type of data:
-
-
Data Type
# of Columns
bigint
3
binary
1
bit
208
date
24
datetime
9
datetime2
2
datetimeoffset
296
decimal
62
float
54
int
369
money
3
numeric
3
nvarchar
71
tinyint
3
uniqueidentifier
834
varbinary
1
varchar
2033
-
-The database contains 2,104 columns that store text data (varchar and nvarchar). Of these, 301 columns are defined as varchar(max) or nvarchar(max), which means they are configured to store unlimited text.
-
-> **VARCHAR** uses a single-byte character set, meaning it can store characters from a single language or script. **NVARCHAR** uses Unicode, allowing it to store characters from multiple languages and scripts.
-
-In the past we have not monitored the use of max columns, because the size of the database has not required us to impose strict limits on them. However, the database has grown large enough that this now poses performance and scalability concerns, especially with the increasing number of active concurrent users. Therefore, we need to begin actively monitoring and limiting the use of max columns in the database.
-
-Here is a brief technical summary of the reasons to avoid varchar(max) when possible:
-
-- A varchar(max) column cannot be included as a key column in any database indexes.
-- In order to store large text values, varchar(max) columns use LOB\_DATA allocation units, which are much, **much (!)** slower than using IN\_ROW\_DATA storage allocation units.
-- LOB\_DATA storage does not support page and row compression.
-
-Here is a more detailed explanation of the risks and potential problems associated with using varchar(max):
-
-**Performance Issues**:
-
-- Query Performance: varchar(max) columns negatively impact query performance, especially when dealing with large volumes of data. These columns are stored out-of-row when they exceed 8,000 bytes, requiring additional I/O operations to retrieve the data they contain.
-- Indexing: Indexing varchar(max) columns is problematic because the database cannot fully index them in same way that it can index all other data types, limiting the effectiveness of indexes and slowing the performance of queries that include them.
-
-**Storage Considerations**:
-
-- Storage Efficiency: Using varchar(max) leads to inefficient storage usage. SQL Server allocates additional space for varchar(max) columns, which may not be used, leading to wasted storage.
-- Data Pages: When varchar(max) data exceeds 8,000 bytes, SQL Server stores the data on separate pages. This separation increases the number of data pages that need to be read during queries, which degrades performance.
-
-**Memory Usage**:
-
-- Memory Allocation: Queries that include varchar(max) columns consume more memory, impacting overall system performance. SQL Server may need to allocate larger buffers to handle varchar(max) columns, reducing the memory available for other operations.
-
-**Data Integrity and Maintenance**:
-
-- Data Validation: Defining specific lengths for varchar columns helps to enforce data integrity and validation. varchar(max) lacks constraints, making it harder to ensure consistent data entry.
-- Maintenance: Managing and maintaining databases with varchar(max) columns is more challenging. Tasks such as backups, restores, and index maintenance take longer and require more resources.
-- Efficiency: Limiting text based on the expected size of the data helps to optimize storage and performance. Specifying a reasonable length for varchar columns allows SQL Server to allocate storage more efficiently and better optimize its queries on stored data values.
-
-## Provisioning Best Practices
-
-- Use varchar(max) only when the length of a single value is expected to exceed 8K (i.e., 8000 characters). Otherwise, use nvarchar(limit) where "limit" is a reasonable constraint on the expected size of the values to be stored in the column
-- Use nvarchar only when you need to store characters from multiple languages and character sets.
-- Use nvarchar(max) only when the length of a single value is expected to exceed 4K (i.e., 4000 characters). Otherwise, use nvarchar(limit) where "limit" is a reasonable limit on the expected size of the values to be stored in the column.
-- Never define multiple varchar(max) columns in the same database table. If there is a legitimate system requirement to store more than 8K in a varchar column (or more than 4K in an nvarchar column) then your schema should be designed so that no database table contains more than one such column.
-- When using varchar(limit) and nvarchar(limit), set a realistic limit that is based on expected usage. The SQL Server query optimizer expects values in such a column have an average length that is limit \* 0.5, therefore it is important to select a realistic limit for performance reasons, in addition to data integrity reasons.
-- A column that stores a single email address must be varchar(254). Refer to [https://www.directedignorance.com/blog/maximum-length-of-email-address](https://www.directedignorance.com/blog/maximum-length-of-email-address)
-- A column that stores a single URL must be varchar(2000). Refer to [https://stackoverflow.com/questions/417142/what-is-the-maximum-length-of-a-url-in-different-browsers](https://stackoverflow.com/questions/417142/what-is-the-maximum-length-of-a-url-in-different-browsers)
-
-## Immediate Next Steps
-
-1. Analyze the existing data in every database table, including all five enterprise partitions (E01-E05).
-2. For every varchar column, determine the length of the largest value currently stored in the database.
-3. Calculate an optimum limit based on the largest existing value:
- 1. Round up to the nearest 100 characters.
- 2. Add 20 percent.
-4. If the optimum limit is less than 8K then replace varchar(max) with varchar(limit) using the calculated optimum. Otherwise, leave the column defined as varchar(max).
-5. Repeat steps 2, 3, and 4 for every nvarchar column and use a 4K threshold.
-6. Ensure every column that stores an email address is varchar(254).
-7. Ensure every column that stores a URL is varchar(2000).
-8. Write a SQL Upgrade script to update the database schema with the new limits.
-9. Update the Entity Configuration classes in the data access layer with the new limits.
-10. Update any MaxLength attribute values in the UI with the new limits.
-
-## Future Next Steps
-
-- Implement a new feature that allows a survey administrator to specify the maximum number of characters permitted in a question used to collect text input from respondents. Make this a required setting with a warning displayed to the administrator if they input a value larger than 4000.
- - Based on existing responses to the annual NCSHA agency surveys, set a realistic maximum limit on the number of characters permitted in each of the questions.
-- Other next steps, to be determined.
diff --git a/src/data/draft/login-401.md b/src/data/draft/login-401.md
deleted file mode 100644
index 844acca..0000000
--- a/src/data/draft/login-401.md
+++ /dev/null
@@ -1,47 +0,0 @@
----
-title: Login 401
-author: Daniel Miller
-pubDatetime: 2025-08-29T02:45:28.000Z
-modDatetime: 2025-08-29T02:45:28.000Z
-featured: false
-draft: true
-tags:
- - others
-description: I use IPBan to detect and prevent brute force attacks. It works by analyzing IIS logs for 4xx error codes. Edit Ah, that changes things! If you're using…
----
-
-I use IPBan to detect and prevent brute force attacks. It works by analyzing IIS logs for 4xx error codes.
-
-Edit
-
-Ah, that changes things! If you're using IPBan to detect brute force attacks by monitoring 4xx status codes in IIS logs, then **yes, you should return 401** for invalid login credentials.
-
-**Why 401 makes sense in your setup:**
-
-- IPBan can automatically detect failed login attempts via 401 responses
-- No need for custom application-level logging or rate limiting
-- Leverages existing infrastructure for security monitoring
-- Provides automated IP blocking without additional code complexity
-
-**Recommended approach with IPBan:**
-
-```
-POST /login with invalid credentials
-→ 401 Unauthorized + login form + "Invalid credentials" message
-```
-
-**IPBan benefits:**
-
-- Automatic detection of brute force patterns
-- Configurable thresholds and ban durations
-- Works at the network level (more effective than app-level blocks)
-- Monitors all 4xx codes, so covers various attack vectors
-
-**Additional considerations:**
-
-- Still use generic error messages to prevent username enumeration
-- Consider logging successful logins as well for audit trails
-- Monitor IPBan's ban list to ensure legitimate users aren't blocked
-- Test that 401 responses still render your login page properly
-
-This is a good example of how architectural decisions (using IPBan) can influence HTTP status code choices. The 401 response serves dual purposes: semantic correctness for failed authentication AND triggering your security monitoring system.
diff --git a/src/data/draft/the-missing-term-in-software-documentation-why-we-need-contributor-apis.md b/src/data/draft/the-missing-term-in-software-documentation-why-we-need-contributor-apis.md
deleted file mode 100644
index 4ae2c84..0000000
--- a/src/data/draft/the-missing-term-in-software-documentation-why-we-need-contributor-apis.md
+++ /dev/null
@@ -1,71 +0,0 @@
----
-title: 'The Missing Term in Software Documentation: Why We Need "Contributor APIs"'
-author: Daniel Miller
-pubDatetime: 2025-08-04T21:33:11.000Z
-modDatetime: 2025-08-04T21:33:11.000Z
-featured: false
-draft: true
-tags:
- - others
-description: 'Building with us vs. building on us Every software team knows the pain: you''re onboarding a new engineer, and they spend hours digging through scattered…'
----
-
-_Building with us vs. building on us_
-
-Every software team knows the pain: you're onboarding a new engineer, and they spend hours digging through scattered documentation trying to understand how to actually modify the system. They find plenty of external API docs, but where's the internal architecture reference? The deployment guides? The service interaction patterns?
-
-This documentation exists, of course—it's just hiding under vague names like "internal docs" or "technical specifications." Meanwhile, our external-facing API documentation has a clear, universally understood name: the **Developer API**.
-
-## The Problem We All Face
-
-Here's the reality: every software system has two distinct API audiences, but we only have clear terminology for one of them.
-
-**Developer APIs** serve external developers who want to integrate with our system. These docs focus on endpoints, authentication, rate limits, and use cases. They're polished, stable, and designed for consumption.
-
-But what about the other API—the one that explains how to contribute to the system itself? The internal interfaces, deployment procedures, database schemas, and architectural decisions that enable someone to extend, modify, or maintain the platform?
-
-This critical documentation usually gets buried under generic labels, making it nearly impossible for new team members (or even experienced ones) to quickly find what they need.
-
-## A Simple Solution: Contributor APIs
-
-I propose we adopt the term **Contributor API** for internal technical documentation aimed at those who build _on_ the system rather than _with_ it.
-
-This terminology is particularly powerful in today's development landscape:
-
-• **Open source alignment**: The term "contributor" is already well-established in GitHub workflows and open-source communities • **Clear audience distinction**: It immediately signals whether docs are for external integration or internal development • **Semantic precision**: It clarifies the fundamental difference between consumption and contribution
-
-## Why This Matters
-
-When we distinguish between Developer APIs and Contributor APIs, we're not just organizing documentation—we're creating clarity around two fundamentally different workflows:
-
-**Developer APIs** emphasize stability, ease of integration, and external use cases. They're about building _with_ your system.
-
-**Contributor APIs** document implementation details, architectural decisions, and modification workflows. They're about building _on_ your system.
-
-This distinction helps teams:
-
-- Reduce onboarding friction for new engineers
-- Prevent confusion between external and internal documentation
-- Create clearer information architecture
-- Align with established open-source terminology
-
-## The Broader Impact
-
-Better internal documentation isn't just about individual productivity—it's about organizational resilience. When contributor knowledge is well-documented and easily discoverable, teams can:
-
-- Scale more effectively
-- Reduce bus factor risks
-- Enable faster feature development
-- Improve system maintainability
-
-## Making the Change
-
-Adopting this convention is straightforward: audit your existing internal technical documentation and reorganize it under the "Contributor API" umbrella. Create clear navigation paths that distinguish between resources for external developers and internal contributors.
-
-The terminology alone won't solve documentation problems, but it provides a framework for thinking more clearly about your documentation architecture and its intended audiences.
-
-* * *
-
-What terminology does your team use for internal technical documentation? Have you found effective ways to organize contributor resources? I'd love to hear about your approaches in the comments.
-
-#SoftwareDevelopment #Documentation #API #TechnicalWriting #EngineeringCulture
diff --git a/src/env.d.ts b/src/env.d.ts
deleted file mode 100644
index 43bdae4..0000000
--- a/src/env.d.ts
+++ /dev/null
@@ -1,9 +0,0 @@
-interface Window {
- theme?: {
- themeValue: string;
- setPreference: () => void;
- reflectPreference: () => void;
- getTheme: () => string;
- setTheme: (val: string) => void;
- };
-}
diff --git a/src/layouts/AboutLayout.astro b/src/layouts/AboutLayout.astro
deleted file mode 100644
index f9e3665..0000000
--- a/src/layouts/AboutLayout.astro
+++ /dev/null
@@ -1,24 +0,0 @@
----
-import type { MarkdownLayoutProps } from "astro";
-import Header from "@/components/Header.astro";
-import Footer from "@/components/Footer.astro";
-import Breadcrumb from "@/components/Breadcrumb.astro";
-import Layout from "./Layout.astro";
-import { SITE } from "@/config";
-
-type Props = MarkdownLayoutProps<{ title: string }>;
-
-const { frontmatter } = Astro.props;
----
-
-
-
-
-
-
-
- Working notes on database administration, performance tuning, and the
- software practices that keep data systems healthy. Written from the seat
- of a practicing consultant — what we tried, what broke, what we'd do
- differently.
-
-
- Browse the
-
- posts
- or get in touch at
- daniel@millerdatabases.com
- .
-
- {
- // only display if at least one social link is enabled
- SOCIALS.length > 0 && (
-