Index of all articles

This is an alphabetical list of every article in the site.

A shared database is still an anti-pattern, no matter what the justification (22 February 2013)

A simple (yeah, right...) guide to using Redux with React.js (12 February 2017)

Agile metrics. You get what you measure. In a bad way. (12 August 2019)

Agile velocity is not a measure of productivity (12 August 2013)

API gateways and the dangers of creeping middleware scope (23 March 2016)

API management and the return of the enterprise service bus (16 May 2017)

Architectural governance can be used to foster innovation. No, really. (3 April 2017)

Architecture without documentation is incomplete (17 October 2020)

Are CRUD methods what we really want from a repository? (6 November 2012)

Are microservices just SOA done properly”? (12 June 2014)

Autonomous bubbles and event streams: Pragmatic approaches to working with legacy systems (29 July 2018)

Azure Data Factory and the myth of the code-free data warehouse (4 July 2019)

Build vs Buy decisions and the importance of context (8 January 2013)

Building Twelve Factor Apps with .Net Core (12 August 2018)

Building your own in-house technology radar (20 November 2020)

Can APX help in developing usable and accessible APIs? (19 October 2013)

Can consumer-driven contracts manage breaking change in microservice integrations? (4 June 2017)

Can cross-cutting concerns really exist between services? (25 July 2015)

Can TOGAF and Agile really go together? (27 January 2018)

Comparing Gartner’s cloud integration leaders: Informatica, Dell Boomi and Mulesoft (2 July 2015)

Comparing nServiceBus and MassTransit: Do we still need .Net integration frameworks? (26 November 2015)

Comparing serverless C# and .Net development using Azure Functions and AWS Lambda (26 May 2017)

Custom token authentication in Azure Functions (18 December 2018)

Data design for event-driven architecture: autonomy, encapsulation and ordering (1 February 2016)

Deploying a Windows Service remotely with Powershell (12 June 2015)

Designing an event store for scalable event sourcing (29 July 2016)

Do you really need Kubernetes? (22 April 2020)

Does code quality matter? Using SonarQube with legacy code bases (22 July 2019)

Don’t assume message ordering in Azure Service Bus (16 December 2014)

Don’t use test coverage as a target (19 February 2020)

Entity services: when microservices are worse than monoliths (13 December 2017)

Estimation pitfalls: Why software development estimates are so difficult (3 February 2011)

Event stores and event sourcing: some practical disadvantages and problems (7 January 2017)

Events, sagas and workflows: managing long-running processes between services (4 November 2017)

Eventual consistency and the trade-offs required by distributed development (4 May 2014)

Finding service boundaries: more than just the bounded context (6 January 2019)

Forget code coverage – test design should be driven by behaviours (19 December 2016)

GraphQL will not solve your API design problems (20 March 2018)

Hackable URIs may look nice, but they don’t have much to do with REST and HATEOAS (21 April 2014)

Handling Protocol Buffers backwards compatibility between versions 2 and 3 using C# (13 November 2016)

Here's the truth about CMS selection: It doesn't really matter... (27 March 2014)

Hosting .Net Core containers in Service Fabric (12 September 2018)

How big is a microservice? (9 March 2015)

How can Domain Driven Design help with large scale agile development? (20 September 2017)

How do you foster technical excellence in an agile development culture? (22 May 2016)

How I learned to love the “Agile Industrial Complex” (30 August 2018)

How not to use dependency injection: service locators and injection mania. (2 July 2012)

How to decompose that monolith into microservices. Gently does it… (8 May 2018)

How to manage down the payments on your technical debt (3 September 2012)

How to write useful .NET and C# coding standards (15 October 2010)

If “Enterprise Architecture” is failing, what should architects be doing instead? (11 March 2020)

Informatica Cloud development best practices (18 January 2016)

Is “Serverless” architecture just a finely-grained rebranding of PaaS? (2 June 2016)

Kafka on Azure Event Hub – does it miss too many of the good bits? (10 July 2018)

Layers, onions, hexagons and the folly of application-wide abstractions (3 June 2018)

Lean development’s “last responsible moment” should address uncertainty, not justify procrastination (21 February 2014)

Machine learning models in production: the maths is the easy part (15 May 2019)

Managing and throttling serverless scaling with Azure Functions (3 October 2017)

Managing change and version control for service interfaces (16 July 2013)

Managing services that don’t have clear code ownership (5 May 2016)

Memory leaks in .Net applications. Yes - they happen all the time… (23 September 2013)

Messaging anti-patterns in event-driven architecture (12 October 2018)

Messaging shouldn’t be used for queries (21 August 2014)

Microservice preconditions: what needs to be in place before you decompose that monolith... (9 March 2018)

Microservices, REST and the distributed big ball of mud (20 April 2015)

Migrating .Net framework applications to .Net Core (9 August 2016)

Monorepos. For when life isn’t already complicated enough. (22 June 2019)

Most software architecture diagrams are useless (11 August 2015)

Naming things is easy. Abstraction is much harder. (13 June 2020)

Netflix has abandoned OData – does the standard have a future without an ecosystem? (17 June 2013)

Now that Kubernetes is on Azure, what is Service Fabric for? (9 February 2019)

Optimising bulk inserts with Entity Framework (26 June 2014)

Optimizing Performance of the Azure Service Bus .Net Standard SDK (21 April 2019)

PolyBase import and export between Azure SQL Data Warehouse and Blob Storage (13 August 2016)

Pragmatic REST: APIs without hypermedia and HATEOAS (12 December 2015)

Refactoring large monoliths to microservices: strategies, risks and pragmatic reality (5 May 2015)

Relax. There’s no conflict between architecture and agile. (16 February 2018)

REST APIs don’t need a versioning strategy - they need a change strategy (27 September 2015)

REST services may not have standards, but they should follow conventions (17 December 2012)

Running a .Net Core console application as a Windows Service (3 September 2017)

Running serverless containers in AWS Fargate, Google Cloud Run and Azure (26 January 2020)

Sharing APIs in an organisation: challenges and pitfalls (4 June 2013)

Sharing code between geographically distributed development teams (15 January 2013)

Sharing libraries between .Net Core and .Net Framework applications (10 March 2017)

Sharing microservices across large organisations (8 March 2019)

Should microservices share technologies and platform capabilities? (28 June 2016)

Should teams choose their own languages and tools? (24 February 2019)

Splitting up shared databases (6 October 2019)

Swagger is not WSDL for REST. It’s much less useful than that… (14 August 2017)

Technical debt is an overused and lazy metaphor (18 November 2017)

Ten myths about Quality Assurance in software development (29 December 2011)

The case against maturity models (8 June 2019)

The code reuse myth: why internal software reuse initiatives tend to fail (11 April 2012)

The generic repository is just a lazy anti-pattern (21 May 2013)

The poor man’s Cassandra: scaling Azure Table Storage to maximise throughput. (22 July 2017)

The problem with GUIDs… (3 October 2014)

The problem with the .Net Standard compatibility shim… (12 January 2018)

The problem with tiered or layered architecture (9 July 2014)

The RESTafarian flame wars – common disagreements over REST API design (22 November 2014)

There’s more to publishing external APIs than choosing an API management vendor (17 November 2019)

Using a tolerant reader for web service integrations in .Net (22 July 2014)

Using architectural “fitness functions” as a guide to system design (18 June 2018)

Using asynchronous log4net appenders for high performance logging (16 March 2013)

Using Docker to build and deploy .Net Core console applications (12 April 2017)

What do we actually mean when we say business logic? (14 April 2016)

What makes a REST API mobile-friendly? (25 April 2018)

What role do architects have in agile development? (12 March 2014)

What should a Scaled Agile “architectural runway” actually look like? (12 October 2017)

What we talk about when we talk about “legacy” software (22 July 2020)

What’s in a name? Three-lettered acronyms and their impact on development culture (20 September 2016)

What’s so bad about monoliths anyway…?! (3 October 2016)

When does refactoring become rewriting? (19 June 2017)

When is an event not an event? (8 February 2020)

When should you write your own message endpoint library? (14 December 2019)

Why agile software architects should write code (28 January 2017)

Why is loose coupling between services so important? (14 April 2019)

Why isn't WCF supported in .Net Core? (28 October 2018)

Why refactoring code is almost always better than rewriting it (30 April 2012)

Why REST is not a silver bullet for service integration (4 January 2015)

Why SAFe can be agile kryptonite (23 March 2019)

Why trunk-based development isn’t for everybody (9 September 2019)

Writing a brokered messaging client for Azure Service Bus that is production-ready (22 April 2013)

Writing ArchUnit style tests for .Net and C# to enforce architecture rules (27 November 2018)

Writing unit tests for Azure Functions using C# (5 July 2017)

“Goldilocks” governance: balancing team autonomy and alignment for agile architecture (24 August 2020)