SOA

26 January 2020

Running serverless containers in AWS Fargate, Google Cloud Run and Azure

“Serverless” containers could help you to avoid the complexity of Kubernetes, but you may struggle to leverage them for anything beyond small, predictable workloads or batch jobs.

14 December 2019

When should you write your own message endpoint library?

Enterprise messaging patterns are complex beasts that often warrant a common implementation across your endpoints. Should you ever be tempted to roll your own?

17 November 2019

There’s more to publishing external APIs than choosing an API management vendor

Publishing a public API involves many considerations, from billing and metering through to documentation and on-boarding. These are likely to be addressed through a collection of solutions rather than a single all-singing, all-dancing API management platform.

21 April 2019

Optimizing Performance of the Azure Service Bus .Net Standard SDK

Microsoft have published advice for maximising performance with Azure Service Bus, but there doesn’t appear to be any explicit advice for optimising the newer .Net Standard based SDK.

14 April 2019

Why is loose coupling between services so important?

You can’t eliminate coupling between collaborating services, but you can ensure that it doesn’t prevent you from enjoying the benefits of service-based development.

28 October 2018

Why isn't WCF supported in .Net Core?

Development shops that have invested heavily in WCF have been left high and dry by the emerging .Net Core ecosystem. There are a number of good reasons why WCF for .Net Core is unlikely to make it onto any official roadmaps…

12 October 2018

Messaging anti-patterns in event-driven architecture

Event-driven integration can improve the scalability, resilience and scalability of distributed applications… but this does depend on the design of your event messages…

12 September 2018

Hosting .Net Core containers in Service Fabric

Service Fabric does support container-based applications, but it still feels more like an application server than a container orchestrator.

12 August 2018

Building Twelve Factor Apps with .Net Core

Twelve factor apps provide a methodology for building apps that are optimised for modern cloud environments. It’s only been achievable in the Microsoft world since the advent of .Net Core.

3 June 2018

Layers, onions, hexagons and the folly of application-wide abstractions

Not only are layered applications difficult to maintain, but the common abstractions they are built on tend to give rise to inflexible implementations that have serious scalability challenges.

20 March 2018

GraphQL will not solve your API design problems

If you find REST APIs difficult to design, develop and scale, then your experience with GraphQL is not going to be any easier.

9 March 2018

Microservice preconditions: what needs to be in place before you decompose that monolith...

One of the main benefits of microservices is that they reduce the cost of change. The problem is that you need to make a significant up-front investment to realise this saving. Your first few microservices are more likely to be an expensive and potentially painful undertaking.

13 December 2017

Entity services: when microservices are worse than monoliths

Finely-grained, entity-based services seem to be advocated by some pretty authoritative sources. This is unfortunate as they are something of an anti-pattern that can undermine many of the benefits of decomposing an monolith into micoservices.

4 November 2017

Events, sagas and workflows: managing long-running processes between services

An event-driven architecture can give rise to complex chains of events that are difficult to manage. These problems can be mitigated through careful design rather than resorting to shared state databases or workflow engines.

4 June 2017

Can consumer-driven contracts manage breaking change in microservice integrations?

One of the more enduring problems with service integration is managing change in service interfaces. Consumer-driven contracts can help to detect breaking changes, but this visibility comes at a price.