Nothing matches your search.
All articles
- 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.
Keep reading → - 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.
Keep reading → - 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.
Keep reading → - 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.
Keep reading → - 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.
Keep reading → - 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.
Keep reading → - 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.
Keep reading → - 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.
Keep reading → - 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.
Keep reading → - 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.
Keep reading → - 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.
Keep reading → - 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.
Keep reading → - 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.
Keep reading → - 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.
Keep reading → - 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.
Keep reading → - 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.
Keep reading →
Categories
- Keep reading →
AI & agents
6 - Keep reading →
Azure & Cloud
4 - Keep reading →
Company
1 - Keep reading →
Development & automation
24 - Keep reading →
Governance & security
8 - Keep reading →
Microsoft 365 & SharePoint
3 - Keep reading →
Migrations
5
Send us a message
or write to hello@ph7x.com