This workshop presentation has been conceived to give you a head start in architecting with agile practices. Even if the stakes are not the same, architects can benefits from the same practices as those used by the agile software development. The only difference is that the deliverables, the end results conceived by the architects are not the same. While the agile developers focus on objects and its internal implementation, the architects focus on structures that elevate the level of abstraction by suppressing the details that have to do solely with the internal implementation. Software architecture is about creating structures to tackle complexity and to achieve simplicity. The simplest way to achieve simplicity is to divide into layers and to hide each layer behind an interface to isolate dependencies. Combining layering with agile practices provide an effective approach to cope with changes and to achieve simplicity. Architects are now responsible to design interfaces, tests and mockups, which make possible to create a new semantic level to be more precise with regard to the contract of a layer. This precision is important to effectively communicate with programmers and also to adequately validate the implementation. Since tests are executable, correctness with regard to architecture can be confirmed at any time. Overall, you will acquire fundamental knowledge not only about layered architecture but also about how to design architecture using agile practices such as test-driven design, code refactoring, interface based programming, automated unit test and continuous integration.

Audience:

Software Architects, lead developers and anyone aspiring to be an architect

Course Outline:

This workshop explains how to divide into layers the concerns of the application and how to add a testable interface for each layer. Using a real case study with C# language and Microsoft .NET framework, students will learn how to implement a layered architecture using agile practices such as interface based programming, test-driven design and continuous integration:

• Layered Architecture: The simplest way to achieve simplicity is to divide complexity into layers. You will learn the four types of layers found in every enterprise applications. Partitioning the concerns of the application requires modularity. You will learn about the attributes of a module and how it applies to layers.
• Visible Interface: The greatest leverage to obtain simplicity is to hide details behind an interface. Hiding complexity requires a visible interface with a contract well defined. To express not only the syntax but also the semantic of the contract, we will teach you how to use tests to design the expected behaviors of the interface.
• Autonomous Testability: Testability at the layer level without having to assemble the whole system is an important attribute of modularity. Using test-driven design techniques to express behavior, you will learn how to build a “mockup” implementation to efficiently test a layer in an autonomous way (in a test bed).
• Implementation Correctness: Based on mockups and “dependency injection” as a mediator to reduce coupling with sub-layers, we will teach you how to confirm, at any time, implementation correctness using regression testing.

At the end of this workshop you will acquire fundamental knowledge not only about layered architecture but also about how to design architecture using agile practices.