These are the slides along with some comments from a presentation I gave lately in the bbv .Net System boot camp – the yearly education week of my division in my company.

Once upon a time, Agile Software development came to our software development country.

Like a monster, Agile software methodologies scared the hell out of us. Suddenly, we had to find ways how to build software so that we could keep up with the high rate of change, just-in-time requirements and a sacrificial offering – a product increment – every two weeks (our Sprint length).

The way we were used to build software was not up to this task. We were used to dig a big hole of new functionality and to build something great over months. The structure of our source code and our engineering practices were no good to match the Agile monster.

So we had to come up with some new “weapons” to stand a chance:

Agile, Architecture, Methodology Agile, Architecture, ATDD, Design, DI, DRY, SOLID, TDD

Updated: new version available!

I have compiled two cheat sheets about clean code (the ones mentioned in my post about Code Quality!).

The first covers clean code – code that is easy readable and keeps changeable. The second is about Test Driven Development. Both cheat sheets list principles, patterns, practices and smells.

You can download them here – Clean Code Cheat Sheet V1.3, Clean TDD Cheat Sheet V1.2.

Take a look!

I’d like to read your feedback in the comments section…

(just an unreadable preview    – click on link in text above)

.NET, Agile, Test Driven Development .NET, Architecture, Clean Code, Design, TDD, Test Driven Development, unit testing

This is the slide deck of my LAS 2010 presentation: From user stories to architecture.

Agile, Architecture, Methodology, Presentation Agile, Architecture, Design, Presentation, scrum

Updated: Something went wrong with the code snippets. Now it’s okay.

Today, we”l have a look at nested views in my series on agile UI development in .NET using an extended MVVM pattern (table of contents).

There are two kinds of nested views:

• contextually nested views and
• hierarchically nested views (master-detail scenarios)

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

In my series on agile UI development in .NET, we have seen quite a lot so far (table of contents). But up to now, we never made a call to the model (business logic, services and so on). This is the topic of this post: Model Commands.

A Model Command encapsulates a single action hat is execute against the model. This can be a query to request data, an action that modifies data, communication with a completely different part of the system or anything else your application has to do on the model.

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

Next in my series (table of contents) on agile UI development in .NET is the presenter. The presenter is responsible to drive the UI workflow. This means that the presenter is the control center to react to:

• events from the model. For example that data has changed.
• events from embedded presenters
• calls from parent presenter
• calls from UI commands

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

In this post, we are going to have a look at UI commands. UI commands are responsible for reacting to user input, for example the send button click in the sample I use throughout this series of agile user interface development in .NET series. For other posts in this series look here: table of contents.

We have seen in the last post that the view binds a command to the send button that it gets from the view-model:

<Button Command="{Binding SendMessageCommand}" IsDefault="True">Send</Button>

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

Last time we started looking at sample code with the view-model class for the UI to send messages on channels (table of contents).

In this post, we continue with the next responsibility, the visualization.

The View

The view is responsible for visualizing the domain model to the user. We have seen in the last post that the view-model provides a simplified mini-model to the view. That means that the view does not have to care about the domain model as a whole with all its interactions and constraints. The view-model provides only the part of the domain model that is relevant to the current screen the user is seeing thus simplifying the job of the view.

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

After the posts (table of contents) in which I covered why we need an agile UI design pattern, it’s big picture and the needed tools, I start digging into sample code. I’ll show in each post a small part of the whole picture. If you want to get all at once then you find the source of all samples at http://sourceforge.net/projects/procollee. ProCollEE is my playground to experiment with WPF and UI design.

Lets start

Yes, let’s start. But where?

There is one UI design pattern – presenter first (link) – that explicitly states where to start in its name. But unfortunately, the presenter first pattern packs too many responsibilities into the presenter. Therefore, not the best source to get an answer from.

But we have to start somewhere, don’t we?

In my experience, I normally know what has to be visualized in a dialog or window, but I don’t know yet how exactly the data is visualized or where to get it from.

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

In the last two posts of this series (table of contents) I explained the need for a new UI design pattern: changeability and extensibility.

In this post, I’ll throw a big diagram in your face without much explanation. The reason for this is that I want to give you the big picture before I start digging into details in the following posts of this series. You can always come back here to see where we are.

The Big Picture

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