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.

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

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.

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.

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…

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.

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

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!

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.

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.

We’ve been exploring the feedback on business rules and how they may apply to EntLib. We see a number of possibly interesting scenarios, but they vary across a number of dimensions. We want to see if we can narrow down the options and what would be useful for EntLib to provide for most users.

Please note, the intention here is not to write our own business rules engine, but to leverage the platform as much as possible.

Taxonomy of Rules

During our exploration we settled on a basic taxonomy of rules that may be useful context for our discussions. This taxonomy is:

Constraints – Rules that enforce restriction on values, but do not change object state (e.g. only one invoice submitted per month)

Deduction/Process – Rules that may calculate or trigger action (e.g., calculating effective tax rates on a sale based on province or generating emails based on exceeding some threshold amounts).

Combination – Rules that combine the above.

Scenarios

In the context of the above, we’ve identified the following possible scenarios based on feedback from the Advisory Board.

1. Efficiency of Expression

Simplify the creation of custom validators by allowing lambda expressions to be passed to the validator and executed over an instance at some later date. This would be an extension to the Validation Application Block (VAB).

2. Invoke WF Rules Engine (WFRE) rule set from VAB

Provide the ability to invoke WFRE rules from VAB via a custom validator. This would allow externalizing some set of validation rules. These rules could take advantage of the forward chaining capabilities of the WFRE if any of the rules were to modify object state. It is unclear that mixing VAB rules and WFRE rules would produce predictable results of the WFRE modified object state after VAB rules were already invoked.

3. Common Rule Invocation

Provide a common mechanism for invoking ‘rules’ that may be executed from WFRE rules, VAB rules or potentially another rule execution provider. This would likely look like a typical provider model that abstracts the initial invocation over an object instance.

4. Ambient Execution

The rule evaluation is continuously performed in the background as object state changes. This is different than what VAB and WFRE currently offer, which is explicit rule execution.

5. Rule Hierarchies / Rule Merging

This would be the ability to coalesce hierarchies of rules to provide overrides at more specific levels or combine rule sets from different sources. This would largely be around WFRE, specifically. The complexity here may lie in rules that overlap or conflict.

Which of the above scenarios would be of value to you?

Ethnographies are descriptions of people with their habits and points of difference (typically, in their natural settings). They explore the richness, depth, and complexity of some phenomena. These descriptions are based on extended observations, which make this type of studies particularly difficult to produce. Popular in social, geographical and psychological studies, ethnographic-based research studies are hard to come by in computer science and software engineering. This is to no surprise as, historically, empirical software engineering was rooted in the quantitative paradigm and many pundits still believe that ethnographic research is less rigorous than other “hard”, quantitative methods of scientific inquiry (a multi-decade old positivism vs interpretivism argument). Still, ethnographic methods are slowly gaining popularity (see published studies on the topics of agile teams dynamics, conflict in software engineering teams, distributed teams, maintenance work).

Importantly, ethnographies are also getting attention in the industry. Corporate ethnographies are being used nowadays not only to explain customer behavior but to actually inform strategy and long-range planning. Ethnographic research is complementary to market research. In a short column of March 2009 issue of Harvard Business Review, Ken Anderson, an anthropologist at Intel Research, explains how it is different in a way that unlike market researcher who tend to ask specific and highly practical questions, ethnographers observe people in a nondirected way – the goal is “to see people’s behavior on their terms, not ours.” He describes how ethnographers have veered into strategic questions (in particular, in a business unit that is concentrated on processors and platforms for home use). Anderson concludes that “ethnography has proved so valuable at Intel that the company now employs two dozen anthropologists and other trained ethnographers”. He believes that “ethnography is so beneficial that it will spread widely, helping firms in every industry truly understand customers and adapt to fast-changing markets”. I tend to agree with this prediction.

At Microsoft, we too use ethnographies. I was actually quite happy to find people with job titles “UX – Ethnographer”. I am going to see if I can get any of them engaged on the Enterprise Library project. With their help, I plan to gain additional insight into how developers actually use Enterprise Library, not just what they say about their experience.

As I was going through postings from our internal agile discussion forum  (yes, we do have one at Microsoft and it’s pretty vibrant too, with, on average, about a dozen of messages daily), I came across the draft of Sara Ford’s story about how she learnt to program manage an agile team after 6 years of waterfall. Sara is a colleague from Codeplex team. She was asking for feedback on it prior to posting it publicly, which she’s a got tones of. I don’t want to re-tell her story but encourage you to read the final version as I do think it’s an awesome first person account of how a convinced waterfallian ventured into the sea of agile and what kind of mindset conversions took place.

The paragraph that I thought was quite notable and also funny is when Sara talks about the spec:

“…during my first week on the team, I had asked a specification question, like how many characters do we allow for a password? And Jim  says, “we’ll have to look it up in the test cases.” And I said very proudly from my Visual Studio experience, “Gotta love it when the test cases are the specs.” (yes, I said this to Jim Newkirk, my manager.) To which Jim very calmly replied, “That’s the way it is supposed to be.” And I laughed, and then after a pause, I said in slight horror, “you’re serious, aren’t you?” It was like finding out there was no Santa Claus or you really don’t vote for the President of the United States. The mind just simply can’t comprehend.”

With time Sara’s mind learnt to appreciate and make the most of test cases as requirements. This resonates with the The Equivalence Hypothesis  Bob Martin and I formulated several years ago stating that “as formality increases, acceptance tests and requirements become indistinguishable”.

When I saw Sara by the coffee machine today and commended her on posting the story, she mentioned that the actual look Jim had on his face at that moment of telling her to look up the spec in the test cases was identical to the one of a pet-owner who was ready to punish a new puppy for ruining the carpet and stopped short from smacking it while thinking to himself “Wait, it’s a puppy!”

After all, it looks like old tricks can be unlearnt.

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.

Agile conference traditionally publishes proceedings (that’s where you find all research papers and experience reports).

Attendees also receive a CD or a memory stick with tutorial materials (decks, handouts, demos etc.).

Several main stage talks are available as webcasts.

What about workshops? A workshop is really an opportunity for attendees to learn more from each other as opposed to from a lecturer/facilitator/presenter. Thus, typically, there is not much material produced ahead of time, when the proceedings and conference cds are being assembled. However, a good wealth of knowledge has been captured in workshop summaries that we encouraged workshop facilitators to publish on the conference public wiki after the conference: http://agile2008toronto.pbwiki.com/Agile2008+Sessions

Take a look!

Greetings, the Enterprise Library user community!

Today the patterns & practices EntLib team together with the EntLib support team from Avanade is pleased announce the Enterprise Library Frequently Asked Questions (FAQs) wiki. We’ve done a sweep of discussion topics through the Codeplex site and our mailboxes and distilled a collection of tips, tweaks, pointers and trouble shooting methods to most frequently asked questions. Check it out!

This is a part of our continuing effort to improve learnability and ease of use of the Enterprise Library.

Importantly, this is a live wiki, not a static document (though if you prefer a printable version, we’ve made one available too). Feel free to comment on any of the answers with your additional suggestions or tricks you want to share. Also, if you have encountered the same question many times and you know how to answer but do not see it on the list, go ahead, add it. Please make sure your answers are meaningful and helpful (an easy way to determine if they are, is whether somebody had thanked you for those answers previously :)