Grigori Melnik: Thoughts on Agile Software Engineering and Beyond

p&p Summit 2009: What’s coming in Enterprise Library 5.0

gmelnik — Fri, 16 Oct 2009 13:51:06 GMT

Yesterday Bob Brumfield and I gave a talk on EntLib5.0 at p&p summit in Redmond . We’ve discussed the underlying architectural refactoring and previewed the following improvements:

Data accessors that will help you easily consume sproc results when using Data Access Application Block – instead of a data reader you get an IEnumerable back and can do all LINQ magic on it.
Logging Block performance improvements due to optimizations using predefined timestamp patterns mapped to high-speed formatting implementations and new “local” tokens for context info (e.g. localMachine, localAppDomain) that we cache.
Improved config experience epic which included:

programmatic config support via fluent interface
face lift of the config tool to make it more intuitive (especially when displaying relationships), simpler (by removing a lot of design time dlls) and better extensible (by simplifying the way config for custom handlers/blocks) can be plugged into the config tool)

Honouring validation attributes in System.ComponentModel.DataAnnotations
Getting EntLib objects in various ways :

via a single point of entry EnterpriseLibraryContainer.Current
or injected by the container

We also demoed container independency story which allows to switch the underlying container. Out of the box, you get EntLib shipped with Unity, but if you prefer to use another DI container, now you can easily switch over.

We are planning several webcasts to share these demos.

In the meantime, feel free to check out our recent bits here and provide feedback.

Removing WMI support from Enterprise Library

gmelnik — Tue, 13 Oct 2009 20:00:31 GMT

In our quest to simplify EntLib’s codebase, we are considering removing WMI2 support in v5. This is based on recommendation by our Advisory board, as well as lack of usage and interest from the user community and the high development complexity to maintain WMI2 integration (the code itself as well as non-trivial environmental setup on dev and test machines).

If this is something you care deeply about, please scream now. We are waiting for any scenarios that could convince us to keep WMI2 support of EntLib objects till the end of October.

Note: as part of our instrumentation story, we will continue to maintain EventLog and perf counter updates.

Enterprise Library reaches 2 million downloads!

gmelnik — Wed, 09 Sep 2009 02:49:46 GMT

Enterprise Library has a broad reach and adoption. No wonder, since it embodies many of the proven .NET development practices and ships with the code, tests and hands-on labs – lots to reuse and lots to learn from. The EntLib community has welcomed more than 2 million downloads worldwide! At least 10% of Fortune 500 companies use Enterprise Library (that’s who we know of). In addition, I’ve noticed that employers now list specifically EntLib skills in their developer job ads on monster and workopolis.

To celebrate the 2M milestone, our p&p colleagues surprised us with a cake. A slice goes to everyone who has ever worked on application blocks or the library itself (one day I’ll be able to do a better job and acknowledge each and everyone of you!) as well as to all community members who have used EntLib, commented on it, reported bugs, suggested improvements, written extensions. It’s been five years since this effort began and the tremendous success of EntLib today is largely due to all of you! Thank you! We look forward to continuing collaboration with you.

Don’t forget to check out our Codeplex development site where you can see what’s coming next (in v5) and download most recent code drops.

EntLib/Unity Trainers

gmelnik — Sat, 15 Aug 2009 01:50:00 GMT

If you are offering industrial or academic courses or workshops that use Enterprise Library or Unity, I hope you are already taking advantage of our updated Hands-On Labs. I would like to know what else we could do to better support you and the learners.

Please reply to this post or ping me directly. You may also want to send me your syllabus and we’ll consider profiling you under the Learning section of our Codeplex site.

- Grigori

Showcasing patterns & practices’ goodness

gmelnik — Fri, 14 Aug 2009 07:54:00 GMT

These are some of the events I’ll be presenting at in the next couple of months:

Patterns & Practices Conference Ukraine, Kiev, Sep 16, 2009 (www.pnp.in.ua)
Patterns & Practices Summit Russia, Moscow, Sep 22, 2009 (www.pnpsummit.ru)
Patterns & Practices Summit Redmond, Oct 12-16, 2009 (www.pnpsummit.com)
TechEd EMEA, Berlin, Nov 9-13, 2009 (www.msteched.com)

Whether you are using Enterprise Library or any other p&p asset, I’d be happy to chat with you about your experience. Look forward to it!

Unity 2.0 container update

gmelnik — Thu, 16 Jul 2009 21:18:56 GMT

Our latest work on Unity 2.0 is available on Codeplex (see change set 28516). This is the first work we’ve done on Unity as part of the EntLib5.0 effort.

Major changes in this drop include:

ObjectBuilder2 DLL is now gone. The code is now completely contained in the Unity assembly, and you won't need to reference OB2 anymore in your projects using Unity. Over time the ObjectBuilder stuff is going to lose a lot of it's generality and be just the underpinnings for the container.
We're taking a first cut at fixing our exception messages. All the extra BuildFailedException’s that ended up in the inner exception tree are now GONE. Instead, you get a top level ResolutionFailedException, and the InnerException is the actual exception that caused resolution to fail. And the exception message has been reformatted significantly to hopefully get a better description of what the container was doing, and how it ended up where it did, when the error occurred. This is in response to user feedback to provide better error messaging in Unity. We consider this to be a significant improvement, but still need your feedback. In particular, we look forward to specific suggestions about how we could change the messages to be even more descriptive and intuitive. Please reply to this post or via Codeplex discussion thread.
Silverlight projects are now updated to Silverlight 3.

Acceptance Test Engineering Guide, volume 1 BETA2 release

gmelnik — Wed, 01 Jul 2009 03:30:00 GMT

Today I am pleased to announce the release of the beta2 of the first volume of our Acceptance Test Engineering Guide. We are getting closer to “done”.

As it became apparent that the primary reader personas for each part in the original guide (that was released as beta1) were different and the size of the guide was approaching 800 pages, we decided to split it into 3 volumes. It allows us to ship Volume I sooner while finishing Volume II and III. Incremental delivery for the win!

Based on the first round of reviews, Volume I has undergone some serious rewriting (especially, the Gating model, which is now called the Acceptance Process Model) and the entire new chapters were added (Part II – Perspectives on Acceptance).

Here’s the current structure of the guide:

Volume I provides an overview of the acceptance process and how acceptance testing and other key practices fit into the process. This volume is intended to be read from beginning to end. It is subdivided into three main parts:

Part I – Thinking about Acceptance explains six mental models that are useful when thinking about the acceptance process.

Chapter 1 The Acceptance Process
Chapter 2 Decision-Making Model
Chapter 3 Project Context Model
Chapter 4 System Requirements Model
Chapter 5 Risk Model
Chapter 6 Doneness Model

Part II – Perspectives on Acceptance describes the acceptance process from the perspectives of key stakeholders in two different kinds of organizations: the Information Technology Department in a business and the Product Development Company. Most readers involved in the acceptance process should find some commonality with at least one of the roles describes.

Chapter 7 Business Lead’s Perspective
Chapter 8 Product Manager’s Perspective
Chapter 9 Test Manager’s Perspective
Chapter 10 Development Manager’s Perspective
Chapter 11 User Experience Specialist’s Perspective
Chapter 12 Operations Manager’s Perspective
Chapter 13 Solution Architect’s Perspective
Chapter 14 Enterprise Architect’s Perspective
Chapter 15 Legal Perspective

Part III – Accepting Software introduces the practices that are necessary for planning the acceptance process, for performing acceptance testing and for improving the acceptance process.

Chapter 16 Planning for Acceptance
Chapter 17 Assessing Software
Chapter 18 Managing the Acceptance Process
Chapter 19 Streamlining the Acceptance Process

Volume II is a collection of what we call thumbnails that describe the practices introduced in Volume I in more detail. A thumbnail is a short overview of a practice that explains what it is, when you may want to use it, the risks that it mitigates, and an overview of how to perform the practice. Thumbnails also include a list of references to papers, books, and other resources that provide more complete descriptions of the practices in question. The main purpose of a thumbnail is to describe a topic well enough to provide an overview, serve as a mental reminder for someone who has used the practice on how to do it, and give someone unfamiliar with the practice enough information about the practice and its applicability to determine if they want to learn more about it. Some of these topics and practices have entire books written about them that describe the concepts in greater detail and depth than this guide could possibly do. Volume II is intended to be used as a reference; most readers will not read it from beginning to end.

Volume III. This volume is a collection of sample artifacts generated by applying different practices in a fictional but realistic situation for the fictional company Global Bank. These artifacts are embedded in a series of case studies of what the Global Bank team may have produced while building the application. The case studies provide some context to the individual artifacts. They also provide cross-references to the practices described in Volume II. The artifacts are intended to be used as way to learn more about how to perform a practice; they can also be used as templates for your own artifacts.

As always, we look forward to your feedback! Feel free to submit it through the Codeplex site (Issue Tracker or Discussion Forum) or simply email it to me.

Enterprise Library 5.0: Architectural refactoring complete

gmelnik — Fri, 26 Jun 2009 01:19:45 GMT

The highest priority story in the EntLib5 backlog is ARC01: Architectural refactoring, which includes the use of a dependency injection container for wiring your EntLib objects instead of the one-off ObjectBuilder factories and DI container independence (to allow other containers such Spring.NET, Castle/Windsor, StructureMap, Ninject etc. to be used instead of Unity if you prefer so). This work is now complete. For details of this architectural update, please see an easy-to-read summary by Bob Brumfield. We also touch on this in the channel9 video.

As usual, the updated bits are available for preview on Codeplex - http://entlib.codeplex.com/SourceControl/ListDownloadableCommits.aspx

Video on what’s coming in EntLib 5.0

gmelnik — Fri, 26 Jun 2009 01:01:11 GMT

In this channel9 video, Chris and I give a 10,000 ft view on what’s coming in EntLib5.0. For details, consult our product backlog.

Thoughts on improving performance of the Logging Application Block

gmelnik — Fri, 19 Jun 2009 20:16:44 GMT

EntLib5 team is working on improving performance of the logging block (story LAB02 in our product backlog). We’ve identified that message formatting in particular takes substantial amount of time based on our own performance tests and customer reports. So, we are considering alternatives. One of them is improving performance of the formatting operations and another one is doing formatting and logging asynchronously, thus offloading the formatting work to a separate thread and improving perceived performance. Note, this discussion is not about optimizing the message formatting mechanism, which we may address separately.

Our intention is to implement these improvements on the opt-in basis to preserve the default behavior of the Logging Block consistent with the previous versions of the EntLib.

Here are the possible limitations we’ve identified when doing formatting and logging asynchronously:

1. When using the Logging Block, it is possible to utilize non-EntLib-specific .NET trace listeners (such as console, debug, eventlog, etc.). These trace listeners use TraceEventCache object to obtain context information, including thread-specific information, which we cannot control. This means that performing the logging operation in a thread different than the originating one may result in the log entry that has inaccurate context information.

2. Besides, the TraceEventCache also supplies the call stack, which we can force to be pre-computed in the originating thread. However, this turns out to be very expensive and likely be a waste since not all trace listeners would require it. Options include:

a. Pre-compute always

b. User elects to pre-compute via configuration

c. Add logic to the block to determine whether pre-compute is necessary based on the configuration of the trace listeners

Note, this is not the call stack you would care about when logging exceptions through the LoggingHandler of the Exception Handling Application Block. In this scenario, the actual message (together with the call stack) gets formed before a call to the Logging Block is even made.

3. With this approach, there is no guarantee that all log entries are effectively logged. For example, if a log entry posted just before the application terminates, it’s possible that the logging thread may not complete its processing.

We’d like to understand which logging characteristics you care about. Among the following, please select top 3 that matter to you:

A. Maintain the chronological order of log entries

B. Avoid depletion of the thread pool

C. Minimize the lag time between post of the log entry and its persistence (this would reduce the risk of losing posted entries)

D. Start throttling to avoid unbound memory consumption

E. Ability to provide custom logging strategies (such as async logging) to be plugged-in

F. Ability to elect which categories/trace listeners use async or sync logging mechanism

Based on relative importance of these choices, we will select a design direction ranging from using the thread pool to implementing more sophisticated thread and data management.

With your votes (feel free to reply to this post or send Grigori an email), please describe the context driving your choices and any other comments or concerns we may have overlooked.

We would appreciate your rapid feedback – if you care for this story, please do not wait with your response.

Taking User Experience Seriously

gmelnik — Thu, 14 May 2009 09:14:51 GMT

As I have mentioned in my previous posts, over the years, Enterprise Library grew large (it now includes 9 application blocks), and arguably more complex than it really needs to be. With v5, we are focusing on enhanced user experience, simplicity, and learnability. We are tackling these goals from several dimensions: architectural refactoring to simplify our code base and make it easier for users to extend EntLib; improving our config experience through the config tool; and writing more approachable guides. Let me describe these in a bit more detail.

Simplifying the underlying architecture

The creation of EntLib objects is, on the surface, pretty simple. You call into the appropriate factory, stuff happens, the current configuration is read, and the appropriate instances are returned to you. Of course, the aforementioned “stuff” gets rather complex. Every EntLib object requires the object itself, a Data class describing the configuration, a custom factory class, and (usually) an assembler class, plus a bunch of attributes scattered around to wire them all up together. Maintaining all these moving parts can be challenging to the uninitiated, and this is a major barrier to people who want to build their own blocks or extensions.

At its heart, the ObjectBuilder infrastructure (and the factories and assemblers, etc.) was really a very specialized dependency injection framework. With the basic idea of DI moving into the mainstream, we took the opportunity to revisit this design. We are replacing all our custom object creation infrastructure with a dependency injection container plus methods that properly configure the container. The net result is the removal of a lot of moving parts, which simplifies the codebase significantly. You no longer have to wade through quite so much infrastructure to get to the real meat of what Entlib is doing. And switching to a full-featured DI container also gives us much more flexibility, both in Entlib and in how it interacts with your applications.

Usability of the config tool experience

The config tool (available as a standalone application, or as an integrated configuration editor with Visual Studio starting with EntLib v3) was a major step forward in creating, modifying, and validating application block settings. No one wants to manually tweak xml configuration. The tool has not undergone any major changes since v1. It uses a tree-based interface that, according to some anecdotal evidence, users find not very intuitive. There also seem to be some conceptual barriers in connecting various parts. We would like to understand the current user experience and improve it in v5, specifically in regards to:

Approachability and usability. Important goals are increasing efficiency of use and reducing pain points associated with common tasks.
Extensibility is a key feature of EntLib. The new design for the configuration tool must be robust and flexible enough to support multiple types of user customization and also scale with future EntLib releases.

In order to do this methodically, we are partnering with seasoned user experience researchers (Kelly Franznick and Jen Amsterlaw of Blink Interactive) and executing on the following plan:

1) Baseline usability testing of the v4.1 config tool. This is needed to identify areas for improvement, and as a standard to compare to the new tool, once it is designed and implemented. We are targeting .NET developers who are fairly new to EntLib (1-3 months of experience) and IT Operations/Admins who are new to EntLib. By asking users to perform specific tasks in a controlled and moderated setting, we are focusing on specific areas of concern, including processes that require conceptual understanding to assess learning curve issues. We are currently doing this at TechEd in LA. If you are interested in participating, stop by the p&p booth on the exhibit floor (blue area).

2) User research. This will involve interviewing existing end users to understand their goals, motivations, and perceptions of the overall EntLib experience. Together with the results of the baseline usability testing, the user research will inform the next phase, which will focus on interaction design.

3) Interaction design. During this phase, three distinct concepts will be designed to reflect the major workflows of the EntLib improved config. These will be presented in the form of wireframe prototypes.

4) Prototype usability testing will test these prototypes.

Based on the results of these studies, we will analyze the feasibility of implementing the best prototype and build the new tool. I will keep the community updated about how these activities are going.

Learnability

Our current set of docs includes over 1000 pages. We understand that no one has time to read all of that information, some of which has more details that most users need. To address this, we are experimenting with a new style of documentation — Developer Notes. These are written in a more informal, conversational style, are task based and are meant to be more approachable. The key here is for users to be able to quickly find out how to do common tasks with EntLib (thus, we are limiting the size of the guide to be under 200 pages total). Chapter 1. Meet the Librarian and Chapter 3. Error Management Made Exceptionally Easy are available for preview and public commenting.

The first 50 people who provide thoughtful feedback will receive a complete copy of the book once it is out.

Hope these three initiatives give you a good indication of how seriously the EntLib team takes user experience. If you have other suggestions, we welcome them as well.

Back to TechEd crowd now…

EntLibContrib – May 2009 Release and future plans

gmelnik — Wed, 06 May 2009 02:02:59 GMT

Two of our community champions François Tanguay and Stephen Phillips just pushed out a new release of EntLibContrib. This is the final round-up of all of the user contributions built around the Enterprise Library v3.1 core. They are now working on the upgrade to the EntLib v4.1 core.

The latest release of EntLibContrib contains the following functionality:

Common Block extensions
- TypeConfigurationElement<T>, AnonymousConfigurationElement
Data Access Application Block extensions
- MySql, SQLite and SqlEx providers
Exception Handling Application Block extensions
- SqlException Wrap Handler
Logging Application Block extensions
- LogParser, TimeStampParser
Policy Injection Application Block extensions
- PostSharp4EntLib
- New matching rules: And, Or and Not
- New call handlers: CursorCallHandler, OneWayCallHandler, SynchronizedCallHandler, ThreadSafeCallHandler, TransactionScopeCallHandler
Resource Application Block 3.1
- Configurable providers for Globalization and Localization
- Full application block complete with support for the console, instrumentation and group policies
Validation Application Block extensions
- New validators: CollectionCountValidator, CompositeRulesetValidator, TypeValidator<T>, ObjectValidator<T>, EnumDefinedValidator
- Designtime enhancements: Lightweight type picker, Test command
- Other extensions: Default validators, Argument Validation, ExternallyConfigurableObjectValidator

The Enterprise Library Contribution Project is to be revamped and upgraded to work from the Entlib v4.1 core - This will also include VS2008 solutions and projects and be built using .NET framework v3.5 SP1. To start the ball rolling the Resource Application Block has been upgraded to v4.1 and a new Query Application Block v4.1 has been added to provide the next level of integration for data storage. With the DAAB you got separation from the Database vendor with QAB you get separation from the data storage type with providers for the DAAB, Xml files and Web Services.

Other separate releases hosted on the EntLibContrib site are:

Standalone Validation Application Block 1.2: adds deep WPF automatic object validating data-binding via a new ValidationBinding markup extension.
Extended SQL Data Access Block 3.1.1: Now integrated into the main EntLibContrib release.

Other contributions in the source code but not in the latest release:

Query Application Block 4.1 New - Next level of integration up from the DAAB providing a common interface for data stored in a DB, XML file or Web/WCF service
Resource Application Block 4.1 New - Upgraded to include Unity integration and to work with EntLib4.1 core and VS2008
The Application Block Software Factory (needs GAX)
The Strong-Naming Guidance Package (needs GAX)

Kudos to Stephen and François! Great job, community! It’s good to see passion around improving and extending the EntLib. I would like to acknowledge the following contributions and contributors in particular:

MySQL Data provider = Wesley Hobbie
SQLite Data Provider = Kenneth Scott
Extended SQL Data Provider = Chris Dufour
SQL Exception Wrap Handler = Tom Hollander
LogParser = Alois Kraus, Randy E. and Mark Seemann
PostSharp4EntLib = Gael Fraiteur
Policy Injection Extensions = Olaf Conijn and François Tanguay
Resource Application Block = Steve Phillips
Validation Application Block extensions = Tom Hollander, Olaf Conijn, Martin Lapierre, Martin Bennedik and François Tanguay
Standalone VAB = Daniel Cazzulino
Common Extensions = Francois Tanguay

Look forward to the next EntLibContrib release!

Enterprise Library 5.0 … and we’re off!

gmelnik — Mon, 20 Apr 2009 20:56:37 GMT

We have officially started our development work on EntLib5.0. Earlier I’ve shared our product backlog, which was largely driven by you, the community. Our initial plan is to ship in early 2010.

If you want to stay tuned with what we’re doing, the best way is to keep an eye on the home page of our community site at http://codeplex.com/entlib. Here, you can view recent posts aggregated from individual team members’ blogs, participate in online discussions, get the most recent bits of code, see file bugs/issues, and access other useful resources.

As you probably know, we run our projects in agile fashion (XP@Scrum). For those wondering, yes, we do perform TDD, pairing (I kid you not! – even distributed pairing), automated acceptance testing, refactoring, daily standups, regular retrospectives, customer proxy demos, and iteration planning; plus frequent releases, continuous integration, collective code/content ownership, low-fi information radiators, and progress tracking. We are working in two-week iterations and will be doing regular source drops on Codeplex.

Now it’s time to introduce the mighty team. You will recognize some familiar faces (many of us have worked on one or more of the previous EntLib releases) and also see some new ones. I am privileged to work with this group of accomplished professionals. I give you… <drum roll please>:

from left to right: David Hill (architect), Alex Homer (documentation and user experience lead/writer), Chris Tavares (dev lead/architect), Bob Brumfield (dev/architect), Fernando Simonazzi (dev/architect), François Tanguay (system test/dev), Nelly Delgado (release lead), Grigori Melnik (product owner/program manager). Not shown are: Rohit Sharma (test lead), RoAnn Corbisier (technical writer/content coordinator), Dennis DeWitt (technical writer), Carlos Farre (perf test consultant), Mani Krishnaswami (test), Nicolas Botto (system test/dev), Olaf Conijn (dev), Mr X (security test).

For the kickoff iteration, we were able to get the core of the team together in Redmond. The level of energy was remarkable! This team has all necessary expertise, diversity of perspectives, and desire to deliver even more goodness and value with EntLib v5.0.

You should realize that, in reality, the team is way bigger. It includes 20 members of the advisory board who we meet with on a regular basis (every 2-3 weeks). These experts help steer our direction. I must say that they are quite direct and honest, and are not shy in pushing back on any of our ideas that don’t make sense to them or do not provide sufficient value for the buck. The advisory board is representative of our target audience with experts from large and small companies, from a wide variety of domains (such as retail, transportation, government, insurance, finance, military, health care, education, media, IT services, and more).

We are also leveraging much of the learning from the previous four major releases of EntLib. Therefore, we appreciate everyone who has ever been a part of the EntLib team. We are smarter today because of you!

In addition, seven members of the patterns & practices directorate (John deVadoss, Ade Miller, Ajoy Krishnamoorthy, Don Smith, Javed Sikander, Mohammad Al-Sabt, and Steve Elston) blessed our project. Their trust and support in our abilities to self-organize and self-manage are real tokens of confidence.

All other teams at patterns & practices are involved and provide their feedback informally on the daily basis. We also interact with many members of other Microsoft product groups via regular workshops, brownbags, and internal discussion forums (with 300+ members).

I would also like to acknowledge our sustained engineering team from Avanade, who have been doing a terrific job in providing online technical support.

And, of course, you – the community! Anyone who ever participated in our surveys, submitted requests/bug reports through Codeplex, shared their EntLib extensions via EntLibContrib, participated in the customer workshops, came to our booth at the conventions (TechEd, PDC, p&p summit, etc.), or in any other way provided feedback or suggestions has contributed to this development effort. For that, we salute and thank you! We build EntLib for you and with you!

We all look forward to yet another exciting ride developing EntLib v5.0!

Enterprise Library 5.0: Product Backlog prioritization results

gmelnik — Thu, 16 Apr 2009 21:50:00 GMT

Some two weeks ago, we exposed the preliminary product backlog for Enterprise Library 5.0 and invited the community to vote on the features that matter to them most. And what a response we got! Over 2,600 people viewed the backlog and 981 cast their votes, with 230 troopers persevering to the very end. 18 members of the EntLib Expert Advisory Board also voted. In this post I would like thank you all for taking the time to complete the survey, and I want to share the results with you.

In retrospective, every previous EntLib release had a theme:

1.0 = Integration of application blocks
2.0 = .NET 2.0 update
3.0 = Validation, PIAB, Block Factory
4.0 = Dependency Injection with Unity, WMI 2.0

Over the years, EntLib grew larger, and arguably more complex than it really needs to be. The community has spoken loud and clear that they want EntLib to be easier to learn and to use. We have taken this feedback seriously, and have decided to focus this release on enhanced user experience, simplicity, and learnability. The working slogan is “Simplicity for the Win!”.

So, getting back to the product backlog. Let me explain the methodology we used to analyze the data. Stories voted as Priority 1 got 20 points, Priority 2 got 19 points, Priority 3 got 18 points, and so on, with Priority 20 getting only 1 point. Votes from our team of expert advisors’ carried double weight. Then, for each story, we calculated an arithmetic sum (the total number of points), and - using these numbers - ranked all of the stories (obviously the story with the most points was ranked as #1).

Based on past experience, we didn’t want to plan our development execution in the strict natural order of story rank, because this would require juggling various blocks within each iteration, and potentially create silos of experts around each block. Instead, we wanted an iteration to have a theme that the entire team can focus on. Therefore, we decided to carry out affinity mapping of stories for each block, and calculate their group weightings (ignoring all stories with ranks 50 and higher, since those automatically made our P3 bucket and so are not likely to be done). We then stack ranked the P1 groups (colored green in the following table) and we plan to address them in the stack ranked order, with the individual stories inside the group still ranked according to the original scores. Note that learnability and user experience stories will be addressed in parallel with all the development stories throughout the entire project, and -therefore - those groups are listed near the top of the backlog.

Total points	Rank	Description (T-shirt size)
*Architecture*
2910	1	ARC01 : Architectural update: use DI container instead of one-off Object Builder factories; DI container independence (XL)
2164	2	ARC02 : Simplification of the codebase (identify redundancies, obsoletes etc.) (XL)
1898	6	ARC03 : Reduction of the number of assemblies (XL)
*Learnability*
2082	4	LEARN03: Notebook-style 150 page book for Enterprise Developers (XXL)
1400	12	LEARN02: Notebook-style 150 page book for Architects (XXL)
1338	14	LEARN08: Updated Quickstarts (XL)
976	22	LEARN09: Updated Hands-on Labs (XXL)
590	37	LEARN10: EntLib Overview Video (L)
524	42	LEARN07: Migration guide v.4.1 ->5.0 (L)
*User Experience*
1876	8	UX05: Config tool facelift - towards a more intuitive and easier to use UI (XL)
1718	10	UX03: Config IntelliSense for Unity and EntLib in XmlEditor (M)
1610	15	UX01: Better error reporting/messaging throughout (M)
1010	28	UX02: Debugging Visualizer for Unity (L)
744	36	UX04: Config IntelliSense for Unity in XmlEditor (M)
*Data Access*
2652	3	DAAB01: DAAB & LINQ basic integration (i.e. execute a query on a database, get back an object that you can do LINQ on) (M)
2012	9	DAAB02: Async ADO.NET support (M)
1390	16	DAAB04: No swallowing of SQL exceptions (S)
*Logging*
2006	7	LAB02: Async logging (text formatting done asynchronously) to cut down on load on primary thread (M)
1100	17	LAB03: Automatically purging old files by the rolling trace listener (S)
*Tool support*
1516	13	TOOL02: Support of Unity configuration (M)
*Unity*
1072	19	UIN01: Generalized interceptor (XXL)
1108	20	U06: Clearer error reporting (M)
1042	23	U05: Unity-MEF Integration (e.g. unityContainer.Resolve<MefPart>()) (M)
896	24	U03: Support for passing arguments to the Resolve method (M)
*Config*
1962	11	CFG01 : Config decentralization (support for config stored in multiple sources) (S)
1276	18	CFG05: Making Unity configuration less verbose (M)
1072	21	CFG07: Unity config auto-registration: expanded conventions and helper classes to reduce need for explicit configuration (M)
804	34	CFG02: Improved Config API (XL)
850	38	CFG03: Support for different sections of config in different media (not just files) (XL)
*Validation*
2438	5	VAB01: Integration with WPF (XL)
1020	25	VAB04: Decorating LINQ objects with Validation attributes (M)
944	26	VAB02: Integration with/assistance in implementing IDataErrorInfo (S)
840	33	VAB07: Validation Block refactoring to allow using Unity to resolve Validators (M)
570	40	VAB12: Inheritance-aware object validator (M or ?)
*Installability/Uninstallability*
858	29	INS01: Installer allows you to pick which specific blocks to install instead of the whole package (M)
864	31	INS03: EntLib installers to be included as part of installers of other custom products (merge modules) (M)
*Extensibility*
1028	30	EXT01: Simplifying writing extensions and plugging their custom configs into the config tool (XXL)
*PIAB*
784	32	PIAB01: Implement PIAB interface that takes an interceptor type (to leverage new Unity interceptors) (S)
718	35	PIAB03: New handlers (incl. RequiresTransaction and Call Forwarding) (S)
*Resource management*
996	27	RAB03: Resource Application Block (a provider to get assorted resources from various media/sources) (XXL)
*Localizability*
834	39	LOC01: Localizability of EntLib assemblies (L)
752	41	LOC02: Localizability of exception messages and templates (S)

Stories in P2 (yellow in the following table) and P3 (red) categories are listed according to their ranks, and not group ranks. Should time permit, we will address the P2 stories in the order shown.

P2
614	43	LEARN01: Discoverability and context/dependencies EntLib poster (L)
556	44	LEARN11: EntLib5.0 New Features Video (L)
682	45	EHAB02: Parameterized templates for exceptions (M)
572	46	TOOL01: Type picker improvements (sped up search, better generics UI) (M)
516	47	U04: Container introspection (S)
590	48	LEARN12: Unity Overview Video (L)
500	49	VAB06: Simple validating field only if the value is not null (S)
590	50	VAB13: Support for recursive data structures (M)
496	51	U02: Allow a mapping from a named registration to the "default" one (S)
506	54	VAB08: Enabling Validation Block to be used with 3rd party object relational mappers (M)
482	55	VAB09: Honouring validation attributes defined in System.ComponentModel.DataAnnotations (S)
468	59	LEARN04: Notebook-style 100 page book for Operations/IT management (XXL)
394	65	VAB03: ArgumentValidationException.ToString() show the validation results (S)
P3
500	52	UIN02: Caching of matching policies (M)
608	53	DAAB03: Fix: validation of sprocs parameters – do not validate (S)
496	56	LAB04: Authenticated Email Trace Listener (S)
430	57	CFG06: Support other config schemas for Unity config (e.g. XAML-based config)
402	58	U01: ResolveAll to return unnamed registration too (S)
390	60	LAB01: ETW sink (?, potentially XXL)
422	61	LEARN14: Unity Extensibility Guide (XL)
424	62	VAB16: Additional validator: Validator that checks that an enum contains a value that maps onto its defined values (S)
404	63	INS02: Installer ships both debug and release versions of the DLLs (S)
546	64	CFG04: Support for multiple pieces of config for a single block in multiple places (XXL)
412	66	EHAB01: Default post-handling action to ThrowNewException instead of NotifyRethrow (S)
378	67	TOOL04: Web-based config tool (L)
372	68	CACHE01: Adding a reason to the class that informs a user why their object was removed from the cache (S)
409	69	LEARN15: Guidance on environmental overrides in Unity (S)
409	70	LEARN15: Unity& MEF decision tree/matrix (M)
344	71	VAB14: Provide NullValidator to properly "ignore nulls" instead of the "Or composite" (S-M)
390	72	CACHE02: Cache backing store targeting ESENT (L)
352	73	VAB15: Additional validator: Number of decimal places validator (S)
292	74	PIAB02: Add non-generic overloads (S)
344	75	VAB05: Simplifying checking for positive / negative values (S)
282	76	LEARN05: Migration guide v.2.0 ->5.0 (XL)
266	77	VAB11: Better localization support (i.e. the first time the validator is used, the locale for the messages is defined) (M)
270	78	VAB18: RelativeDateTimeValidator update to compare against UtcNow instead of Now (S)
238	79	VAB10: Honouring MetadataType attribute (M)
238	80	TOOL03: Block invocation from the configuration designer (e.g. Configure a block, Right-click, Copy “Code to Invoke”, and then paste it elsewhere) (S)
234	81	TOOL05: Easier manipulation of validation trees (potentially, drag&drop) (M)
238	82	VAB17: Validator that compares against a single specific value (S)
196	83	LEARN06: Migration guide v.3.1 ->5.0 (XL)
162	84	LEARN13: Unity Extensibility Video (L)

The initial request for a Business Rules Application Block (which would help developers to take advantage of the WF business rule engine without creating a workflow) has been evaluated, and we solicited additional feedback from the advisors and the community. We didn’t see much convergence on the scenarios, and concluded that - at this point - we would not be playing in this area.

With regard to the platform we will target, originally our plan was to target binaries to version 4.0 of the .NET Framework. However, our advisors and the community pushed back on this. The result from 1,229 votes is shown in the following graph:

This data is significant enough for us to adjust our plans to meet the community needs, and so we will target the binaries to version 3.5 SP1 of the .NET Framework. We will also carry out our test path on version 4.0 of the .NET Framework to ensure compatibility.

A similar question was asked about the framework version to which we should target Unity. The graph below shows the result of the votes, and so the decision is similar to that for EntLib 5.0. We will be targeting version 3.5 SP1, but also testing on version 4.0.

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

gmelnik — Fri, 27 Mar 2009 09:01:00 GMT

EntLib Community!

First of all, let me thank all of those who actively took part in providing their ideas and suggestions for the next version of EntLib. There are over 50 comments posted to my original invite and a similar number of emails, all of which have been reviewed by the EntLib team. In addition, we have analyzed the results of the EntLib satisfaction survey, examined discussions and issues posted on the EntLib community site and conducted extensive consultations with the members of our Advisory Board.

The list included over 100 items, most of which are exposed now. If we missed anything important there is still room for you to add some suggestions of your own.

We have also done “T-shirt sizing” of the stories – a rough, relative estimation of the effort involved in delivering a given story.

At this point, we would like to invite you to select and prioritize candidate features/stories you care about. Please review them carefully along with the associated effort estimates and cast your votes. Do remember to stay within the budget (100 points). Here’s the link to the online survey.

NOTE: Due to the limitation of the surveying tool that doesn’t permit ranking matrices wider than 10, I had to flatten the survey that resulted in the 2nd page being rather long. It does NOT require you to answer all 20 questions though. You can vote for as few as top 5 and then move to the next page and vote for Integration Packs. Also note, that the backlog with the codes is posted on a separate page (see the link in the survey) and you can open it in a separate window, screen or print for referencing. Alternatively, simply review the backlog and take notes of the features you care about and then simply select them as your priorities.

We will analyze the results and produce the prioritized backlog defining what the team will focus on in the next several months. We will share the results of the prioritization exercise with the community.