Visual Basic QuickStarts and How-to Topics for patterns & practices PrismV2 (Composite Application Guidance for WPF and Silverlight) are now available.

What is PRISM
The Composite Client Application Guidance is designed to help you more easily build modular Windows Presentation Foundation (WPF) and Silverlight client line of business applications.

Included in this Release
The release includes QuickStarts, the Composite Application Library (only provided in C#), and documentation. The documentation includes:

• Visual Basic Content for Composite Application Guidance for WPF and Silverlight - February 2009.chm: The QuickStarts, Hands-On Labs, and How-to Topics in Visual Basic.
• Composite Application Guidance for WPF and Silverlight - February 2009.chm: Complete documentation in C#.
• Composite Application Library Reference February 2009.chm: Library reference API.

Now's your chance to influence patterns & practices Enterprise Library 5.0.  You can do so by taking the Enterprise Library 5.0 Product Backlog Prioritization Survey.   The current backlog includes more than 100 stories.  You can suggest priorities for these items as well as suggest up to 3 new stories.  Each story has a "T-Shirt size", which is a rough estimate of the cost.  You get 100 points to spend on your priorities.  For example, you might spend all 100 points on your most important priority or you might spread your points over several stories.

T-Shirt Cost Sizes / Cost
Here's a summary of the T-Shirt sizes and relative costs:

• S = 1
• M = 2
• L =4
• XL = 8
• XXL(epic) = 20 points

Story Categories
The Enterprise Library 5.0 product backlog is organized by the following categories:

• User Experience
• Learnability
• Architecture
• Configuration
• Configuration Tool
• Extensibility
• Exception Handling
• Caching
• Logging
• Resource Management and Localization
• Validation
• Unity
• Policy Injection

Enterprise Library 5.0 Stories List
Here's the list of stories in the tentative Enterprise Library 5.0 Product Backlog:

User Experience

• UX01: Better error reporting/messaging throughout (M)
• UX02: Debugging Visualizer for Unity (L)
• UX03: Config IntelliSense for Unity and EntLib in XmlEditor (M)
• UX04: Config IntelliSense for Unity in XmlEditor (M)
• UX05: Config tool facelift - towards a more intuitive and easier to use UI (XL)

Learnability

• LEARN01: Discoverability and context/dependencies EntLib poster (L)
• LEARN02: Notebook-style 150 page book for Architects (XXL)
• LEARN03: Notebook-style 150 page book for Enterprise Developers (XXL)
• LEARN04: Notebook-style 100 page book for Operations/IT management (XXL)
• LEARN05: Migration guide v.2.0 ->5.0 (XL)
• LEARN06: Migration guide v.3.1 ->5.0 (XL)
• LEARN07: Migration guide v.4.1 ->5.0 (L)
• LEARN08: Updated Quickstarts (XL)
• LEARN09: Updated Hands-on Labs (XXL)
• LEARN10: EntLib Overview Video (L)
• LEARN11: EntLib5.0 New Features Video (L)
• LEARN12: Unity Overview Video (L)
• LEARN13: Unity Extensibility Video (L)
• LEARN14: Unity Extensibility Guide (XL)
• LEARN15: Guidance on environmental overrides in Unity (S)
• LEARN15: Unity& MEF decision tree/matrix (M)

Architecture

• ARC01 : Architectural update: use DI container instead of one-off Object Builder factories; DI container independence (XL)
• ARC02 : Simplification of the codebase (identify redundancies, obsoletes etc.) (XL)
• ARC03 : Reduction of the number of assemblies (XL)

Config

• CFG01 : Config decentralization (support for config stored in multiple sources) (S)
• CFG02:  Improved Config API (XL)
• CFG03:  Support for different sections of config in different media (not just files) (XL)
• CFG04:  Support for multiple pieces of config for a single block in multiple places (XXL)
  CFG05:  Making Unity configuration less verbose (M)
• CFG06:  Support other config schemas for Unity config (e.g. XAML-based config)
• CFG07: Unity config auto-registration: expanded conventions and helper classes to reduce need for explicit configuration (M)

Config Tool

• TOOL01: Type picker improvements (sped up search, better generics UI) (M)
• TOOL02: Support of Unity configuration (M)
• TOOL03: Block invocation from the configuration designer (e.g. Configure a block, Right-click, Copy "Code to Invoke", and then paste it elsewhere) (S)
• TOOL04: Web-based config tool (L)
• TOOL05: Easier manipulation of validation trees (potentially, drag&drop) (M)

Extensibility

• EXT01: Simplifying writing extensions and plugging their custom configs into the config tool (XXL)
• Data Access
• DAAB01: DAAB & LINQ basic integration (i.e. execute a query on a database, get back an object that you can do LINQ on) (M)
• DAAB02: Async ADO.NET support (M)
• DAAB03: Fix: validation of sprocs parameters – do not validate (S)
• DAAB04: No swallowing of SQL exceptions (S)

Exception Handling

• EHAB01: Default post-handling action to ThrowNewException instead of NotifyRethrow (S)
• EHAB02: Parameterized templates for exceptions (M)

Caching

• CACHE01:  Adding a reason to the class that informs a user why their object was removed from the cache (S)
• CACHE02: Cache backing store targeting ESENT (L)

Logging

• LAB01: ETW sink (?, potentially XXL)
• LAB02: Async logging (text formatting done asynchronously) to cut down on load on primary thread (M)
• LAB03: Automatically purging old files by the rolling trace listener (S)
• LAB04: Authenticated Email Trace Listener (S)

Resource Management & Localization

• LOC01: Localizability of EntLib assemblies (L)
• LOC02: Localizability of exception messages and templates (S)
• RAB03: Resource Application Block (a provider to get assorted resources from various media/sources) (XXL)

Validation

• VAB01: Integration with WPF (XL)
• VAB02: Integration with/assistance in implementing IDataErrorInfo (S)
• VAB03: ArgumentValidationException.ToString() show the validation results (S)
• VAB04: Decorating LINQ objects with Validation attributes (M)
• VAB05: Simplifying checking for positive / negative values (S)
• VAB06: Simple validating field only if the value is not null (S)
• VAB07: Validation Block refactoring to allow using Unity to resolve Validators (M)
• VAB08: Enabling Validation Block to be used with 3rd party object relational mappers (M)
• VAB09: Honouring validation attributes defined in System.ComponentModel.DataAnnotations (S)   
• VAB10: Honouring MetadataType attribute (M)
• VAB11: Better localization support (i.e. the first time the validator is used, the locale for the messages is defined) (M)
• VAB12: Inheritance-aware object validator (M or ?)
• VAB13: Support for recursive data structures (M)
• VAB14: Provide NullValidator to properly "ignore nulls" instead of the "Or composite" (S-M)
• VAB15: Additional validator: Number of decimal places validator (S)
  VAB16: Additional validator: Validator that checks that an enum contains a value that maps onto its defined values (S)   
• VAB17: Validator that compares against a single specific value (S)
• VAB18: RelativeDateTimeValidator update to  compare against UtcNow instead of Now  (S)

Unity

• U01: ResolveAll to return unnamed registration too (S)
• U02: Allow a mapping from a named registration to the "default" one (S)
• U03: Support for passing arguments to the Resolve method (M)
• U04: Container introspection (S)
• U05: Unity-MEF Integration (e.g. unityContainer.Resolve<MefPart>()) (M)
• U06: Clearer error reporting (M)
• Unity Interception
• UIN01: Generalized interceptor (XXL)
• UIN02: Caching of matching policies (M)

Policy Injection

• PIAB01: Implement PIAB interface that takes an interceptor type (to leverage new Unity interceptors) (S)
• PIAB02: Add non-generic overloads (S)
• PIAB03: New handlers (incl. RequiresTransaction and Call Forwarding) (S)
• Installation/Repair/Uninstallation
• INS01: Installer allows you to pick which specific blocks to install instead of the whole package (M)
• INS02: Installer ships both debug and release versions of the DLLs (S)
• INS03: EntLib installers to be included as part of installers of other custom products (merge modules) (M)

Additional Resources

• Enterprise Library 5.0 – tentative product backlog published, story/feature prioritization is open – your participation is invited!

Sources of Insight is 6 Months Old.  It's growing up fast.  I'd like to say I have the perfect plan, and everything's gone as planned, but I don't and it hasn't.  Life's funny like that.  What I can say is that I've made the most of it along the way, and I continue to fail forward.  Onward and upward.

Sources of Insight is my blog for sharing patterns and practices for skilled living.  It's how I scale myself as I help others unleash their inner awesome.  You can think of it as a collection of insight and action to get results for work and life.

Here's some key features on Sources of Insight:

• Browse guest posts by best selling book authors
• Download my Free eBook - The Zen of Results, a quick guide to getting your life back.
• Browse my hand picked collection of top personal development books
• Browse my hand picked collection of top personal productivity quotes
• Browse my posts of insight and action to help you make the most of what you got.

I'm honored to have a guest post at Sources of Insight from Dr. Ken Sylvester on The Top 5 Characteristics of Leaders.  Dr. Sylvester has taught Negotiation Strategies at Microsoft for many years.  He's president of Organization Strategy Institute (OSI) and has more than 35 years of experience as a leadership and management consultant and professional negotiator.

Here's a summary of Dr. Sylvester's top five characteristics of leaders:

• Characteristic 1. Depersonalization: Neutralize Ego-Centric Thinking
• Characteristic 2. Self-Control and Emotional Maturity:
• Characteristic 3. Emotional Maturity: Avoid “Dancing” To Others’ Psychological Music
• Characteristic 4. Manage Failure: Expect Setbacks
• Characteristic 5. Cope with Imperfection: Guard Your Expectations

Ray Ozzie had a chance to review our Microsoft patterns & practices Application Architecture Guide 2.0, and this is what he had to say:

“This guide is a tremendous compilation of patterns, practices, architectural styles and other principles to be used when structuring a contemporary .NET application. Whether developing software targeted at the PC or a phone; or developing services for the web or an enterprise server; or developing a composite software+services solution, this book will provide you a wealth of useful and practical guidance.”

Today marks 100,000 downloads of our Microsoft patterns & practices Application Architecture Guide 2.0.    That's a significant milestone.  The guide gets downloaded about 750 times a day.

To help put it in perspective, here's some quick comparisons:

• patterns & practices Team Development with Team Foundation Server guide has been downloaded 107,072 times since May, 2007.  It gets downloaded about 160 times a day.
• patterns & practices Improving Web Services Security guide has been downloaded 17,594 times since January 2008.  It gets downloaded about 42 times a day.
• patterns & practices Performance Testing Guide for Web Applications has been downloaded 4,252 times since October 2007.  It gets downloaded about 6 times a day.

My Related Posts

• Application Architecture Guide 2.0 Final Release
• Microsoft Application Architecture Guide 2.0 Impact
• Application Architecture Guide 2.0 on ASP.NET Home
• .NET Rocks Interview on the Application Architecture Guide 2.0
• Application Architecture Guide 2.0 Videos

I wrote a post about Security Hot Spots on Shaping Software.  Hot Spots are a way to organize and share information more effectively.    Hot Spots are also a way to turn Pareto's principle (the 80/20 rule) into action.  By focusing on the hot spots, you find the levers in the system that produce the greatest results.  You can use these levers to help find security flaws or improve security engineering.  Read my post to find the what, why and how of Security Hot Spots.

Our Microsoft patterns & practices Application Architecture Guide is now linked from the ASP.NET Home.  Many thanks to Joe Stagner for making this happen.

You can read Scott Guthrie's foreword for the guide online. Here's the key features of the guide at a glance:

• a canonical application frame
• a set of canonical application types (Web, RIA, mobile ... etc.)
• an architecture frame (caching, data access, exception management ... etc.)
• quality attributes (security, performance, manageability, ... etc.)
• principles, patterns, and practices
• technologies and capabilities

From an ASP.NET standpoint, you get design level guidance for Web applications, and there's a technology matrix at the end of the guide.  Think of the guide as a map of the terrain to help you find the hot spots for your architecture and design.

.NET Rocks published show #426, Rob Boucher on Application Architecture Guidance.  It's an in-depth interview with Rob Boucher from our Microsoft patterns & practices Application Architecture Guide 2.0 project.  It's a behind the scenes look at the making of the guide and you get to know Rob along the way.  There's a lot of insight about the structure of the guide, as well as the approach we used in the guide.  There's also a lot of inside information on the design intentions and usage scenarios.  Enjoy!

I posted an update to the Agile Architecture method on Shaping Software.  When I originally posted about the Agile Architecture method, I took some things for granted.  I thought the mapping to agile practices was more obvious than it turned out to be.  After taking more customers through the approach, I realized some things are worth more elaboration.  Here's some of the key things that stood out among the conversations:

• Whiteboard technique.  You can use the Agile Architecture method as a simple technique to quickly sketch out your solutions on a whiteboard.  It's a guided process for rapid prototyping.  The value is that it helps you identify hot spots for technical risks more quickly than ad-hoc or random approaches.
• Hot Spots.   Thinking of the cross-cutting concerns and quality attributes as hot spots seems to stick.   The intersection of the hot spots and stories is a key way to drive architectural concerns.
• Prioritized scenarios.   The user, business, and system stories are a way to help focus and prioritize which hot spots matter most.
• Mapping to agile practices.   You can use the Agile Architecture method to shape your candidate architecture, as well as prioritize technical risks and guide your architectural spikes for iteration 0.  For iterations 1 - N, you can use the Agile Architecture method to guide your design, implementation, and deployment inspections as well as identify hot spots in your design.  You can also use it to help you periodically refactor your design to meet your objectives for your various quality attributes, such as performance, security ... etc.  Most importantly, you can use the Agile Architecture method as a structured approach for addressing cross-cutting concerns and baking quality throughout the life cycle.
• Just in Time Architecture.   One of the most important points about the Agile Architecture method is that it's just enough architecture and just in time architecture.  When you're creating your baseline or candidate solutions, it's a structured approach to help you prioritize technical risk and find the key hot spots.  During iterations, it's a way to provide just in time architecture by mapping relevant hot spots against your prioritized stories.