All articles

  1. Development & automation

    Before Design Patterns: How Software Engineering Learned to Manage Complexity

    From Lovelace's Notes of 1843 to Brooks's essay of 1986, each advance in programming removed a difficulty of the tools and left the difficulty of the problem. One pricing routine, written three ways with identical output, shows what structure and names buy and what they do not.

    ·17 min read

    Keep reading →
  2. Development & automation

    Structured Programming, Modularity and Information Hiding

    Structured control flow, procedures, modules, information hiding, coupling, cohesion and separation of concerns are separate ideas from separate authors. The same pricing rules, cut as functions and then as modules, show what Parnas's criterion localises and what it does not.

    ·19 min read

    Keep reading →
  3. Development & automation

    Object-Oriented Programming: Origins, Promises and Trade-offs

    Object orientation is several mechanisms with separate origins: Simula's subclasses, abstract data types, Smalltalk's messaging. One pricing example shows what encapsulation and an interface buy, what they cost, and when functions over plain data stay the better design.

    ·16 min read

    Keep reading →
  4. Development & automation

    The Gang of Four: 23 Design Patterns and the Problems They Solve

    The 23 patterns of the 1994 book, each as a problem, a shape, a cost and its modern C# form, in one pricing example. Most are a single move, an interface placed where something varies, and the example needed only one of them.

    ·31 min read

    Keep reading →
  5. Development & automation

    SOLID, Coupling, Cohesion and Dependency Inversion

    Coupling and cohesion are the criteria; the five SOLID principles are later heuristics with separate origins in Meyer, Liskov and Martin. One pricing calculator shows what each buys and costs, and why dependency inversion, dependency injection and a container are three different things.

    ·23 min read

    Keep reading →
  6. Development & automation

    Refactoring: Improving Design Without Changing Behaviour

    Refactoring changes structure against a recorded definition of behaviour, in steps small enough to check. One legacy pricing method is pinned by characterisation tests, reshaped in seven steps, and the tests themselves are proved able to fail.

    ·22 min read

    Keep reading →
  7. Development & automation

    From Design Patterns to Domain-Driven Design and Modern Architecture

    Domain-driven design, ports and adapters, the onion and the clean architecture share one rule: the business rules refer to nothing else. The pricing example gains a domain model and a tested boundary, and needs 22 types where one class did.

    ·20 min read

    Keep reading →
  8. Development & automation

    Do We Still Need Gang of Four Patterns in Modern C# and .NET?

    All 23 patterns set against C# 14 and .NET 10: eleven have a shorter form in the example, built from a language or platform feature, and twelve do not. The problems remain in every case, and each modern form has a failure of its own.

    ·25 min read

    Keep reading →
  9. Governance & security

    Automatic external forwarding in Exchange Online: three controls, and one value that tells you nothing

    Whether mail can leave a Microsoft 365 organisation by automatic forwarding is decided by three separate controls, and the default value of the first one means On in some tenants and Off in others. How to read each control with PowerShell, how to find the mailboxes that forward today, and how to block forwarding with named exceptions.

    ·7 min read

    Keep reading →
  10. Development & automation

    A green gate did not make the release deployable

    A release of this site passed every check in its release gate and was refused by the deployment client before a single file was uploaded. What the gate proved, what only the platform's own validator decides, and how a test written from the same assumption as the code it tests agreed with an error instead of finding it.

    ·7 min read

    Keep reading →
  11. Governance & security

    Documentation is a claim until the system is read against it

    A configuration document governs a Microsoft 365 or Azure estate only while it is bound to the system it describes: an owner, a documented reading of the actual state, a comparison and a date to read it again. What NIST SP 800-53 and Microsoft's guidance ask of documentation, how Compliance Manager keeps a recorded status apart from a read one, and three Microsoft 365 settings where the document and the tenant can disagree unnoticed.

    ·12 min read

    Keep reading →
  12. Development & automation

    A readiness probe that checks the database

    A probe answers one question for one consumer, and a probe that checks a shared database turns the database's failure into every instance's failure at once. What Azure App Service and Kubernetes do with that answer, how ASP.NET Core keeps liveness and readiness apart, and what we would check on each probe.

    ·12 min read

    Keep reading →
  13. Azure & Cloud

    What a slot swap promises, and what it abandons

    A deployment slot swap warms the new version, moves production traffic to it without dropping requests, and keeps the old version one swap away. It does not protect the work running on the old instances, stop timers and WebJobs running in both slots, carry the identity and some settings across, or undo on the way back what the new version wrote.

    ·12 min read

    Keep reading →
  14. Development & automation

    Writing to two systems is not a transaction

    An application that saves one change in two systems has two outcomes, and nothing commits them together. What Microsoft's architecture guidance says about why the copies drift apart, where a transaction across two systems does exist, and what makes the result recoverable: one record of the change, delivered at least once to a consumer that ignores repeats, and compensation for what cannot be derived.

    ·15 min read

    Keep reading →
  15. Development & automation

    A retry that sends a POST twice

    A client that never received the response cannot know whether its create was applied, and a retry can write the record twice. What HTTP allows a client to repeat, which Microsoft 365 failures mean the write was refused, where integrations inherit retries they did not write, and how to make a SharePoint or Graph create safe to repeat.

    ·15 min read

    Keep reading →
  16. Development & automation

    The green test that measured nothing

    A test suite can be green because the system works, or green because the test points at nothing. We collected our own specimens: a suite verifying a build nobody shipped, a read-only gate over a collector that could not load, a published guarantee table that never executed, a pinned assertion that was a fossil of a bug, and a suite that proved every rule and never ran the handler. Each one with the code, and the one-line question that catches all five.

    ·7 min read

    Keep reading →

Categories

Send us a message

or write to hello@ph7x.com