Architecture and Design

These sessions focus on Patterns, general Best Practices (not implementation-specific), and how to structure and architect .NET applications. The focus is at the strategic level, focusing on what technologies to use – and where – in large, n-tier applications. Plus, you'll learn about Behavior Driven Design, and application of OO with SOA.

DT4Achieving Balance
Rockford Lhotka
Tuesday, December 9 – 9:45 a.m.
It is all too easy to become fixated on the latest trend. Even if we know there's no "silver bullet", it is so tempting to become "pure OO" or "pure SOA" or "pure anything". Of course reality is messier. Real applications require a mix of technologies and concepts, including SOA, messaging, OO, client/server, workflow and more. At the same time, it isn't chaos. Each technology fits perfectly in some cases, acceptably in others and must be coerced into still others. Balance can be achieved by using the right technology to solve the right problems. The key is to start with a flexible architectural philosophy, and to fit technologies into that technology without being overly affected by marketing hype or developer enthusiasm for the latest fad. Learn about one such architectural philosophy and how it can be used to frame the use of the many Microsoft technology offerings available today.

DT12Practical Use of Model View Presenter and .NET
John Papa
Tuesday, December 9 – 1:45 p.m.
The Model View Presenter (MVP) pattern has been widely adopted and applied to .NET architectures. The View in the MVP model is directed by the presenter. Injecting the MVP pattern into an architecture can help foster UI ignorance, test first code, and code abstraction. THis session will demonstrate how the MVP model can make the same architecture easily used by a ASP.NET form, WPF form or a Silverlight form without changing any code in the presenter.

DT14Sexy Extensibility Patterns
Miguel Castro
Tuesday, December 9 – 3:15 p.m.
Let's face it, like everything else in software development, some patterns are cool and some are just plain boring. So let's turn up the heat and go over some exciting patterns that will allow you to enhance and extended an application without affecting the original design or code. In this session, I will teach you to design your applications using providers, plug-ins, and modules; in the end making an application as robust and full-flavored as a good beer.

DT17Behavior Driven Design
Raymond Lewallen
Tuesday, December 9 – 4:45 p.m.
After years and years of practicing and learning test driven development, there is a revolution going on towards BDD, Behavior Driven Design, which helps to bridge gaps between extreme programming and SCRUM. In this session, we will look at how BDD improves on the concepts of TDD, helps write better tests and makes you think more thoroughly through the problem you are attempting to solve. We will be replacing what you know about fixtures and tests with concepts such as contexts and specifications, concerns and observations and how to organize your specifications and use specunit to introduce better language into your tests and build specification reports. We do all of this in C# and Visual Studio 2008.

DW8Language-Oriented Domain-Driven Design
David Laribee
Wednesday, December 10 – 11:15 a.m.
For the past several years Domain-Driven Design has given the object oriented developer a proven set of practices and patterns for coping with business complexity through coherent, expressive domain models. In the coming years new techniques, such as Domain-Specific Language design, will carry forward the core tenants of DDD: ubiquitous language, bounded contexts, and model-driven development. In this session, we'll look at some language-oriented programming techniques for getting the most out of your domain models. We'll discuss the use of internal DSLs as a means of developing clean, intention revealing APIs and creating encapsulating languages that protect mature models. We'll examine practical scenarios where external DSLs and domain models play nice and we'll look at domain expert friendly techniques for specifying, testing, and documenting your high-value model code.

DW16User Experience for Architects: No Longer Optional
Josh Holmes
Wednesday, December 10 – 3:15 p.m.
The user experience is a core part of new applications and those with the best user experience will prevail. When I say user experience, most people think of the graphics and the front end. This, however, is just the lipstick on the application and considered "small d" design. The "big D" Design starts well before the UI layer and can have profound implications on your application architecture. Is it a SaaS application? Or is that one of many front ends? How does that impact your services strategy? How does the information flow impact your database structure? These and hundred more questions are all ways that the user experience decisions can affect the architecture.

In this session, we will cover a primer on user experience for the architect and discuss the various ways that it will affect your application architecture.

DTH5Better Application Design with Practical Loose Coupling
Caleb Jenkins
Thursday, December 11 – 9:45 a.m.
This talk introduces the concepts of component factories, strategy pattern, Inversion of Control, dependency injection and several of the available frameworks.

We'll also dig in to a comparison of various IoC's (Unity, Castle, Spring.NET, Ninject) the pro's cons, practical steps and guidance as well as some of the real world scenarios with impact to Unit Testing and application architecture.

DTH16Good Test, Better Code - Improving Design with Tests
Scott Bellware
Thursday, December 11 – 3:15 p.m.
"Testing is design"; "Unit tests are documentation"; "Tests are specifications". These are lauded rewards of developer testing practices, but simply writing tests or even writing tests before writing production code doesn't always make these wishes come true.

This presentation demonstrates how tests are used to drive design and to recognize the "test friction" which frequently suggests lurking design flaws. Through a series of examples of unit testing and test-driven development, participants are introduced to basic testing techniques and more advanced topics such as test-driven, client-driven, and behavior-driven programming, mock objects, behavior-driven development, and domain-specific languages for testing.

DTH20Architecture in the Fast-Paced World
Todd Girvin
Thursday, December 11 – 4:45 p.m.
Software development technologies seem to be evolving at an ever accelerating rate. Couple that with wide-spread adoption of agile development methods, and traditional development disciplines can get left by the wayside. But, we still have all the same need for managing requirements, architecting solutions, developing, and testing to produce quality results. In this discussion, we'll talk about techniques for architecting solutions in the midst of iterative/incremental/agile process and all of the new technologies and ideas emerging from vendors and the community at large.