J.D. Meier's Blog

Software Engineering, Project Management, and Effectiveness

  • J.D. Meier's Blog

    Productivity Personas

    • 3 Comments

    I wrote a post on Productivity Personas at Sources of Insight.  It's simply a way to identify and label some common behaviors you see in yourself and others when it comes to producing results.  Once you know the personas, you can effectively switch hats and use the right personas for the job.  Using these personas, you can also better analyze team performance.  For example, if you have a bunch of "starters" but no "finishers" you might be in trouble bringing things to closure.  Here's a list of the personas:

    • Starter
    • Finisher
    • Thinker
    • Doer
    • Simplifier
    • Maximizer
    • Critic
    • Can do
    • Opportunist
    • Perfectionist
    • Details
    • Big Picture
    • Facts and figures
    • Controller
    • Tinkerer
    • Marketer
    • Achiever
    • Randomizer
    • Daydreamer
    • Procrastinator

    For a quick summary of the personas, check out Productivity Personas.

  • J.D. Meier's Blog

    You 2.0 Free E-Book

    • 3 Comments

    You20

    Personal Development is one of my passions.  I find and share the principles, patterns, and practices that work.  I have some draft thinking that I'm sharing in my You 2.0 E-Book.  I turned a slide deck into a PDF to make it easier to share.  It's brief (25) pages and quick to flip through.  More importantly, it captures a mash up of some of the most important principles, patterns, and practices for leading from the inside out.  When you drive from the inside out, you amplify your impact and improve your effectiveness.  It also gives you a strong foundation for dealing with life's curve balls.

    Why You 2.0
    Here are a some key benefits:

    • Success by design.  Rather than luck into success, you’ll know your personal combination for results.
    • Living your purpose.  Nothing fuels life like knowing what you want.
      Living your values.  Living your values help you enjoy more moments in your life, a moment at a time.
    • Playing to your strengths.  When you play to your strengths, you improve your energy, and you amplify your results.  It’s the simplest way to get more impact each day.
    • Improved results.  You’ll improve your results.  A little self-knowledge goes a long way.  You’ll be a better, faster, stronger you for whatever you want.

    Read my post and download the You 2.0 E-Book on Sources of Insight.

  • J.D. Meier's Blog

    Dr. K on How To Design a Fulfilling Life

    • 1 Comments

    I'm honored to have a guest post on Sources of Insight from Dr. Rick Kirschner (aka Dr.K on How To Design a Fulfilling Life.  Dr. K is the best-selling author of Dealing with People You Can't Stand.  If you're an engineer or simply like doing things by design, Dr. K shares some of his thoughts on how to live a life by design vs. by default.  Here's a summary of his lessons:

    • #1: Self Protection is the priority mission.
    • #2: Self Maintenance is the secondary mission.
    • #3: Create Something is your third mission.
    • #4: Connection is the fourth mission.
    • #5: Service is the fifth mission.

    For me, the guiding rule that helps me shape my life is, "give your best where you have your best to give."  It forces me to focus on my strengths and lift others up.

    Read How To Design a Fulfilling Life.

  • J.D. Meier's Blog

    Lessons Learned in patterns and practices

    • 1 Comments

    I'm a fan of continuous learning.  My post Lessons Learned in patterns & practices on Shaping Software summarizes some of my best lessons.  It's from the school of hard knocks.  I've been lucky enough to have some great mentors that have really helped me unleash my best.  I've also been lucky enough to work on a variety of challenging projects that have grown my experience and capabilities beyond what I ever expected.  The post is my attempt to both remind myself of the key lessons and to share those lessons with you.  Absorb what is useful.

    Top Ten Lessons
    Here's a list of the top 10 lessons:

    • Win the heart, the mind follows.
    • Know the tests for success.
    • Fix time, flex scope.
    • Use the system to educate.
    • Work with the right people, on the right problems, making the right impact.
    • Have the right people in the room asking the right questions.
    • Sell the vision.
    • Make it a project.
    • Know what you're optimizing.
    • Turn chickens into pigs.

    One of the ways I've learned to carry lessons forward is to turn them into terse little guidelines.  It makes them sticky and easier to recall.  I also find that some of my best mentors tend to have a way with words and they share their advice as pithy sayings.

    For more lessons and elaboration check out my post, Lessons Learned in patterns and practices.

  • J.D. Meier's Blog

    Dr. K on Top 10 Lessons in Interpersonal Skills

    • 5 Comments

    I'm honored to have a guest post on Sources of Insight from Dr. Rick Kirschner (aka Dr.K) on Top 10 Lessons in Interpersonal Skills. Dr. K is the best selling author of Dealing with People You Can't Stand.   I think that communication skills improve your effectiveness in just about any situation.  I find this is especially true in software development given how much of the work is about collaboration, teamwork, and getting things done with other people.  You can luck into communication success or you can learn key skills.  Dr. K does a great job of giving actionable, prescriptive advice for bringing out the best in people.

    Here's a summary of the top 10 lessons in interpersonal skills:

    • Lesson #1: Make Useful Assumptions
    • Lesson #2 Assume Positive Intent
    • Lesson #3: Know What You Want
    • Lesson #4: Meet People Where They Are
    • Lesson #5: Listen To Go Deep
    • Lesson #6: Choose Your Words Carefully
    • Lesson #7: Relationships Are About Perception
    • Lesson #8: Project and Expect The Best
    • Lesson #9: Keep Your Wits About You
    • Lesson #10: Create Change In Stages

    Read Top 10 Lessons on Interpersonal Skills for more on these lessons.

  • J.D. Meier's Blog

    Customer Connected Engineering

    • 2 Comments

    I posted slides on how we do Customer Connected Engineering at patterns & practices to Shaping Software.  Customers Connected Engineering (CCE) is how we engage customers throughout our product development. We formally engage customers during the planning, development, and release of our deliverables to help make sure our deliverables are customer-driven.  Customers supply the scenarios, help prioritize, and provide feedback helping reduce the gap between what we build and what customers actually need.  It's effectively a prosumer model where the producer pairs with the consumers to improve the results.

    Find out more about Customer Connected Engineering including key activities and guiding principles.

  • J.D. Meier's Blog

    Motivation Quotes

    • 5 Comments

    I added a set of my favorite motivation quotes to Sources of Insight.   You never know where you might find just the inspiration you need. 

  • J.D. Meier's Blog

    A Language for Architecture

    • 5 Comments

    ALanguageForArchitecture

    My Architecture Journal article is live, A Language for Architecture.   I wrote the article to share the map of application architecture we created during our patterns & practices Application Architecture Guide 2.0 project.  It's a simple language for helping you get in the ballpark when you're traversing the very large space of software architecture.   By framing and naming the space, we can more effectively share our principles, patterns, and practices for application architecture.   This also helps consolidate all the great information spread over time and space and threads and heads.   More importantly, if we simplify how we talk about architecture, we can move up the stack as well as pave paths for others and help mentor others in our field.  Instead of asking basic questions like what is architecture, we can ask things like how do we define archetypes for the cloud or how do improve product line engineering for common systems and application types? In our case, we're using the language to help rationalize our portfolio of assets in our patterns & practices product line.

    Why the Map
    There's an explosion of concepts in the architecture space.  While working on the Application Architecture 2.0 Guide, we needed a simple, but effective bird's-eye view of the space.  By framing and naming the space, we created a shared vocabulary, helped avoid information overload, and made it easier to find, organize, and share principles, patterns, and practices with customers, field, and product teams.  It's good for the ecosystem.

    Usage Scenarios
    Here's some usage scenarios:

    • Heat Map.  If you do product planning or competitive analysis you can use the map and language to create heat maps and create a "consumer reports" for the space you are in.  You can identify key hot spots and quickly drill in or evaluate the level of maturity in that domain.  You can use the map to find the most important areas to invest.  That's key, especially in today's economic landscape.
    • Hot Spots.   By mapping out hot spots you build a catalog of your key engineering decisions.  These become your focus points.  By focusing efforts you improve your results.  For example, if cloud computing is a hot spot, you might identify manageability within that and then you might invest your energy in reducing friction or creating opportunity in that hot spot.
    • Solution Engineering.   If you build applications you can use the map and language for quickly traversing key engineering decisions.  You can use it to quickly identify your key risks as well as explore potential solution options.  It helps you identify what you know, don't know and need to know next.  It also helps you quickly rip through technology decisions.
    • Architectural Exploration.   You can use the map as a way to explore existing systems.  By chunking up architectures into things like archetypes, qualities, hot spots ... etc. you can drill into them more effectively.  For example, you might go on an architectural expedition to build a catalog of common application patterns for your group.
    • Whiteboarding.   Effective whiteboarding is an art.  That said, whiteboarding is one of the most important tools in our industry when it comes to sharing knowledge and getting people on the same page.   You can use the language, maps, and frames to improve your whiteboarding skills by using common elements from the map.
    • Product-line engineering.  If you build software, you can use the map to get more precision over your product line by defining the scenarios, the requirements, the archetypes and hot spots.  You can also use these to differentiate.
    • Slideware.  If you have to build slides, you can use the map, the language, and the visuals to more effectively share what's important.
    • Prescriptive Guidance.   If you're in the decision improvement business, then using a common map and frames will help you organize and share patterns and practices more effectively.  What if we could easily traverse the common data access patterns for RIA applications from a security, performance or manageability perspective?  We get closer to the capability when we share common maps.

    Key Concepts
    Here's some key concepts behind the map and language:

    • Hot Spot driven.  Rather than exhaustive, the maps, language, and frames are hot spot driven.  If you can see the forest from the trees, you have a better vantage point and can more selectively drill down or elaborate as needed.   Hot spots are also where the action is.  See Security Hot Spots and Performance Hot Spots.
    • Expandable by design.  The maps are expandable by design.   You can unfold, elaborate or expand each area as needed.   You can tailor it for your context.  The maps gives you a baseline of hot spots to start from so you don't have to start from scratch.
    • Overlays.   The maps, language, and frames are backdrops.  This means we can overlay principles, patterns, and practices.  This also means we can overlay products or technologies or solution assets, such as reusable code.
    • Whiteboard oriented.    The maps, language and frames are oriented towards whiteboard usage, simply because it's one of the most universal tools in our field.  By optimizing around whiteboard usage and humans over tools, we reduce friction around sharing basic information.
    • Plays well with others.   No matter what your favorite framework or mental models are, you can leverage the maps, language and frames.  We didn't set out to build an exclusive set.  Instead, we set out to map out an inclusive set of concepts that can easily stretch to fit.  It's platform agnostic and if anything, it's most tightly bound to the knowledge areas of software architecture.  In the words of Bruce Lee, "absorb what is useful."
    • Real-world over academic.   We chose to optimize around the language, maps, and frames we see in practice.  We needed it to be simple to explain whether we're in a team full of developers or a doing a presentation for business decision makers.  It's a simple way to look at the legos and  organize them in a meaningful way.

    The Map
    The key components of the language include:

    • User, Business, and System Perspective.   Architecture is a constant balance of user, business, and technical concerns.  For example, the user wants a response time of x, but the cost and impact on the system side have to make business sense.  When you group by user, business, and system stories you get more precision around the drivers and goals and you can include the right people for the right decisions, as well as keep checks and balances.  See What are the User, Business, and System Goals.
    • Architecture Frame.  This is the main map that includes the context, the app types, the architectural styles, and the application feature frame.  The context is expressed with scenarios, requirements / constraints, and quality attributes.
    • Application Archetypes (App Types).  Application Types are simply blueprints for classes of applications.  In our Application Architecture Guide 2.0, we called out mobile, RIA, Web, Rich Client, and Services.  Those are technical types.  You could also call out a set of business types. or a set of core system archetypes.  The key is to identify a set of types for your business so you can think in terms of a product-line.  See Application Types.
    • Quality Attributes.   This includes system, run-time, design, and user qualities.  For example, a run-time quality would be availability, while a design quality would be conceptual integrity.  See Quality Attribute List.
    • Scenarios.  You can't design or evaluate an architecture in a vacuum.  Scenarios give you the context.  The scenarios are a really important element.  In terms of architecture, the architecturally significant use cases are vital to making the right trade-offs.  You can find architecturally significant scenarios by looking at the intersections of quality attributes or hot spots with application features.  See App Types, Verticals, and Scenarios and What's a Scenario?.
    • Architectural Styles.  Architectural styles are simply sets of principles that shape the software.  We grouped styles by  big decision areas: communication, deployment, domain, interaction and structure.The beauty of architectural styles is we can talk about higher-level goals before getting into specific technologies.  For example, if you choose SOA as your architectural style for your communication, you can then evaluate whether WCF or ASMX helps you implement those principles.  Every app is a mash up of styles. 
    • Requirements and Constraints.   Requirements and constraints are simply what's required of the system.  Again, this is where user, business, and system perspectives matter.  We called out functional, non-functional, technological, and constraints.  Non-functional would include quality attributes and constraints would include organizational and industry compliance.  See Requirements Types and  User Requirements vs. System Requirements.
    • Application Feature Frame.   This is a set of hot spots focused on a common set of key engineering decisions.  We called out Caching, Communication, Concurrency and Transactions, Configuration Management, Coupling and Cohesion
      Data Access, Exception Management, Layering, Logging and Instrumentation, State Management, Structure, Validation, and Workflow.  These are  the types of decisions you don't want to make up on the fly and you want to avoid do-overs.  You'll also notice our industry is rich with principles, patterns, and practices in these categories, as well as reusable components.  For example, you can overlay Enterprise Library on several of these areas.   See Application Infrastructure Frame.
    • Application Frames.   These are hot spots based on a given application type.  For example, for Web applications, we defined Authentication, Authorization, Caching, Exception Management, Logging and Instrumentation, Navigation, Page Layout (UI), Page Rendering, Presentation Entity, Request Processing, Service Interface, Session Management, Validation.  Notice that the map has a lot of similar categories to the core application infrastructure frame.  The key is context.  Now we are talking about validation within Web applications.  Also notice that some hot spots are more Web centric such as page layout and page navigation.  Also notice that we can overlay key Web patterns on these hot spots.  Instead of a laundry list of patterns, we can find, organize, and share key patterns for these hot spots.
    • Layers, Components, and Tiers.  We called out layers, components, and tiers so that we could have a common backdrop with the various existing bodies of work.   We kept layers logical and tiers physical (a precedent set back in 2001 to help untangle confusion.)  We called out the presentation, business, data, and service layers.  You can extend that for things like productivity layers or manageability layers.  Keep in mind that layers are fractal, in other words you might have a service that has a presentation, business, and data layer within it.  Effectively you can think in terms of macro and micro levels.  For components we called out presentation components (user interface, user process), business components (application facade, business, business entity, business workflows), data layer components (data access logic, data helpers/utilities, service agents), and service layer components (service interfaces, message types).  For tiers, we called out 2-tier, 3-tier, and N-tier.
    • Pattern Maps.  We created pattern maps based on the frames.  For example, for each application type (Web, RIA, Mobile ... etc.) we used the hot spots to overlay relevant patterns.  This helped us surface up the most important patterns for a given topic and avoid information overload.
    • Product and Technology Maps.   We created product and technology maps organized by scenarios, application types, and hot spots.  The key here was making it easy to traverse the problem space and overlay the solution space.
  • J.D. Meier's Blog

    The Elegant Code Cast on PRISM 2.0

    • 1 Comments

    Bob Brumfield and Blaine Wastell from our patterns & practices team talk about Prism 2.0 with the Elegant Code Cast in Code Cast 26 - Prism 2.0.   Prism 2.0 is our patterns & practices Composite Client Application Guidance.  It's prescriptive guidance to help you build modular Windows Presentation Foundation (WPF) and Silverlight client line of business (LOB) applications.

    My Related Posts

  • J.D. Meier's Blog

    Stephen Nelson on The Five Small Business Success Formulas

    • 1 Comments

    I'm honored to have a guest post at Sources of Insight from author Stephen Nelson on The Five Small Business Success Formulas.  Stephen is the best-selling author of QuickBooks for Dummies (over 400,000 copies sold), of Quicken for Dummies (over 1,000,000 copies sold), and numerous other books about small business accounting, finance, project management, and technology.  He was once called the Louis L’Amour of computer books by the Wall Street Journal because he’s written more computer books (roughly 160 at last count) than any other author.

    Read Stephen Nelson on The Five Small Business Success Formulas.

  • J.D. Meier's Blog

    Performance Hot Spots

    • 2 Comments

    I wrote a post about Performance Hot Spots on Shaping Software.  This is a follow up to my post on Security Hot Spots.  Hot spots are a way to turn Pareto's principle (the 80/20 rule) into action.  By focusing on hot spots, you find the levers in the system that produce the greatest results.  You can also use the Performance Hot Spots to help you find and share principles, patterns, and practices for performance.  Read my post to find the what, why and how of Performance Hot Spots.

  • J.D. Meier's Blog

    Monday Vision, Daily Outcomes, Friday Reflection

    • 2 Comments

    I've posted a summary of my Monday Vision, Daily Outcomes, Friday Reflection pattern on Sources of Insight.   It's the heart of my results system and it's how I organize and structure my week.  On Mondays, I figure out 3 compelling outcomes (results) for the week.  This helps me prioritize my day to day.  Each day, I figure out 3 compelling outcomes.  On Fridays, I reflect on 3 things going well and 3 things to improve.  I carry forward the lessons learned into each new week.

    It's a simple but effective pattern improving your effectiveness.  I use it to drive results for myself and my project teams.  By scoping with The Rule of 3 , structuring your week with Monday Vision, Daily Outcomes, Friday Reflection, and investing in your hot spots for life (mind, body, emotions, career, relationships, financial, and fun), you set yourself up for success.  It works because you define your 3 tests for success each day and for the week.  It also works because it's easy to get back on your horse when you fall down.  If you got off the bandwagon, to get back on, simply start your day by asking what's the 3 best results you can accomplish for the day.

  • J.D. Meier's Blog

    New Release: Hands-on Labs for Unity 1.2

    • 2 Comments

    Hands-on Labs for Unity 1.2 are now available.

    What is Unity
    Unity is a lightweight, extensible dependency injection container with optional support for instance and type interception. It facilitates building loosely-coupled applications and provides developers with the following advantages:

    • Simplified object creation, especially for hierarchical object structures and dependencies.
    • Abstraction of requirements; this allows developers to specify dependencies at run time or in configuration and simplify management of crosscutting concerns.
    • Increased flexibility by deferring component configuration to the container.
    • Service location capability; this allows clients to store or cache the container.
    • Instance and type interception (via an extension introduced in Unity Application Block 1.2—October 2008).

    What's in this Release
    Use this set of Hands-on Labs as a guide to learn about how to use Unity dependency injection container and how to leverage its capabilities in various application contexts (including ASP.NET).   It covers the following topics:

    • setting up the container
    • configuring injection through API and files
    • resolving generics and decorator chains
    • using array injection
    • integrating with ASP.NET
    • using child containers.
  • J.D. Meier's Blog

    New Release: Hands-on Labs for Microsoft Enterprise Library 4.1

    • 3 Comments

    Hands-on Labs for Microsoft patterns & practices Enterprise Library 4.1 are now available. 

    What is Enterprise Library
    Microsoft Enterprise Library is a collection of reusable software components ("application blocks") designed to address common cross-cutting concerns for enterprise application development (such as logging, validation, data access, exception handling, and more). Entlib is provided as source code, test cases, and documentation that can be used "as is" or extended, and encapsulates the Microsoft recommended and proven practices for .NET application development.

    What's in this Release
    Use this set of Hands-on Labs as a guide to learn about the application blocks included with Enterprise Library 4.1 and practice how to leverage their capabilities in various application contexts.

    There are also updates of the hands-on labs for the following blocks:

    • Caching Application Block
    • Cryptography Application Block
    • Data Access Application Block
    • Exception Handling Application Block
    • Logging Application Block
    • Security Application Block
  • J.D. Meier's Blog

    New Release: Visual Basic Quickstarts for Prism v2 (WPF and Silverlight)

    • 3 Comments

    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.
  • J.D. Meier's Blog

    Enterprise Library 5.0 Product Backlog Prioritization Survey

    • 5 Comments

    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

  • J.D. Meier's Blog

    Sources of Insight is 6 Months Old

    • 1 Comments

    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:

  • J.D. Meier's Blog

    Ken Sylvester on Top 5 Characteristics of Leaders

    • 1 Comments

    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
  • J.D. Meier's Blog

    Ray Ozzie on the Microsoft Application Architecture Guide 2.0

    • 3 Comments

    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.”

  • J.D. Meier's Blog

    100,000 Downloads of Microsoft Application Architecture Guide 2.0

    • 2 Comments

    image

    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:

    My Related Posts

  • J.D. Meier's Blog

    Security Hot Spots

    • 1 Comments

    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.

  • J.D. Meier's Blog

    App Arch Guide 2.0 on ASP.NET Home

    • 2 Comments

    image

    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.

  • J.D. Meier's Blog

    .NET Rocks Interview on the Application Architecture Guide 2.0

    • 1 Comments

    .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!

  • J.D. Meier's Blog

    Agile Architecture Method Revisited

    • 2 Comments

    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.
  • J.D. Meier's Blog

    Keys for Skilled Happiness

    • 6 Comments

    I wrote a post, Keys for Skilled Happiness, on Sources of Insight.  Some people are born with a better disposition, while others have to work at it.  You don't have to work harder, you have to work smarter.  Luckily, we have a great body of knowledge on happiness to draw from now.  My notes are based on Carlin Flora's article, The Pursuit of Happiness in Psychology Today.   Some insights are obvious, while others are surprising.

    Here's a summary of the keys:

    • We're lousy at predicting what makes us happy.
    • Improve your self-talk.
    • Find engaging activities.
    • Feel your full range of emotions.
    • Practice mindfulness.
    • Work towards goals.
    • Be generous.
    • Be careful who you hang with.
    • Limit your choices.
    • Build your relationships.
    • Evaluate your well-being at the macro as well as the micro level.
    • Leverage your natural coping style.
Page 29 of 46 (1,126 items) «2728293031»