Agile UI Development in .NET: Introduction

There are a lot of patterns available for UI architecture: Model-View-Presenter (MVP), Model-View-Controller (MVC), Passive View, Model View View-Model (MVVM) and some more.

However, none does really fit my needs in an agile project.

In this series, I’ll show you first why they don’t work for me and then I’ll try to evolve a pattern that matches the special needs in agile software development.

Why is Agile Software Development different?

In agile development, we start little and add small parts to evolve a complete application. This approach allows us to deliver every sprint (= iteration in Scrum terminology; 2 weeks in our case) a working software and  to get early feedback from our customer.

When we start a project, we don’t have a complete requirement specification (nor do we want one). The requirements (or user stories in Scrum) evolve together with the software: appetite comes with eating. The requirements get clearer and more precise as we learn more about what the software has to do and how we can implement them providing best user experience.

What are the Consequences of Agile Software Development?

We start with minimal requirements and get a first running application as soon as possible to start the feedback loop and refinement of requirements.

The consequences are that the chosen UI design pattern has to allow fast setup, easy changeability and extensibility.

Easy changeability is important because the feedback on the software will result in changes to the existing code. Sometimes, this changes are very dramatic because whole screens are turned up-side-down. Therefore, the chosen UI design pattern has to be very changeable in order not to slow our development down.

Easy extensibility is important because we want to add piece by piece to the software. Every step has to be a working version of the software. We gather feedback on every step to steer where to go next. That means, the UI design pattern has to support adding functionality piece by piece and should not break when complexity grows from very simple to simple to quite complex and finally to complex.

Conclusions

Agile software development has its own requirements for an UI design pattern: changeability and extensibility.

Only if we choose a pattern that guarantees changeability and extensibility throughout the whole life cycle of the project then we can keep our development pace at a high level. A high pace is the basis to keep in touch with the needs of the customer and a short enough reaction time to maximize the Return-On-Investment of our customer.

See table of contents for following posts.