In the first post in this series (table of contents) I explained why agile software development influences the choice of the UI design pattern. For short, changeability and extensibility are must have characteristics.

In this post, I’ll show you the corner stones of a UI design pattern that fulfills these needs.

Principles of Object Oriented Software Design – SOLID

One of the best known set of principles to achieve my goal of a UI design pattern that is changeable and extensible is SOLID by Robert C. Martin (link).

If you don’t already know those principles then please follow the above link and read it before continuing here.

The principle I’m most interestes at the moment is the S in SOLID, the Single responsibility principle:
A class should have one, and only one, reason to change.

.NET, Agile, Architecture .NET, Agile, Architecture, Design, User Interface

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.

.NET, Agile, Architecture .NET, Agile, Architecture, Design, User Interface

The Model View View-Model pattern gained a lot of momentum lately. It allows to reduce the code in the code behind class of a form or user control to a minimum. Therefore, unit testability is improved dramatically compared to other view patterns like MVC/MVP.

However, when I design software, I follow (amongst others) the principles of SOLID (link).

The first principle in SOLID is the Single Responsibility Prinicple (SRP) that states that “A class should have one, and only one, reason to change.” (link)

And here start my concerns about MVVM.

.NET, Architecture .NET, Architecture, Design, Passive View Command, Patterns, Unit Test, unit testing

These are my personal top ten of software design evilness. That means ten designs that make your software either complex, untestable, monolithic, unchangeable or hard to understand:

1. Singletons
2. Enums (or other c# enumeration equivalents)
3. Swallow exceptions
4. God classes
5. Missing interface segregation
6. Monster classes
7. Too configurable, too flexible
8. Abstraction layers not providing additional abstraction
9. Try catch for program flow control
10. Missing logging

Architecture, Software Architecture, Design, Patterns, principles

I’m often hearing thoughts about Test Driven Development from people not using it, which are not true (at least not 100%).

Therefore, I want to describe some of these myths here:

• Writing unit tests is difficult and complex
• Projects take longer because of the additional test code that has to be written
• Not everything can be tested with unit tests. Therefore TDD cannot be used.
• There is no need for architecture and design because TDD claims to evolve that from tests

Methodology, Software, Test Driven Development Architecture, Design, Myths, TDD, Test Driven Development, Unit Test

Yesterday, I found an interesting page (in German) describing some of the most important patterns and practices in software development: http://www.clean-code-developer.de/

Although I’m not a fan of wrist bands (see the linked page to see for yourself), I like the page for its short description of patterns and practices like:

• Don’t repeat yourself
• keep it simple stupid
• single responsibility pattern
• separation of concerns
• interface segregation principle
• dependency injection principle
• Liskov substitution principle
• open close principle
• law of Demeter
• principle of least astonishment
• you ain’t gonna need it
• use a version control system
• issue tracking
• continuous integration
• automated tests
• mocking
• code coverage
• test first
• reviews
• and some more

Architecture, Software Architecture, Clean Code, Design, Development, Patterns, Practices