Software Engineering, Project Management, and Effectiveness
We added our Application Architecture Diagrams (Visios) to our Application Architecture Knowledge Base (KB) on CodePlex. You can download the Visios and customize for your own presentations or documents.
Application Architecture Figures Here’s the figures available:
Architecture Meta Frame (AMF)
User, Business, System Perspectives
Agile Architecture Method
Layered Architecture
Layered Architecture with Services Layer
Layered Architecture with Multi-Client / Multi-Channel
Web Application Archetype
Mobile Application Archetype
Rich Internet Application (RIA) Archetype
Rich Client Archetype
Service Archetype
I presented our new patterns & practices Agile Architecture Method for the first time at the patterns & practices Summit. Our Agile Architecture Method is an iterative and incremental approach for designing architectures.
To summarize, it’s a technique that:
I’ve summarized the approach below, and we’ve posted a step-step how to on CodePlex:
Input Here’s the key input into the process:
Output Here’s the key output of the process:
Summary of Steps
Step 1. Identify Architecture Objectives This is a scoping exercise. The purpose of this step is to figure out how much time and energy to spend on subsequent steps as well as guide your overall effort. You should know what you want in terms of outcomes. Here’s an example of potential goals:
Step 2. Identify Key Scenarios Identify relevant scenarios to focus your design on what matters most, and to evaluate your candidate solutions. In this case, you want to identify architecturally significant use cases. Architecturally significant use cases are those that meet the following criteria:
You can draw key scenarios from your user stories, business stories and system stories.
Step 3. Create an Application Overview Create an application overview. The application overview serves to make your architecture more real, connecting it to real-world constraints and decisions.
An application overview consists of the following steps:
A good test of an application overview is whether you can whiteboard it.
Step 4. Analyze Key Hot Spots Identify key hotspots based on quality attributes and the architecture frame. These are the areas where mistakes are most often made when designing an application.
Quality Attributes Frame Understand the quality attributes that are important for your application and scenarios. For instance, most applications need to address security and performance and will be traded against usability, flexibility and other attributes that may be more or less important to you depending on your scenarios and requirements. You can use the following frame to identify key quality attributes to consider:
Architecture Frame The architecture frame represents cross cutting concerns that will impact your design across layers and tiers. These are also the areas in which high impact design mistakes are most often made. Use the architecture frame to identify hot spots in your design that require additional attention to get right. You can use the following architecture frame to identify cross cutting concerns in your design:
Step 5. Create Candidate Solutions Create a candidate architecture and along with architectural spikes and evaluate it against your key scenarios, hot spots, and deployment constraints. The outcomes of this step are:
Iterative and Incremental Design You can iteratively flesh out your architecture as you work through your design and discover more details that impact your architecture. You don’t have to design your architecture in a single iteration. Do not get lost in the details; focus on the big steps and build a framework on which you can base your architecture and design.
My Related Posts
Chapters At a Glance Here’s the chapters at a glance:
Download
Today we released our patterns & practices Application Architecture Guide 2.0 Beta 2. This is our Microsoft playbook for the application platform. It's our guide to help solution architects and developers make the most of the Microsoft platform. It's a distillation of many lessons learned. It’s principle-based and pattern-oriented to provide a durable, evolvable backdrop for application architecture. It's a collaborative effort among product team members, field, industry experts, MVPs, and customers. This is the guide that helps you understand our platform, choose among the technologies, and build applications based on lessons learned and proven practices.
Key Changes in Beta 2 Beta 2 is a significant overhaul of the entire guide. We carried the good forward. We made some key additions:
4 Parts
Chapters
Appendix
Key Scenarios The guide helps you address the following scenarios:
Key Features
Conceptual Framework At a high level, the guide is based on the following conceptual framework for application architecture:
Reference Application Architecture We used the following reference application architecture as a backdrop for explaining how to design effective layers and components:
Key Links
Core Dev Team
Contributors / Reviewers
Today we posted our updated software architecture best practices at a glance to CodePlex, as part of our patterns & practices Application Architecture Guide 2.0 project:
They’re essentially a brief collection of problems and solutions around building software applications. The answers are short and sweet so that you can quickly browse them. You can think of them as a bird’s-eye view of the problem space we tackled. When we add them to the Application Architecture Guide 2.0, we'll provide quick links into the guide for elaboration.
This is your chance to bang on the set of problems and solutions before Beta 2 of the guide.
Pocket Guides Here’s the Pocket Guides available so far:
You can browse the list of pocket guides on the Pocket Guide Index page.
We posted our Service Architecture Pocket Guide to our Application Architecture Guidance KB. This is in response to customers who expressed interest in more modular guides as a supplement to our Application Architecture Guide 2.0.
We posted our patterns & practices Security Engineering Cheat Sheet to our Application Architecture Knowledge Base on CodePlex. It’s a bird’s-eye view of applying our security techniques to the life cycle. The techniques and approach shipped with VSTS/MSF Agile starting in 2005.
Security Engineering Overlay Here’s a view that overlays our key patterns & practices security techniques alongside common software engineering activities:
Key Activities in the Life Cycle The core activities you should consider performing include the following:
You can read more about these techniques and how to apply them to your software architecture and your software development life cycle on our Cheat Sheet – patterns & practices Security Engineering.
Additional Resources
We posted our patterns & practices Reference Application Architecture Cheat Sheet on CodePlex. It’s an overview of a layered architecture, including an brief explanation of each layer and the relevant components.
Layered Architecture at a Glance Here’s a figure that shows the layers and components:
Layers Here’s a brief summary of the layers:
Components Here’s a listing of the key components for each layer:
Presentation Layer Components
Business Layer Components
Data Layer Components
Services Layer Components
You can read more about the components in our Cheat Sheet – Reference Application Architecture.
We posted our Architecture Meta Frame Cheat Sheet to CodePlex as part of our Application Architecture Knowledge Base. The Architecture Meta Frame (AMF) is a lens to help you quickly navigate the application architecture space. You can think of it as bringing together some of the important factors that shape applications. You can also use it as a way to help find hot spots for focusing your architecture efforts.
Architecture Meta Frame (AMF) The Architecture Meta Frame integrates context, application types, architecture styles, and an architecture frame to help map out the application architecture space.
The Architecture Meta Frame serves as a durable, evolvable backdrop for the guidance in the patterns & practices Application Architecture Guide 2.0.
Key Features of the Architecture Meta Frame Here’s a summary of the Architecture Meta Frame:
You can read more about the Architecture Meta Frame in Cheat Sheet – Architecture Meta Frame (AMF) on CodePlex.
How do you choose among the Microsoft .NET presentation technologies? Use scenario-based evaluation. At the end of the day, a technology is a set of capabilities. Map those capabilities to your scenario and requirements. OK, great, but where do you start? That's where our cheat sheet comes in. As part of our Application Architecture Guidance 2.0 project, we created a cheat sheet to help you quickly find your way through the technologies:
Cheat Sheet – Presentation Technology Matrix We posted our latest cheat sheet to CodePlex:
Presentation Technologies Here’s the technology combinations that we identified, evaluated and cataloged:
That’s a lot of options, but that’s a good thing. In a mature market, expect lots of options and specialization. This helps you use the right tool for the job. The challenge, of course, is knowing which one is the right tool, but that’s where our cheat sheet should help. Ultimately, the cheat sheet is a support aid and doesn’t replace your own thinking or analysis. Instead, it helps you consolidate some key information on the technologies, and help you consider some of the benefits and considerations.
Organizing the Technologies To organize the technologies, we use a simple frame:
By pinning the technologies against common application types (Mobile, Rich Client, RIA, and Web App), it made it very easy for us to slice and dice the technologies by relevancy, capabilities, and scenarios.
How We Created the Cheat Sheet
We started from a base set of application types and scenarios. We vetted from experience among the p&p development team. Next, we reviewed with various product team members, including Brad Abrams, Pat Helland, Glenn Block, and Ian Ellison-Taylor. Next we vetted with some customers. It’s a work in progress and we’ve been through several iterations. In fact, the version we posted today is version 35. Now it’s time to share with a broader community.
As part of our patterns & practices Application Architecture 2.0 project, we created a set of application architecture checklists to help sweep our guide. The act of creating the checklists, forces us to revisit the guidance. We're still sweeping the guidance, but we're ready to share the checklists. Improving the checklists improves the guide. As a side benefit, you get handy checklists you can use as a baseline for your own checklists for application architecture.
Application Architecture Checklists
Layer Checklists
Application Checklists
Feedback on the Checklists To provide feedback on the checklists, you can make your comments either here on my blog or in the App Arch KB forums.
We posted our patterns & practices Performance Engineering Cheat Sheet to our Application Architecture Knowledge Base on CodePlex. It’s a bird’s-eye view of applying our performance techniques to the life cycle. The techniques and approach shipped with VSTS/MSF Agile starting in 2005.
Performance Engineering Overlay Here’s a view that overlays our key performance techniques alongside common software engineering activities:
You can read more about these techniques and how to apply them to your software architecture and your software development life cycle on our Cheat Sheet – patterns & practices Performance Engineering.
Additional Resources You can find more information on performance engineering at:
In my previous post, Choosing the Right Presentation Technology, I mentioned that we posted our cheat sheet on Microsoft presentation technologies to CodePlex. Now, we’ve finished posting our cheat sheets for data access, workflow, and integration on CodePlex:
Technology Coverage Here’s a summary table of the technology coverage in the cheat sheets:
Agile Architecture Methodology You can use the Agile Architecture Methodology to help map and test relevant technologies to your scenario. At the end of the day, the best techniques for choosing technologies include architectural spikes, scenario-based testing and scenario-based evaluation. My Related Posts
patterns & practices SharePoint Guidance is now available.
Abstract patterns & practices SharePoint Guidance helps architects and developers build SharePoint intranet applications. The guidance contains a reference implementation (RI) that demonstrates solutions to common architectural, development, and lifecycle management challenges. This guidance discusses the following:
Out of Scope