J.D. Meier's Blog

Software Engineering, Project Management, and Effectiveness

November, 2008

  • J.D. Meier's Blog

    Application Architecture Visios Now Available

    • 12 Comments

    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, and System Perspectives
    • Agile Architecture Method
    • Layered Architecture
    • Layered Architecture with Services Layer
    • Layered Architecture with Multi-Clients / Multi-Channel
    • Web Application Archetype
    • Mobile Application Archetype
    • Rich Internet Application (RIA) Archetype
    • Rich Client Archetype
    • Service Archetype

    Architecture Meta Frame (AMF)

    Architecture Meta Frame

    User, Business, System Perspectives

    User Business System

    Agile Architecture Method

    Agile Architecture Method

    Layered Architecture

    Layered Architecture

    Layered Architecture with Services Layer

    Layered Architecture with Services Layer

    Layered Architecture with Multi-Client / Multi-Channel

    Layered Architecture with Multi-Client 

    Web Application Archetype

    Web Application Archetype

    Mobile Application Archetype

    Mobile Application Archetype

    Rich Internet Application (RIA) Archetype

    RIA Application Archetype

    Rich Client Archetype

    Rich Client App Archetype

    Service Archetype

    Service Archetype

  • J.D. Meier's Blog

    Agile Architecture Method

    • 11 Comments
    AgileArchitecture

    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:

    • Scopes and focuses your architecture exercise.
    • Uses scenarios to drive the design and evaluate potential solutions.
    • Helps you think through your choice of application type, deployment, architectural style and technologies.
    • Helps you quickly iterate through potential solutions.
    • Helps you map potential patterns.

    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:

    • Use cases and usage scenarios
    • Functional requirements
    • Non-functional requirements (quality attributes such as performance, security, and reliability)
    • Technological requirements
    • Target deployment environment
    • Constraints

    Output
    Here’s the key output of the process:

    • Architecturally significant use cases
    • Architecture hot spots
    • Candidate architectures
    • Architectural spikes

    Summary of Steps

    • Step 1. Identify Architecture Objectives.
    • Step 2. Identify Key Scenarios.
    • Step 3. Create an Application Overview.
    • Step 4. Analyze Key Hot Spots.
    • Step 5. Create Candidate Solutions.

    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:

    • Build a prototype
    • Identify key technical risks
    • Test potential paths
    • Share models and understanding

    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:

    1. They are important for the success and acceptance of the deployed application.
    2. They exercise enough of the design to be useful in evaluating the architecture.

    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. 

    WhiteboardingYourDesign

    An application overview consists of the following steps:

    • Determine your application type. First, determine what type of application you are building. Is it a mobile application, a rich client, a rich internet application, a service, a Web application, or some combination?
    • Understand your deployment constraints. Next, understand your targeted deployment environment and determine what impact this will have on your architecture.
    • Identify important architectural styles. Determine which architectural styles you will be using in your design. Will you build a service oriented architecture, client/server, layered, a message bus, or some combination?
    • Determine relevant technologies. Finally, identify the relevant technology choices based on your application type, architectural styles and deployment constraints.

    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:

    Category Considerations
    Availability
  • How to design for failover support
  • How to design a redundant site
  • How to plan for backup and recovery How to design for runtime upgrades
  • Conceptual Integrity
  • How to isolate from external dependencies
  • How to create a migration path from legacy technologies
  • How evolve the system without breaking clients
  • Flexibility
  • How to handle dynamic business rules How to handle dynamic UI
  • How to handle changes in data and logic processing
  • How to handle changes in business requirements
  • Interoperability
  • How to allow applications to interoperate while still evolving separately
  • How to isolate systems through the use of service interfaces
  • How to isolate systems through the use of mapping layers
  • Maintainability
  • How to reduce dependencies between layers and components
  • How to implement a pluggable architecture
  • How to choose an appropriate communication model
  • Manageability
  • How to understand the key types of failure
  • How to monitor system operation and health
  • How to modify system behavior based on load
  • Performance
  • How to determine a caching strategy
  • How to design high performance communication between layers
  • How to design high performance data access
  • How to manage resources effectively
  • Reliability
  • How to handle unreliable external systems
  • How to audit requests and jobs
  • How to redirect load
  • How to handle failed communication
  • How to handle failed transactions
  • How to handle exceptions
  • Reusability
  • How to reduce duplication between components and layers
  • How to share functionality across systems
  • How to share functionality across components and layers
  • Scalability
  • How to design layers and tiers for scalability
  • How to scale-up or scale-out
  • How to handle spikes in traffic and load
  • Security
  • How to address authentication and authorization.
  • How to protect against malicious input.
  • How to protect sensitive data
  • Supportability
  • How to design auditing and logging
  • How to design usable error messages
  • Testability
  • How to design for testability
  • How to design unit tests
  • How to design for UI automation
  • Usability
  • How to design for user empowerment
  • How to improve responsiveness
  • How to avoid common user experience pitfalls
  • 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:

    Category Considerations
    Authentication and Authorization
  • How to choose an authentication strategy.
  • How to choose an authorization strategy.
  • How to flow identity across layers and tiers.
  • How to store user identities when not using Active Directory.
  • Caching and State
  • How to choose an appropriate caching technology.
  • How to determine what data to cache.
  • How to determine where to cache the data.
  • How to determine the expiration policy.
  • Communication
  • How to choose appropriate protocols for communication across layers and tiers.
  • How to design loose coupling across layers.
  • How to perform asynchronous communication.
  • How to pass sensitive data.
  • Composition
  • How to choose a composition pattern for the user interface (UI).
  • How to avoid dependencies between modules in the UI.
  • How to handle communication between modules in the UI.
  • Concurrency and Transactions
  • How to handle concurrency between threads.
  • How to choose between optimistic and pessimistic concurrency.
  • How to handle distributed transactions.
  • How to handle long running transactions.
  • Configuration Management
  • How to determine what information needs to be configurable.
  • How to determine where and how to store configuration information.
  • How to protect sensitive configuration information.
  • How to handle configuration information in a farm/cluster.
  • Coupling and Cohesion
  • How to choose an appropriate layering strategy for separation of concerns.
  • How to design highly cohesive components and group them within layers.
  • How to determine when loose coupling is appropriate between components within a layer.
  • Data Access
  • How to manage database connections.
  • How to handle exceptions.
  • How to improve performance.
  • How to handle binary large objects (blobs).
  • Exception Management
  • How to handle exceptions.
  • How to log exceptions.
  • How to provide notification when required.
  • Logging and Instrumentation
  • How to determine which information to log.
  • How to make the logging configurable.
  • How to determine what level of instrumentation is required.
  • User Experience
  • How to improve task efficiency and effectiveness.
  • How to improve responsiveness.
  • How to improve user empowerment.
  • How to improve look and feel. </>
  • Validation
  • How to determine where and how to perform validation.
  • How to validate for length, range, format, and type.
  • How to constrain and reject input.
  • How to sanitize output.
  • Workflow
  • How to choose the appropriate workflow technology.
  • How to handle concurrency issues within a workflow.
  • How to handle task failure within a workflow.
  • How to orchestrate processes within a workflow.
  • 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:

    • Baseline / Candidate Architectures
    • Architectural Spikes

    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

  • New Release: patterns & practices App Arch Guide 2.0 Beta 1
  • patterns & practices App Arch Guide 2.0 Project
  • App Arch Guide 2.0 Overview Slides
  • Abstract for Application Architecture Guide 2.0
  • App Arch Meta-Frame
  • App Types
  • Architecture Frame
  • App Arch Guidelines
  • Layers and Components
  • Key Software Trends
  • Cheat Sheet: patterns & practices Catalog at a Glance Posted to CodePlex
  • Cheat Sheet: patterns & practices Pattern Catalog Posted to CodePlex

  • J.D. Meier's Blog

    Web Application Architecture Pocket Guide

    • 12 Comments
    Web Architecture Pocket Guide
    We posted our Web Application 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.

    Chapters At a Glance
    Here’s the chapters at a glance:

    • Ch 01 – Web Application Architecture
    • Ch 02 - Design Guidelines
    • Ch 03 - Presentation Layer Guidelines
    • Ch 04 - Business Layer Guidelines
    • Ch 05 - Data Access Layer Guidelines
    • Ch 06 - Service Layer Guidelines
    • Ch 07 - Communication Guidelines
    • Ch 08 - Deployment Patterns

    Download

    My Related Posts

  • J.D. Meier's Blog

    New Release: patterns & practices App Arch Guide 2.0 Beta 2

    • 15 Comments

    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:

    • Added a foreword by S. Somasegar.
    • Added technology considerations throughout the guide.
    • Added technology matrixes for choosing technologies, including Presentation, Data Access, Workflow, and Integration technologies.
    • Added a new Agile Architecture Method (see chapter 4.)
    • Tuned and pruned the recommendations across the entire guide.
    • Restructured the guide for simpler parts – fundamentals, design, layers and archetypes.

    4 Parts

    • Part I, “Fundamentals”
    • Part II, “Design”
    • Part III, “Layers”
    • Part IV, “Archetypes"

    Chapters

    Appendix

    Key Scenarios
    The guide helps you address the following scenarios:

    • Choose the right architecture for your application.
    • Choose the right technologies
    • Make more effective choices for key engineering decisions.
    • Map appropriate strategies and patterns.
    • Map relevant patterns & practices solution assets.

    Key Features

    • Canonical app frame - describes at a meta-level, the tiers and layers that an architect should consider. Each tier/layer is described in terms of its focus, function, capabilities, common design patterns and technologies.
    • App Types.  Canonical application archetypes to illustrate common application types.  Each archetype is described in terms of the target scenarios, technologies, patterns and infrastructure it contains. Each archetype will be mapped to the canonical app frame. They are illustrative of common app types and not comprehensive or definitive.
    • Arch Frame - a common set of categories for hot spots for key engineering decisions.
    • Quality Attributes - a set of qualities/abilities that shape your application architecture: performance, security, scalability, manageability, deployment, communication, etc.
    • Principles, patterns and practices - Using the frames as backdrops, the guide overlays relevant principles, patterns, and practices.
    • Technologies and capabilities - a description/overview of the Microsoft custom app dev platform and the main technologies and capabilities within it.

    Conceptual Framework
    At a high level, the guide is based on the following conceptual framework for application architecture:

    ArchMetaFrame2

    Reference Application Architecture
    We used the following reference application architecture as a backdrop for explaining how to design effective layers and components:

    RefAppArch

    Key Links

    Core Dev Team

    • J.D. Meier , Alex Homer, David Hill, Jason Taylor, Prashant Bansode , Lonnie Wall, Rob Boucher, Akshay Bogawat

    Contributors / Reviewers

    • Test team: Rohit Sharma, Praveen Rangarajan
    • Edit team: Dennis Rea.
    • External Contributors/Reviewers. Adwait Ullal; Andy Eunson; Christian Weyer; David Guimbellot; David Weller; Derek Greer; Eduardo Jezierski; Evan Hoff; Gajapathi Kannan; Jeremy D. Miller; John Kordyback; Keith Pleas; Kent Corley; Mark Baker; Paul Ballard; Peter Oehlert; Norman Headlam; Ryan Plant; Sam Gentile; Sidney G Pinney; Ted Neward; Udi Dahan
    • Microsoft Contributors / Reviewers. Ade Miller; Anoop Gupta; Bob Brumfield; Brad Abrams; Brian Cawelti; Bhushan Nene; Burley Kawasaki; Carl Perry; Chris Keyser; Chris Tavares; Clint Edmonson; David Hill; Denny Dayton; Diego Dagum; Dmitri Martynov; Dmitri Ossipov; Don Smith; Dragos Manolescu; Elisa Flasko; Eric Fleck; Erwin van der Valk; Faisal Mohamood; Francis Cheung; Gary Lewis; Glenn Block; Gregory Leake; Ian Ellison-Taylor; Ilia Fortunov; J.R. Arredondo; John deVadoss; Joseph Hofstader; Koby Avital; Loke Uei Tan; Manish Prabhu; Meghan Perez; Mehran Nikoo; Michael Puleio; Mike Walker; Mubarak Elamin; Nick Malik; Nobuyuki Akama; Ofer Ashkenazi; Pablo Castro; Pat Helland; Phil Haack; Reed Robison; Rob Tiffany; Ryno Rijnsburger; Scott Hanselman; Serena Yeoh; Srinath Vasireddy; Tom Hollander; Wojtek Kozaczynski

    My Related Posts

  • patterns & practices App Arch Guide 2.0 Project
  • App Arch Guide 2.0 Beta 1 Release
  • App Arch Guide 2.0 Overview Slides
  • Abstract for Application Architecture Guide 2.0
  • App Arch Meta-Frame
  • App Types
  • Architecture Frame
  • App Arch Guidelines
  • Layers and Components
  • Key Software Trends
  • Cheat Sheet: patterns & practices Catalog at a Glance Posted to CodePlex
  • Cheat Sheet: patterns & practices Pattern Catalog Posted to CodePlex
  • J.D. Meier's Blog

    Software Architecture Best Practices at a Glance

    • 3 Comments

    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.

  • J.D. Meier's Blog

    Pocket Guide Series for Application Architecture

    • 5 Comments
    Agile Architecture Method Pocket Guide
    Our Application Architecture Pocket Guides are available from our Application Architecture KB.  Our pocket guides are based on our Application Architecture Guide 2.0.   We prioritized an initial set of pocket guides based on customer demand for focused content on specific topics.

    Pocket Guides
    Here’s the Pocket Guides available so far:

    You can browse the list of pocket guides on the Pocket Guide Index page.

  • J.D. Meier's Blog

    RIA Architecture Pocket Guide

    • 8 Comments
    RIA Architecture Pocket Guide
    We posted our RIA 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.

    Chapters At a Glance
    Here’s the chapters at a glance:

    • Ch 01 - RIA Architecture
    • Ch 02 - Design Guidelines
    • Ch 03 - Presentation Layer Guidelines
    • Ch 04 - Business Layer Guidelines
    • Ch 05 - Data Access Layer Guidelines
    • Ch 06 - Service Layer Guidelines
    • Ch 07 - Communication Guidelines
    • Ch 08 - Deployment Patterns

    Download

    My Related Posts

  • J.D. Meier's Blog

    Mobile Application Architecture Pocket Guide

    • 7 Comments
    Mobile Architecture Pocket Guide
    We posted our Mobile Application 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.

    Chapters At a Glance
    Here’s the chapters at a glance:

    • Ch 01 – Mobile Application Architecture
    • Ch 02 – Architecture and Design Guidelines
    • Ch 03 - Presentation Layer Guidelines
    • Ch 04 - Business Layer Guidelines
    • Ch 05 - Data Access Layer Guidelines
    • Ch 06 - Service Layer Guidelines
    • Ch 07 - Communication Guidelines
    • Ch 08 - Deployment Patterns

    Download

    My Related Posts

  • J.D. Meier's Blog

    Service Architecture Pocket Guide

    • 6 Comments
    Service Architecture Pocket Guide

    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.

    Chapters At a Glance
    Here’s the chapters at a glance:

    • Ch 01 - Service Architecture
    • Ch 02 - Designing Services
    • Ch 03 - Service Layer Guidelines
    • Ch 04 - Communication Guidelines
    • Service Layer Checklist

    Download

    My Related Posts

  • J.D. Meier's Blog

    Agile Architecture Method Pocket Guide

    • 9 Comments
    Agile Architecture Method Pocket Guide
    We posted our Agile Architecture Method 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.

    Chapters At a Glance
    Here’s the chapters at a glance:

    • Ch 01 - Agile Architecture Method
    • Ch 02 - Step 1 - Identify Objectives
    • Ch 03 - Step 2 - Identify Key Scenarios
    • Ch 04 - Step 3 - Application Overview
    • Ch 05 - Step 4 - Key Hot Spots
    • Ch 06 - Step 5 - Candidate Solutions
    • Ch 07 - Reviewing Your Architecture
    • Ch 08 - Communicating Your Architecture

    Download

    My Related Posts

  • J.D. Meier's Blog

    patterns & practices Security Engineering Cheat Sheet

    • 4 Comments

    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:

    SecurityEngineering

    Key Activities in the Life Cycle
    The core activities you should consider performing include the following:

    • Security Objectives.
    • Threat Modeling.
    • Security Design Guidelines.
    • Security Design Inspection.
    • Security Code Inspection.
    • Security Testing.
    • Security Deployment Inspection.

    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

    My Related Posts

  • patterns & practices Performance Engineering Cheat Sheet
  • Agile Architecture Method
  • New Release: patterns & practices App Arch Guide 2.0 Beta 2
  • Microsoft Presentation, Data Access, Workflow and Integration Technology Cheat Sheets
  • J.D. Meier's Blog

    Rich Client Application Architecture Pocket Guide

    • 5 Comments
    Rich Client Architecture Pocket Guide
    We posted our Rich Client Application 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.

    Chapters At a Glance 
    Here’s the chapters at a glance:

    • Ch 01 - Rich Client Application Architecture
    • Ch 02 - Architecture and Design Guidelines
    • Ch 03 - Presentation Layer Guidelines
    • Ch 04 - Business Layer Guidelines
    • Ch 05 - Data Access Layer Guidelines
    • Ch 06 - Service Layer Guidelines
    • Ch 07 - Communication Guidelines
    • Ch 08 - Deployment Patterns

    Download

    My Related Posts

  • J.D. Meier's Blog

    patterns & practices Reference Application Architecture Cheat Sheet

    • 2 Comments

    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:

    RefArch

    Layers
    Here’s a brief summary of the layers:

    • Presentation Layer - Presentation layer components implement the functionality required to allow users to interact with the application.
    • Business Layer - Business layer components implement the core functionality of the system, and encapsulate the relevant business logic.
    • Data Layer - Data layer components provide access to data that is hosted within the boundaries of the system, and data exposed by other back-end systems.
    • Services Layer - Services layer components provide other clients and applications with a way to access business logic in the application, and make use of the functionality of the application by passing messages to and from it over a communication channel.

    Components
    Here’s a listing of the key components for each layer:

    Presentation Layer Components

    • User Interface (UI) components
    • UI process components

    Business Layer Components

    • Application facade
    • Business components
    • Business workflows
    • Business entity components

    Data Layer Components

    • Data access components
    • Data helper and utility components
    • Service agents

    Services Layer Components

    • Service Interfaces
    • Message Contracts

    You can read more about the components in our Cheat Sheet – Reference Application Architecture.

    My Related Posts

  • J.D. Meier's Blog

    Architecture Meta Frame Cheat Sheet

    • 1 Comments

    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.

    ArchMetaFrame

    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:

    • Scenarios. Application scenarios tie architecture solutions to the real world scenarios that impact your application design.
    • Quality Attributes. Quality attributes represent cross-cutting concerns that apply across application types, and should be considered regardless of architecture style. Security, performance, maintainability, and reusability are examples of quality attributes.
    • Requirements and Constraints. Requirements and constraints narrow the range of possible solutions for your application architecture problems.
    • Application Types. Application types categorize the major application technology stacks on the Microsoft platform. Examples of application types include Mobile, Rich Internet Application (RIA), Services Application, and Web Application.
    • Architecture Styles. An architectural style is a collection of principles that shapes the design of your application. Many of these styles overlap and can be used in combination. Architectural styles tend to be tied both to the application type as well as to the point in time in which the application was developed.
    • Architecture Frame. The architecture frame is a collection of hot spots you can use to analyze your application architecture. This helps you turn core features such as caching, data access, validation, and workflow into actions.

    You can read more about the Architecture Meta Frame in Cheat Sheet – Architecture Meta Frame (AMF) on CodePlex.

    My Related Posts

  • J.D. Meier's Blog

    Application Architecture Checklists Posted to CodePlex

    • 1 Comments

    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.

    My Related Posts

  • J.D. Meier's Blog

    Choosing the Right Presentation Technology

    • 8 Comments

    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:

    • ASP.NET Dynamic Data
    • ASP.NET Mobile
    • ASP.NET MVC
    • ASP.NET Web Forms
    • ASP.NET Web Forms with AJAX
    • ASP.NET Web Forms with Silverlight Controls
    • Compact Framework
    • Silverlight
    • Silverlight with AJAX
    • Silverlight Mobile
    • Windows Forms
    • Windows Forms with WPF User Controls
    • WPF Application
    • WPF with Windows Forms Controls
    • XAML Browser Application (XBAP) using WPF

    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:

    • Technology Summary
    • Benefits and Considerations Matrix
    • Common Scenarios and Solutions

    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.

    My Related Posts

  • J.D. Meier's Blog

    patterns & practices Performance Engineering Cheat Sheet

    • 2 Comments

    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:

    PerfEngineering  

    Key Activities in the Life Cycle
    The core activities you should consider performing include the following:

    • Performance Objectives.
    • Budgeting.
    • Performance Modeling.
    • Performance Design Guidelines.
    • Performance Design Inspections.
    • Performance Code Inspections.
    • Performance Testing.
    • Performance Health Metrics.
    • Performance Deployment Inspections.
    • Capacity Planning.

    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:

    My Related Posts

  • J.D. Meier's Blog

    Microsoft Presentation, Data Access, Workflow and Integration Technology Cheat Sheets

    • 3 Comments

    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:

    Category Technologies
    Presentation Compact Framework; ASP.NET Mobile; Silverlight Mobile; Windows Forms; windows Forms with WPF User Controls; WPF WPF with Windows Forms User Controls; XBAP with WPF; Silverlight; Silverlight with AJAX; ASP.NET Web Forms; ASP.NET Web Forms with AJAX; ASP.NET Web Forms with Silverlight Controls; ASP.NET MVC; ASP.NET Dynamic Data
    Data Access ADO.NET Core; ADO.NET Data Services Framework; ADO.NET Entity Framework (EF); ADO.NET Sync Service;s LINQ; LINQ to SQL
    Workflow Windows Workflow Foundation (WF); Workflow Services; Microsoft Office SharePoint Services (MOSS); BizTalk
    Integration BizTalk; Host Integration Server (HIS); Microsoft Message Queuing (MSMQ); Microsoft Enterprise Service Bus (ESB) Guidance


    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

  • J.D. Meier's Blog

    New Release: patterns & practices SharePoint Guidance

    • 1 Comments

    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:

    • Architectural decisions about patterns, feature factoring, and packaging.
    • Design tradeoffs for common decisions many developers encounter.
    • Implementation examples demonstrated in the RI and in the QuickStarts.
    • How to design for testability, create unit tests, and run continuous integration.
    • Set up of development, build, test, staging, and production environments.
    • Managing the application life cycle including upgrade.
    • Team-based intranet application development.

    Out of Scope

    • Content-oriented sites that use Web content management.
    • Internet and enterprise-scale SharePoint applications.
    • Multilingual SharePoint applications.
    • Scale or security testing of SharePoint applications.

    Key Links

  • Page 1 of 1 (19 items)