Architecture

My trade. Apparently. What is architecture anyway? Well, that could be the subject of a while heap of blog posts, but the essence is in considering the wider context of solutions, data, protocols, technologies and standards and how they interact. Teams can do all this on their own, of course, but they tend to not have the necessary context, skills or experience to lead decisions in larger operations.

May 24th, 2019

Architecture patterns to support incremental change

People tend to see architectural change as a big transactional effort, so if any mistakes are made they tend to be huge mistakes. It is better to focus on delivering smaller changes that can demonstrate incremental value.

April 14th, 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.

February 24th, 2019

Should teams choose their own languages and tools?

Standardisation does have a place, but it should be reserved for infrastructure and collaboration rather than languages and tools.

January 6th, 2019

Finding service boundaries: more than just the bounded context

When you are identifying service boundaries, it’s not enough to consider the domain model alone. There are other, more pragmatic concerns to bear in mind.

November 27th, 2018

Writing ArchUnit style tests for .Net and C# to enforce architecture rules

ArchUnit is a java library that provides a fluent API for creating self-testing architectures via unit tests. A similar library can be written for .Net Standard that acts on compiled assemblies rather than raw code.

October 12th, 2018

Message design anti-patterns for 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…

August 12th, 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.

July 29th, 2018

Autonomous bubbles and event streams: Pragmatic approaches to working with legacy systems

It’s easy to get caught up in unrealistic notions that you can re-write a legacy system or gradually decompose it. There are other, more pragmatic approaches that can help to modernise architectures and enable new development.

July 10th, 2018

Kafka on Azure Event Hub – does it miss too many of the good bits?

Microsoft have added a Kafka façade to Azure Event Hubs, presumably in the hope of luring Kafka users onto its platform. This makes sense as the platforms have a lot in common, though there are some missing Kafka features that may prove critical.

June 18th, 2018

Using architectural “fitness functions” as a guide to system design

Fitness functions can be a useful metaphor for guiding an emerging architecture, but you do have to invest in making sure they describe the right outcome.

June 3rd, 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.

May 8th, 2018

How to decompose that monolith into microservices. Gently does it…

You’re rarely given the opportunity to focus on transitioning an architecture to the exclusion of everything else. You may have to get used to the idea that decomposing a monolith is a direction of travel rather than a clear destination.

March 9th, 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.

February 16th, 2018

Relax. There’s no conflict between architecture and agile.

Agile teams still need to make architecture decisions, but in supporting them architects should seek “just enough” architecture over “big design up front” and practical solutions over large-scale abstract thinking.

January 27th, 2018

Can TOGAF and Agile really go together?

On the face of it, TOGAF describes a very different world to the agile preference for working software over documentation. That doesn’t mean that TOGAF is incompatible with agile, so long as you’re prepared to adapt its numerous building blocks.

December 13th, 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.

December 3rd, 2017

Automating Docker image deployments using Azure Container Instances

Azure’s Container Instances provides an easy and quick way to run Docker images without having to learn the various complexities of orchestration platforms such as Kubernetes.

November 4th, 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.

October 12th, 2017

What should a Scaled Agile “architectural runway” actually look like?

The Scaled Agile Framework talks about an “architectural runway” as the main deliverable for agile architecture, yet it’s vague on the detail of what this looks like.

September 20th, 2017

How can Domain Driven Design help with large scale agile development?

Agile teams spend time modelling software whether they are prepared to admit it or not. Adopting a technique like Domain Driven Design can help to make this more efficient, particularly at scale.

July 5th, 2017

Writing unit tests for Azure Functions using C#

You can now write compiled Azure functions in C# with full unit test coverage, though there are a few obstacles along the way.

June 4th, 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.

May 16th, 2017

API management and the return of the enterprise service bus

No self-respecting integration platform is complete without an API management story these days. Is this just a RESTful return of the enterprise service bus?

April 3rd, 2017

Architectural governance can be used to foster innovation. No, really.

Governance doesn’t have to be all about byzantine process and suffocating approval boards. It can be used to provide clear permission for teams to innovate.

January 28th, 2017

Why agile software architects should write code

No architect will ever admit to being out of touch with software development. However, unless you are writing code then it’s difficult to avoid becoming an “ivory tower” or “PowerPoint” architect that can only discuss systems in the abstract.

January 7th, 2017

Event stores and event sourcing: some practical disadvantages and problems

Event stores and event sourcing are a powerful idea, but they can be vulnerable to a number of technical and operational challenges when faced with real world complexity.

October 27th, 2016

The problem with using maturity models to describe technology solutions

Maturity models are a management tool. When applied to technology solutions they often provide a weak analysis that describes a false progression.

July 29th, 2016

Designing an event store for scalable event sourcing

Event sourcing can scale very nicely, though this does depend on a number of key design decisions for the underlying event store.

June 28th, 2016

Should microservices share technologies and platform capabilities?

Should agile teams be encouraged to share capabilities or be given total autonomy over their technology choices? For larger organisations this can become a trade-off between economies of scale and speed of delivery.

June 2nd, 2016

Is “Serverless” architecture just a finely-grained rebranding of PaaS?

Serverless computing makes bold promises of development without having to worry about environments, scaling or deployment. Haven’t we been here before?

April 14th, 2016

What do we actually mean when we say “business logic”?

In most cases “business logic” just refers to the poorly-defined “gloop” that sits between user interfaces and databases in layered architectures.

March 23rd, 2016

API gateways and the dangers of creeping middleware scope

An API gateway can solve many generic problems in an API infrastructure, but you do need to define a clear remit and protect against creeping scope.

February 1st, 2016

Data design for event-driven architecture: autonomy, encapsulation and ordering

When you’re implementing an event-driven architecture, the design of your events is absolutely critical to realize the benefits of loose coupling.

November 26th, 2015

Comparing nServiceBus and MassTransit: Do we still need .Net integration frameworks?

Both nServiceBus and Mass Transit plugged an important gap in Microsoft’s integration landscape, but do they have a role in a future that is likely to be dominated by diverse technologies and autonomous agile teams?

August 11th, 2015

Most software architecture diagrams are useless

The best architecture diagrams act as a map – if an architect can’t express a system clearly and concisely then they probably don’t understand it properly.

July 25th, 2015

Can cross-cutting concerns really exist between services?

You might be able to identify cross-cutting concerns in a monolith, but in a service-orientated world they should melt away into specific implementations.

July 2nd, 2015

Comparing Gartner’s cloud integration leaders: Informatica, Dell Boomi and Mulesoft

Gartner’s definition of enterprise integration as a service is so wide that it can be difficult to draw any meaningful comparisons between the platforms in the “leaders” space.

May 5th, 2015

Refactoring large monoliths to microservices: strategies, risks and pragmatic reality

Large scale rewrites of systems are loaded with risk. You can address this by preparing the ground in advance and adopting an incremental approach, but a willingness to be pragmatic is essential.

April 6th, 2015

Using logstash, ElasticSearch and log4net for centralized logging in Windows

The ability to collate and interrogate your logs is an essential part of any distributed architecture. This generally involves stitching together different technologies via configuration.

March 20th, 2015

Azure Search is not ElasticSearch “in the cloud”

Azure Search may be based on ElasticSearch but it’s an abstraction that exposes a very different API – the underlying engine is almost incidental.

March 9th, 2015

How big is a microservice?

We know that micro services are small and focused by design – just how small is this in practice?

January 4th, 2015

Why REST is not a silver bullet for service integration

REST is sometimes described as the next “evolutionary step” in service integration. The problem is that REST provides too much of a “dumb pipe” to support genuinely decoupled, fault-tolerant service integration.

December 16th, 2014

Don’t assume message ordering in Azure Service Bus

Azure Service Bus can provide first-in-first-out messaging in theory, but this is not the same as guaranteeing the order in which your messages are processed.

September 9th, 2014

CQRS is a state of mind rather than a cookie-cutter design pattern

CQRS is based on the simple notion that you use a different model to update information than the one to read it. This does not necessarily have to give rise to the same solution every time.

July 9th, 2014

The problem with tiered or layered architecture

An architecture based on tiers or layers is too inflexible to deal with the more flexible demands of modern systems, particularly when you working with high-volume systems that require distributed processing.

June 12th, 2014

Are microservices just SOA “done properly”?

There’s nothing really new about many of the ideas that underpin microservices. Are they just an agile re-branding of SOA?

May 4th, 2014

Eventual consistency and the trade-offs required by distributed development

Developers who have been brought up on the certainties of ACID transactions often have a problem trusting eventual consistency. Once you start exploring the requirements in more depth this really so much of a handicap.

April 21st, 2014

Hackable URIs may look nice, but they don’t have much to do with REST and HATEOAS

Structured and “Hackable” URIs are a staple part of SEO-friendly websites. Although developers generically expect to see them in HTTP-based APIs, they should be irrelevant to consumers of a fully RESTful API that leverages HATEOAS.

March 12th, 2014

What role do architects have in agile development?

Agile principals encourage self-organising teams to take ownership of solutions. This doesn’t leave architects out in the cold, but it does require a more engaged role based on influence rather than governance.

February 21st, 2014

Lean development’s “last responsible moment” should address uncertainty, not justify procrastination

Deferring decisions to the “last responsible moment” can help you to adapt to the inevitable uncertainty that comes with agile development. The risk is that it can become an excuse for uncertainty that undermines development velocity.

February 6th, 2014

Comparing Web API 2 and WCF for building services on HTTP and REST

On the face of it, Microsoft took WCF’s promise of “one implementation, any protocol” and shot it in the head with ASP.NET Web API. Now that the Web API has matured a little it is easier to see them as complimentary technologies that deliver very different types of service.

January 13th, 2014

Identifying the sources of system coupling in service orientated architectures

Every system has some level of coupling. After all, systems need to collaborate and in doing so they will inevitably share some characteristics of language and behaviour. It’s important to recognise where coupling occurs and the impact it has on stability and flexibility.

November 24th, 2013

Set up a federated identity provider on Azure using Active Directory and ADFS 2.0

Azure’s Active Directory Premium service is an increasingly compelling solution for cloud-based identity management. However, if you want control over the login experience or branding then you will have to consider setting up your own identity store. This can still be done in Azure by setting up Active Directory and ADFS 2.0 on a virtual machine.

October 19th, 2013

Can APX help in developing usable and accessible APIs?

Given how important APIs have become in driving the reach of applications and services, it’s surprising how little investment is made in the usability of APIs as opposed to UIs. Perhaps the principals and techniques used by UX should be applied to developing more effective APIs…

September 23rd, 2013

Memory leaks in .Net applications. Yes – they happen all the time…

The promise of garbage collection can lull .Net developers into a false sense of security. They are still vulnerable to memory leaks and have a responsibility to keep an eye on what’s going on under the hood.

July 16th, 2013

Managing change and version control for service interfaces

Change is an inevitable and even desirable part of distributed development. Managing the impact of that change is the difficult part, particularly when change affects the service interfaces that bind a distributed platform together.

June 17th, 2013

Netflix has abandoned OData – does the standard have a future without an ecosystem?

Netflix have closed their OData catalogue and EBay seem to have quietly put their implementation out to grass. With a shrinking ecosystem and no marquee services, does Microsoft’s data standard have a future?

June 4th, 2013

Sharing APIs in an organisation: challenges and pitfalls

Sharing services and APIs can appeal to a desire to reduce duplication and improve development efficiency. It’s a worthy ambition though the journey there can be littered with costly traps for the unwary.

March 16th, 2013

Using asynchronous log4net appenders for high performance logging

Log4net provides decent logging performance out of the box, but you’ll need to consider asynchronous appending if you want more serious throughput or logging to a shared resource.

February 22nd, 2013

A shared database is still an anti-pattern, no matter what the justification

Shared databases risk turning into performance bottlenecks that encourage close-coupling and create a single point of failure. There’s no justification for using them to integrate processes and applications.

January 8th, 2013

Build vs Buy decisions and the importance of context

Technology decisions should not be made in isolation, particularly when you are trying to weigh up building a solution or buying a third party platform.

December 17th, 2012

REST services may not have standards, but they should follow conventions

REST is more of an architectural style than a set of standards. That said, a service should follow certain conventions if it is to be predictable and simple to work with.

November 6th, 2012

Are CRUD methods what we really want from a repository?

CRUD-based repositories may appear convenient but they can make for poor service interfaces as well as giving rise to a lot of unnecessary boiler-plate code.

September 3rd, 2012

How to manage down the payments on your technical debt

Technical debt may be a great metaphor to describe the corrosive effect of quick and dirty design decisions, but it can be difficult to identify, measure and manage.

July 2nd, 2012

How not to use dependency injection: service locators and injection mania.

Development teams can struggle with dependency injection, often because they don’t have a clear understanding of how best to use it.

April 30th, 2012

Why refactoring code is almost always better than rewriting it

Developers and architects like to build things, so their initial impulse is often to flatten the place, lay some stronger foundations and build something impressive. It can be difficult to get them excited about incremental innovation, even when this is generally the most sensible approach from both a technical and commercial perspective.

April 11th, 2012

The code reuse myth: why internal software reuse initiatives tend to fail

Despite all the best intentions, software reuse tends to be confined to third party frameworks and tools rather than being an integral part of the development process. Are we expecting too much from software reuse and should we learn to set our sights a little lower?

January 8th, 2012

Entity Framework anti-patterns: How not to use an ORM with SQL Server

The Entity Framework has come a long way since its earliest incarnations prompted a vote of no confidence from the development community. However, like any data access technology, there are still a number of traps for the unwary – particularly if you’re using it in a tiered application.

September 9th, 2011

EPiServer CMS anti-patterns: common mistakes in development projects

EPiServer is a great CMS but like all platforms it has a number of traps for the unwary and inexperienced.

July 3rd, 2011

Why you should never use a proof of concept in development projects

A proof of concept is often proposed as a way to quickly demonstrate viability. In most cases it does nothing of the sort and merely delivers a quick hack that can undermine good system design.

November 10th, 2010

ORM wars: Comparing nHibernate, LINQ To SQL & the Entity Framework

Ted Neward described ORM as the “vietnam of computer science” in that it’s a quagmire that starts well, gets more complicated as time passes and ends up as an open-ended commitment with poorly-defined goals and no clear exit strategy.

June 15th, 2010

Converting EPiServer 6 to use claims-based authentication with WIF

Converting an EPiServer site to become claims-aware is straightforward enough – the complications come when you try to use the editor and administration interfaces.