Grigori Melnik: Thoughts on Agile Software Engineering and Beyond : Unity

Powered by EntLib

gmelnik — Fri, 13 Nov 2009 12:30:00 GMT

When speaking about or demoing EntLib, I often get asked which Microsoft products Enterprise Library is used in. There are several dozen internal Microsoft projects (that we know of) that take advantage of Enterprise Library. However, many people are particularly interested in commercial products that use it. Today I am able to speak about some of them.

This Monday the Microsoft Exchange team announced the public launch of Exchange Server 2010. There are many innovations in it, which you can read about on the Microsoft Exchange Teamblog. The reason I mention it here, however, is not only to congratulate the Exchange team, but also to proudly share the news that Enterprise Library and Unity container are used by Exchange Server 2010.

In addition, the Enterprise Service Bus (ESB) Toolkit 2.0, which is now part of Microsoft BizTalk Server 2009 also uses Enterprise Library 4.1 and Unity 1.2

Through the course of my interactions with many customers, I’ve compiled an extensive list of companies that use Enterprise Library (including 50 Fortune 500 companies). Unfortunately, I do not have permission to share many of their names. However, you can find some of the case studies published here. In addition, you can explore Microsoft Solution Finder and search for projects with “Enterprise Library” as a keyword.

These endorsements are a clear indication of the value that Enterprise Library provides to Microsoft product groups, our customers and partners.

I would also like to use this opportunity to invite customers who would like to share their story, and be profiled on our patterns & practices development center page, to contact me.

Dependency Injection pattern in APIs

gmelnik — Fri, 13 Nov 2009 00:44:20 GMT

My colleague and friend Chris Tavares, who is the Dev Lead on Enterprise Library and Unity, published an insightful article in MSDN magazine on the usage of DI in APIs, which I highly recommend. It is based on our recent experience of doing architectural refactoring of the Enterprise Library. It outlines our design objectives and the approach taken to meet them. It concludes with lessons learnt and key considerations when designing your own API or framework.

Read Chris’s article here.

Grigori at PDC

gmelnik — Wed, 11 Nov 2009 13:54:22 GMT

I’ll be at PDC2009 in LA next week. I’ll be happy to meet with EntLib and Unity users as well as critics, to discuss new features of EntLib 5.0, preview the new config experience and also solicit suggestions for post v5 work.

If you’d like to discuss acceptance testing and test automation strategies, I’d be interested in that too.

Look for me at the p&p booth Mon-Thu or ping me to set specific time to meet.

See you there.

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.

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

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.

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

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.

Just Released – Hands-on Labs for Enterprise Library 4.1 and Unity 1.2

gmelnik — Thu, 19 Mar 2009 02:38:00 GMT

I know it’s easy to get lost in the plethora of announcements and buzz from MIX’09, but today we are releasing a set of hands-on labs for all the application blocks in Enterprise Library. We believe that this valuable release will not go unnoticed by the community of devoted EntLib users and want to take this opportunity to highlight it for new users as well. After all, the labs are meant to help you get up to speed with EntLib.

This release includes a refresh of the 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

There are also two entirely new hands-on labs covering Interception and Dependency Injection with Unity. The Validation Block hands-on lab was released back in December and the overwhelmingly positive feedback we’ve received on it encouraged the team to produce the rest.

You can download the entire set in both C# and Visual Basic .NET: Hands-on Labs for Enterprise Library 4.1
If you prefer to download the Unity lab as a standalone, it’s also available: Hands-on Labs for the Unity Application Block 1.2

You can do them in any order. They will guide you through common scenarios of using EntLib in various application contexts. Some labs go into advanced topics and you may want do them a couple of times. Also, don’t be shy about improvising and departing from the scenarios written in the lab instructions.

The labs may also be of value to trainers and academics, since they can be used as teaching aids in the classes devoted to Enterprise Library specifically or in courses on Component-Based Software Engineering, Enterprise Application Development, and Aspect-Oriented Programming.

With this release, the EntLib team reiterates its commitment to enhancing learnability and increasing ease of use of Enterprise Library. Please, try them. Whether you love them or feel frustrated (especially if you feel frustrated), please send us your feedback.

Enterprise Library 5 – what’s on your wish list?

gmelnik — Tue, 27 Jan 2009 08:55:40 GMT

We’ve started our planning of the Enterprise Library 5. This is your chance to send us suggestions, comments, screams... These may include ideas for new blocks, new providers for existing blocks, integration with new .NET Framework 4.0 features, improvements to the design-time experience, performance improvements, support of specific deployment/operations scenarios, documentation/training support etc.

I am going to use the same technique Tom employed several years ago soliciting feature requests for EntLib3. It seemed to work quite well then. So, imagine you have a sum of money that you can invest in developing EntLib 5. Say $100 (or should I index the amount to be more like a stimulus package? :) In any case, when suggesting your features, decide how much of that $100 you want to spend for each feature. You can split $100 any way you want. If there is only one feature you want to spend all your money on, you can do it too. Please stay within the budget. Also, be specific – explain your scenario in detail, provide some context, make your case potentially appealing to other users of EntLib. Do remember, however, that EntLib has been and will be a general purpose library of reusable components that are architecture- and application domain-agnostic.

Once we gather your feedback, we will publish the list of feature requests and invite you to prioritize them.

Feel free to post your suggestions as comments on my blog or simply email me. Look forward to your propositions!

Thanks!

Just Released: Unity Application Block 1.2 for Silverlight

gmelnik — Sun, 14 Dec 2008 11:01:41 GMT

If you are building rich application experiences in Silverlight, you can now use the power of dependency injection. It was possible to use Unity on Silverlight before, but you had to make some tweaks since Silverlight has some differences from the desktop common language runtime (CLR). We are happy to announce the official release of Unity for Silverlight.

The following capabilities and packaging of the Unity container have been adjusted in this release:

The single Microsoft.Practices.Unity.dll file in the Silverlight version contains all the classes from the three separate desktop DLLs: Microsoft.Practices.Unity.dll, Microsoft.Practices.ObjectBuilder2.dll, and Microsoft.Practices.Unity.StaticFactoryExtension.dll. You only need to reference and deploy the one assembly in your Silverlight projects.
Because of differences in the Silverlight security model, only public types can be created and injected by the container. The desktop version allows you to also inject internal types.
XML configuration is not supported.
The Unity interception mechanism is not supported.

An updated quickstart is also included.

See Chris’s post for more details on how this release was produced.

As always, submit your feedback and/or questions via Unity community forum.

Merry Christmas! and … Joyous Coding!

What is Enterprise Library team currently up to?

gmelnik — Fri, 12 Dec 2008 01:10:00 GMT

After shipping Enterprise Library v4.1, the team is focusing on the ease-of-use and learnability aspects of both EntLib and Unity. Our top stories of the current backlog include the following:

Unity for Silverlight [Done - 12/14/2008]
Comprehensive Enterprise Library FAQs [Done - 2/10/2009]
Validation Block Hands-on Lab [Done - 1/3/2009]
Interception Hands-on Lab [Done - 3/18/2009]
Unity Extensibility documentation [In Dev]
New video on Unity (level 200)
New video on Unity Extensibility (level 400)
Customer satisfaction survey analysis [Done]

These are all things we plan on doing prior to starting Enterprise Library v5 research and planning work early next year.

Just Released: Microsoft Enterprise Library 4.1 and Unity 1.2

gmelnik — Tue, 28 Oct 2008 23:17:00 GMT

From the floor of the Los Angeles Convention Center, I am writing this message in between many exciting PDC sessions and conversations with customers of Enterprise Library and other p&p assets.

Microsoft patterns & practices is pleased to announce the twin release of Microsoft Enterprise Library 4.1 and Unity 1.2.

What’s New in Enterprise Library v4.1?

This release of Enterprise Library is a service release that includes the following:

– Unity interception mechanism and integration of the Policy Injection Application Block with the Unity Application Block;

– Performance improvements;

– Usability improvements to the configuration tool;

– Visual Studio 2008 Service Pack 1 support;

– Bug fixes.

For the detailed list of all changes, see About This Release of Enterprise Library.

What’s New in Unity v1.2?

− Added an interception mechanism (extension);

− Added two instance interceptors (TransparentProxyInterceptor, InterfaceInterceptor) and one type interceptor (VirtualMethodInterceptor);

− Improved support for generics;

− Added support for arrays;

− Registered names are now available as an ObjectBuilder policy so that you can do a ResolveAll from within the strategy chain. The container automatically registers itself with itself;

− Added PerThreadLifeTimeManager;

− Bug fixes;

− Performance improvements.

How to Get Started?

If you are new to Enterprise Library:

− read the Introduction to the Enterprise Library;

− download, compile, and run the QuickStart samples —study the code;

− read through the related QuickStart Walkthroughs and “Key Scenarios” sections of the documentation;

− practice the Hands-On Labs;

− review the source and unit tests for deeper understanding;

− view webcasts on Enterprise Library and Unity, review demo code.

If you already know and love the Enterprise Library:

− check out the change log for this release;

− upgrade to V4.1—no code change is required—simply update the references to the corresponding application block assemblies and to the common assemblies;

− download the updated QuickStarts and run through the Unity-integrated examples to get the flavor of new dependency injection style of using the Enterprise Library;

− review the documentation on how to use interception with Unity;

− view webcasts on Enterprise Library and Unity, review demo code.

Happy Coding!

EntLib4.1 kickoff

gmelnik — Mon, 04 Aug 2008 06:13:00 GMT

On July 31 we have kicked off the EntLib4.1 and Unity 1.2 project. This is a minor service release. In it, we address several bugs and enhancements, and provide the following features:

- Collections support in the Unity Application Block (Unity dependency injection container)

- Improved support for generics in Unity

- Interception mechanism in Unity (including integration with the Policy Injection Application Block)

- Improved type picker of the config tool (this one needed a face lift for a long time)

- Debugging visualizer (to allow for easy navigation of mappings, corresponding lifetime policies as well as container extensions).

We also plan on doing rigorous testing on 64-bit machines. I’ll post a complete backlog on Codeplex soon.

We intend to release regular community previews at the end of each iteration (biweekly).

I am excited to continue working with several people from the previous release (Chris, Fernando, Vijaya) and also welcome new team members: Erik and Dennis. Alex, Hanz, and Carlos take on the roles of consultants. This is an amazing team! At the end of the first day we already had two user stories done-done.

Codeplex discussions remain the primary venue for posting your feedback. Keep it coming.