Quality by Design

Enterprise Library 5.0 Caching Provider for Azure AppFabric Caching – Production release updates

2011-05-13T17:36:00.000-04:00

My original post has been based on AppFabric Caching CTP2 assemblies and config settings. There are several updates you need to make it work with the current production assemblies and configuration.

Add references to these assemblies:

From AppFabric SDK:

Microsoft.ApplicationServer.Caching.Client
Microsoft.ApplicationServer.Caching.Core
Microsoft.Web.DistributedCache
Microsoft.WindowsFabric.Common
Microsoft.WindowsFabric.Data.Common

From EntLib 5.0:

Microsoft.Practices.EnterpriseLibrary.Cashing
Microsoft.Practices.EnterpriseLibrary.Common
Microsoft.Practices.EnterpriseLibrary.Configuration.DesignTime

NOTE: reference AppFabric cashing and Enterprise library dependencies explicitly on file system, and make sure “Copy Local=True” for those references. Azure VM does not have EntLib assemblies in GAC like your development environment does.

In the current production release you CAN use named configurations for DataCacheFactoryConfiguration class, and I used azureDefault to explicitly tie EntLib provider to the azure cache config element in the config file.

I have added the retry policy because if your client is not in the cloud, DNS lookups of CNAME records for your azure app may take long and sometimes fail the call to azure cache for the first time, but succeed the next. Hence my retry code additions below.

AzureCacheManager updates

using Microsoft.Practices.EnterpriseLibrary.Caching.Azure.Configuration;

using Microsoft.Practices.EnterpriseLibrary.Common.Configuration;

using Microsoft.ApplicationServer.Caching;

using System.Collections.Generic;

using Microsoft.Practices.EnterpriseLibrary.Caching.Configuration;

using System.Collections.Specialized;

using System.Threading;

using System.Diagnostics;

namespace Microsoft.Practices.EnterpriseLibrary.Caching.Azure

    [ConfigurationElementType(typeof(CustomCacheManagerData))]

    public class AzureCacheManager : ICacheManager

        #region Consts

        private const string DefaultRegionName = "default";

        #endregion

        #region Members

        private DataCache _realCache;

        private int maxRetries = 3;

        private bool suppressExs = true;

        #endregion

        #region Ctor

        /// <summary>

        /// <para>Initializes a new instance of the <see

        /// cref="AzureCacheManager"/>.</para>

        /// </summary>

        /// <param name="configuration">The configuration object

        /// used to set the runtime values</param>

        public AzureCacheManager(AzureCacheManagerData configuration)

            maxRetries = configuration.AzureDataCacheMaxRetries;

            suppressExs = configuration.AzureDataCacheSuppressExceptions;

            int attemptNum = 0;

            System.Exception exc = null;

            bool success = false;

            _realCache = null;

do

                attemptNum++;

try

                    var dcfConfig = new DataCacheFactoryConfiguration(configuration.AzureDataCacheClient);

                    //var dcfConfig = new DataCacheFactoryConfiguration();

                    var factory = new DataCacheFactory(dcfConfig);

                    _realCache = factory.GetDefaultCache();

                    success = true;

                catch (System.Exception ex)

                    exc = ex;

                    Thread.Sleep(50);

                    Trace.TraceError(ex.ToString());

            while ( attemptNum < maxRetries && !success );

            if ( !success && !suppressExs )

                throw exc;

        /// <summary>

        /// <para>Initializes a new instance of the <see

        /// cref="AzureCacheManager"/>.</para>

        /// </summary>

        /// <param name="configuration">The configuration object

        /// used to set the runtime values</param>

        public AzureCacheManager(NameValueCollection configSettings):this(new AzureCacheManagerData(configSettings))

        #endregion

        #region ICacheManager Members

        public void Add(string key, object value, CacheItemPriority scavengingPriority,

    ICacheItemRefreshAction refreshAction, params ICacheItemExpiration[] expirations)

            Add(key, value);

        public void Add(string key, object value)

            int attemptNum = 0;

            System.Exception exc = null;

            bool success = false;

do

                attemptNum++;

try

                    // other parameters are currently ignored

                    _realCache.Add(key, value);

                    success = true;

                catch (System.Exception ex)

                    exc = ex;

                    Thread.Sleep(50);

            while ( attemptNum < maxRetries && !success );

            if ( !success && !suppressExs )

                throw exc;

        public bool Contains(string key)

            int attemptNum = 0;

            System.Exception exc = null;

            bool success = false;

do

                attemptNum++;

try

                    // other parameters are currently ignored

                    object obj = _realCache.Get(key);

                    success = true;

                    return obj != null;

                catch (System.Exception ex)

                    exc = ex;

                    Thread.Sleep(50);

            while ( attemptNum < maxRetries && !success );

            if ( !success && !suppressExs )

                throw exc;

            return false;

        public int Count

get

                int attemptNum = 0;

                System.Exception exc = null;

                bool success = false;

do

                    attemptNum++;

try

                        int counter = 0;

                        // other parameters are currently ignored

                        foreach (var item in _realCache.GetObjectsInRegion("default"))

                            counter++;

                        success = true;

                        return counter;

                    catch (System.Exception ex)

                        exc = ex;

                        Thread.Sleep(50);

                while ( attemptNum < maxRetries && !success );

                if ( !success && !suppressExs )

                    throw exc;

                return 0;

        public void Flush()

            int attemptNum = 0;

            System.Exception exc = null;

            bool success = false;

do

                attemptNum++;

try

                    // other parameters are currently ignored

                    _realCache.ClearRegion(DefaultRegionName);

                    success = true;

                catch (System.Exception ex)

                    exc = ex;

                    Thread.Sleep(50);

            while ( attemptNum < maxRetries && !success );

            if ( !success && !suppressExs )

                throw exc;

        public object GetData(string key)

            int attemptNum = 0;

            System.Exception exc = null;

            bool success = false;

do

                attemptNum++;

try

                    // other parameters are currently ignored

                    object result = _realCache.Get(key);

                    success = true;

                    return result;

                catch (System.Exception ex)

                    exc = ex;

                    Thread.Sleep(50);

            while (attemptNum < maxRetries && !success);

            if (!success && !suppressExs)

                throw exc;

            return null;

        public void Remove(string key)

            int attemptNum = 0;

            System.Exception exc = null;

            bool success = false;

do

                attemptNum++;

try

                    // other parameters are currently ignored

                    _realCache.Remove(key);

                    success = true;

                catch (System.Exception ex)

                    exc = ex;

                    Thread.Sleep(50);

            while (attemptNum < maxRetries && !success);

            if (!success && !suppressExs)

                throw exc;

        public object this[string key]

get

                return GetData(key);

        #endregion

AzureCacheManagerData updates

using System.Configuration;

using Microsoft.Practices.EnterpriseLibrary.Caching.Configuration;

using Microsoft.Practices.EnterpriseLibrary.Common.Configuration;

using System.Collections.Specialized;

namespace Microsoft.Practices.EnterpriseLibrary.Caching.Azure.Configuration

    /// <summary>

    /// Represents the configuration data for a <see

    /// cref="AzureCacheManager"/>.

    /// </summary>

    public class AzureCacheManagerData : CustomCacheManagerData

        #region Consts

        public const string AzureDataCacheClientString = "AzureDataCacheClient";

        public const string AzureDataCacheMaxRetriesString = "AzureDataCacheMaxRetries";

        public const string AzureDataCacheSuppressExceptionsString = "AzureDataCacheSuppressExceptions";

        public const string NamedCacheString = "NamedCache";

        #endregion

        #region Ctor

        /// <summary>

        /// Initializes a new instance of the <see

        /// cref="AzureCacheManagerData"/> class.

        /// </summary>

        public AzureCacheManagerData()

            : base("AzureCacheManager", typeof(AzureCacheManager))

            AzureDataCacheClient = "default";

            NamedCache = "default";

        public AzureCacheManagerData(string azureDataCacheClient, string namedCache)

            : base("AzureCacheManager", typeof(AzureCacheManager))

            AzureDataCacheClient = azureDataCacheClient;

            NamedCache = namedCache;

        public AzureCacheManagerData(NameValueCollection configSettings)

            : base("AzureCacheManager", typeof(AzureCacheManager))

            AzureDataCacheClient = configSettings[AzureCacheManagerData.AzureDataCacheClientString] ?? "default";

            NamedCache = configSettings[AzureCacheManagerData.NamedCacheString] ?? "default";

            string maxRetriesStr = configSettings[AzureCacheManagerData.AzureDataCacheMaxRetriesString];

            int mr = 3;

            int.TryParse(maxRetriesStr, out mr);

            //overwrite retries to be a valid number, if needed

            AzureDataCacheMaxRetries = (mr > 0 && mr < 5) ? mr : 3;

            string suppressExStr = configSettings[AzureCacheManagerData.AzureDataCacheSuppressExceptionsString];

            bool se = true;

            bool.TryParse(suppressExStr, out se);

            AzureDataCacheSuppressExceptions = (bool.TryParse(suppressExStr, out se))? se : true;

        #endregion

        #region Properties

        [ConfigurationProperty(AzureDataCacheClientString, IsRequired = true)]

        public string AzureDataCacheClient

get

                return (string)base[AzureDataCacheClientString];

set

                base[AzureDataCacheClientString] = value;

        [ConfigurationProperty(AzureDataCacheMaxRetriesString, IsRequired = false, DefaultValue = 3)]

        public int AzureDataCacheMaxRetries

get

                return (int)base[AzureDataCacheMaxRetriesString];

set

                base[AzureDataCacheMaxRetriesString] = value;

        [ConfigurationProperty(AzureDataCacheSuppressExceptionsString, IsRequired = false, DefaultValue = true)]

        public bool AzureDataCacheSuppressExceptions

get

                return (bool)base[AzureDataCacheSuppressExceptionsString];

set

                base[AzureDataCacheSuppressExceptionsString] = value;

        [ConfigurationProperty(NamedCacheString, IsRequired = true)]

        public string NamedCache

get

                return (string)base[NamedCacheString];

set

                base[NamedCacheString] = value;

        #endregion

config sections related to the Enterprise Library Cashing based on this custom Azure Caching provider should look like this:

<configuration>
  <configSections>
    <section name="cachingConfiguration" type="Microsoft.Practices.EnterpriseLibrary.Caching.Configuration.CacheManagerSettings, Microsoft.Practices.EnterpriseLibrary.Caching, Version=5.0.414.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" requirePermission="true" />

  </configSections>

<cachingConfiguration defaultCacheManager="Cache Manager">

    <cacheManagers>

      <add AzureDataCacheClient="azureDefault" type="Microsoft.Practices.EnterpriseLibrary.Caching.Azure.AzureCacheManager, AzureCacheProvider, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null"

        name="Cache Manager" />

    </cacheManagers>

    <backingStores>

      <add type="Microsoft.Practices.EnterpriseLibrary.Caching.BackingStoreImplementations.NullBackingStore, Microsoft.Practices.EnterpriseLibrary.Caching, Version=5.0.414.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"

        name="NullBackingStore" />

    </backingStores>

  </cachingConfiguration>

  <dataCacheClients>

    <dataCacheClient name="azureDefault">

      <hosts>

        <host name="[YOURSTORE].cache.windows.net" cachePort="22243" />

      </hosts>

      <securityProperties mode="Message" sslEnabled="true">

        <messageSecurity

          authorizationInfo="[YOURTOKEN]">

        </messageSecurity>

      </securityProperties>

      <transportProperties channelInitializationTimeout="60000" receiveTimeout="600000"/>

    </dataCacheClient>

  </dataCacheClients>

 
  <!-- If session state needs to be saved in AppFabric Caching service add the following to web.config inside system.web -->
  <sessionState mode="Custom" customProvider="AppFabricCacheSessionStoreProvider">
    <providers>
      <add name="AppFabricCacheSessionStoreProvider"
              type="Microsoft.Web.DistributedCache.DistributedCacheSessionStateStoreProvider, Microsoft.Web.DistributedCache"
              cacheName="default"
              useBlobMode="false" />
    </providers>
  </sessionState>
 
  <!-- If output cache content needs to be saved in AppFabric Caching service add the following to web.config inside system.web -->
  <caching>
    <outputCache defaultProvider="DistributedCache">
      <providers>
        <add name="DistributedCache"
        type="Microsoft.Web.DistributedCache.DistributedCacheOutputCacheProvider, Microsoft.Web.DistributedCache"
        cacheName="default" />
      </providers>
    </outputCache>
  </caching>
</configuration>

Windows Phone 7 API Wish List

2010-08-12T21:55:00.000-04:00

I have a short, but growing, list of ‘MUST HAVE’ capabilities needed in WP7 SDK to create apps that can compete with iPhone and Android:

Live camera and video API
Network interface API down to IP, WPA, WEP protocols

‘Nice to have’, more of a nuisance:

WaitAll() implementation is needed. One can work around it with WaitAny(), but seriously…

OEMs just do not have enough bodies to create the needed high quality apps to get WP7 apps to 200,000 count to compete with iPhone and Android. Developers, even those who did Windows Mobile 6.5 apps cannot port many of their applications because of the limitations imposed in the current WP7 Silverlight implementation.

Quick Comparison: RequisitePro, DOORs, and Requirements Composer

2010-08-12T20:46:00.000-04:00

Ever since the acquisition of Telelogic by IBM, it has been quite a challenge to figure out what tool fits best and in what context.

Here is a quick compilation:

General/historic tool use

DOORS

RequisitePro

Systems

Software/IT

Formal Req. Change Process

Lightweight Req. Change Management

Telelogic Tools / Harmony Process

Rational Tools / RUP

Reviewer Web Client

Full Web Client

Formal Rigorous Compliance / FDA

IT Compliance

More expensive

Less expensive

(adopted from this presentation)

The Requirements Composer complements both DOORs and ReqPro by providing capturing, modeling, diagramming, and collaboration capabilities.

Capability

ReqPro

DOORS

Requirements Composer

Word integration

great

poor

none

Manage requirements

great

poor

Req. Lifecycle Traceability

great

poor

Web-based access

great

poor

good

Detailed reporting for standards compliance

good

great

poor

Tool integration

good

Rich text capture

none

good

great

UI sketches and storyboards

none

great

Diagramming

none

great

Dashboards

none

good

The roadmap at IBM is to merge DOORs and ReqPro in the new product out in 2011: http://jazz.net/projects/rational-requirements-composer/

This is a larger ALM vision IBM has for their products: http://jazz.net/projects/rational-workbench-for-clm/

Comparison of Team Concert and Team Foundation Server Features

2009-08-25T22:50:00.002-04:00

IBM Rational is playing catch up in the ALM tool space, Gartner reports notwithstanding. Rational Team Concert 2.0 is an incremental step to answer MS Team Foundation Server 2008 and other ALM solutions. Both tools are too large to compare in depth in one article. The following article is a HIGH LEVEL comparison.

ALM disciplines and tools (modified from an earlier article)

ALM Discipline

TFS 2008

IBM Rational Team Concert

Requirements management

Design

Project Management

Change management

Configuration Management

Build management

Testing

The future release will integrate with Quality Manager to extend work item traceability to testing artifacts

Release Management

Software Deployment

Software Maintenance/Asset Management

Table adopted from RTC edition comparison (https://jazz.net/downloads/rational-team-concert/releases/2.0)

Features	Express-C	Express	Standard	Enterprise	Microsoft Team Foundation Server
Server license
Maximum Developers / Contributors	10 / unrestricted	50 / unrestricted	250 / unrestricted	unrestricted / unrestricted	practical limit of ~ 3600 TFS users
Database included (optional)	Derby only	Derby and DB2 Workgroup (DB2, Oracle, SQL Server)	Derby and DB2 Workgroup (DB2, Oracle, SQL Server)	Derby and DB2 Workgroup (DB2, Oracle, SQL Server)	MS SQL Server
Application server included (optional)	Tomcat only	Tomcat (WebSphere)	Tomcat (WebSphere)	Tomcat (WebSphere)	IIS, WSS, MOSS
IDE support	Eclipse, Microsoft Visual Studio	Eclipse, Microsoft Visual Studio	Eclipse, Microsoft Visual Studio	Eclipse, Microsoft Visual Studio	Eclipse, Microsoft Visual Studio
Agile planning: daily, iteration, release
Source code management
Build management
Work item tracking
Customizable process
Project milestone tracking and status
Subversion integration					N/A
Role-based process permissions
Project level access control
LDAP authentication					N/A
Dashboards	(One per Project)	(One per Project)	(Unlimited Project, Team, and Personal)	(Unlimited Project, Team, and Personal)
Cross-project dashboards
Cross-repository dashboards
Customizable work item attributes and presentations
Customizable work item workflow
Plan risk assessment
Reports
ClearCase Synchronizer and Bridge					N/A
ClearQuest Synchronizer and Bridge					N/A
LDAP import/synchronize					N/A
HTTP proxy support
Floating licenses available					N/A
High availability				*

* Entitles installation of a second copy of the server in an idle standby application server failover configuration. Requires WebSphere Application Server and optional high availability database configuration (DB2, Oracle, SQL Server).

One note on dashboards. TFS 2008 uses SharePoint portal, which allows all kinds of customizations, but there is no nice dashboard out of the box. However, TFS 2010 will change all that. See http://blogs.msdn.com/bharry/archive/2009/05/19/tfs-2010-project-management.aspx for more details.

Table adopted from RTC features (http://www-01.ibm.com/software/awdtools/rtc/standard/features/?S_CMP=rnav)

Features	RTC Benefits	TFS Benefits (added for comparison by me)
Integrated work item management	Automatically creates and tracks progress of individual work items in accordance with team process and project rules. Additionally captures and maintains work item relationships to other artifacts, such as code change sets and builds.	TFS has had all features listed under RTC work item management. In addition, TFS extends its traceability and work item tracking to its integrated testing capability and testing artifacts. Automated tests can be incorporated into builds.
Integrated source control	Provides essential software version control, workspace management, and parallel development support to individuals and teams. Additionally, Rational Team Concert is fully aware and integrated into work items (why a code change was made) and build management (when did this code change make it to a build).	TFS has provided the same type of source control and work item management capabilities. Work item traceability also extends to test artifacts.
Integrated build management	Allows you to schedule and execute software build processes. Leverages multiple servers for rapid, cross-platform build processing. Integrates with work items and source control to create detailed bill of materials to guarantee build reproducibility.	TFS has had the same type of build management and execution capabilities.
Process awareness and automation	Guides team workflow with a customized project process and automates process steps and checkpoints at varying degrees of rigor.	Besides the out of the box MSF templates, TFS has process template manager to customize project and process templates. There are a number of templates, including open source Scrum, that may be readily imported and used.
Customizable project dashboard	Lets you stay on top of project progress, troubleshoot project problems, and take corrective action earlier in the project lifecycle.	TFS 2008 uses SharePoint portal, which allows all kinds of customizations, but there is no nice dashboard out of the box. However, TFS 2010 will change all that. See http://blogs.msdn.com/bharry/archive/2009/05/19/tfs-2010-project-management.aspx for more details.
ClearQuest Connector	Integrates the enterprise scalability of Rational® ClearQuest® for change and defect management while maintaining the integration with SCM and build management.	N/A
ClearCase Connector	Integrates the enterprise scalability of Rational ClearCase® for SCM while maintaining the integration with work item management and build management.	N/A
Subversion bridge	Integrates your investment in SCM while maintaining the integration with work item management and build management.	N/A
Team awareness and collaboration	Provides project-integrated presence and messaging.	TFS 2008 uses SharePoint/MOSS portals for project collaboration along with various alerts
Ready to use reports	Leverages ready to use reports to perform trend analysis and to make informed predictions based on patterns.	TFS 2008 has its own data warehouse with sophisticated reporting and analysis capabilities.

TFS vs RTC (modified from an earlier article)

Microsoft Visual Studio® 2008 Team Foundation Server	IBM Rational Team Concert v2.0
Platform and Languages
By default, only Microsoft Windows® TeamPrise third-party partner solution enables cross-platform (i.e. Eclipse) clients.	Windows and Linux
Extensibility
.NET object model. TFS Server web services based API	REST web services API
Traceability
Supports Work Item traceability out of the box	Supports Work Item traceability out of the box
Parallel Development
Supported through branches/merging and workspaces.	Supported through baselining and delivering change set from streams and workspaces and their respective flow targets
User Interaction (UI)
By default, only Windows and Microsoft Office solutions. Team System Web Access by default; in addition, a separate Work Item Web Access (WIWA) client is available (free). TFS Eclipse plug-in by TeamPrise	Eclipse IDE plug-ins; Visual Studio IDE plug-in; Web clients by default
Distributed Development
No offline support.	No offline support.
Developer Workspaces
Private workspaces on local disk that must be updated manually.	Jazz Source Control enables private workspaces that can be updated manually.
Scalability Limits
500 Team Projects is the maximum that one TFS server can support. Up to 3600 TFS users	Not enough information about limits

Microsoft Visual Studio® 2008 Team Foundation Server

IBM Rational Team Concert v2.0

Platform and Languages

By default, only Microsoft Windows®

TeamPrise third-party partner solution enables cross-platform (i.e. Eclipse) clients.

Windows and Linux

Extensibility

.NET object model.

TFS Server web services based API

REST web services API

Traceability

Supports Work Item traceability out of the box

Parallel Development

Supported through branches/merging and workspaces.

Supported through baselining and delivering change set from streams and workspaces and their respective flow targets

User Interaction (UI)

By default, only Windows and Microsoft Office solutions.

Team System Web Access by default; in addition, a separate Work Item Web Access (WIWA) client is available (free).

TFS Eclipse plug-in by TeamPrise

Eclipse IDE plug-ins; Visual Studio IDE plug-in;

Web clients by default

Distributed Development

No offline support.

Developer Workspaces

Private workspaces on local disk that must be updated manually.

Jazz Source Control enables private workspaces that can be updated manually.

Scalability Limits

500 Team Projects is the maximum that one TFS server can support.

Up to 3600 TFS users

Not enough information about limits

Team Concert Prices (IBM RTC pricing is based on version 1.0)

Part description	*^IBM price excluding tax**
IBM Rational Team Concert Contributor Client Access Authorized User License + SW Subscription & Support 12 Months (D041ILL)	630.00
IBM Rational Team Concert Express Edition Developer Client Access Authorized User License + SW Subscription & Support 12 Months (D041FLL)	1,260.00

Part description

^*IBM price excluding tax

IBM Rational Team Concert Contributor Client Access Authorized User License + SW Subscription & Support 12 Months (D041ILL)

630.00

IBM Rational Team Concert Express Edition Developer Client Access Authorized User License + SW Subscription & Support 12 Months (D041FLL)

1,260.00

Part description	*^IBM price excluding tax**
IBM Rational Team Concert Contributor Client Access Authorized User License + SW Subscription & Support 12 Months (D041ILL)	630.00
IBM Rational Team Concert Express Edition Developer Client Access Authorized User License + SW Subscription & Support 12 Months (D041FLL)	1,260.00
IBM Rational Team Concert Express Edition Server Install with 3 Authorized Users License + SW Subscription & Support 12 Months (D041CLL)	6,300.00

Part description	*^IBM price excluding tax**
IBM Rational Team Concert Contributor Client Access Authorized User License + SW Subscription & Support 12 Months (D041ILL)	630.00
IBM Rational Team Concert Standard Edition Developer Client Access Authorized User License + SW Subscription & Support 12 Months (D041ULL)	4,100.00
IBM Rational Team Concert Standard Edition Server Install with 3 Authorized Users License + SW Subscription & Support 12 Months (D041TLL)	52,500.00
IBM Rational Team Concert Standard Edition Floating Developer Client Access Floating User License + SW Subscription & Support 12 Months (D06F4LL)	7,180.00
IBM Rational Team Concert Standard Edition Floating Contributor Client Access Floating User License + SW Subscription & Support 12 Months (D06F9LL)	1,760.00

Team Foundation Server Prices

Visual Studio Team System 2008 Team Foundation Server	$2,799
Visual Studio Team System 2008 Team Foundation Server Client Access License (CAL)	$499

References

IBM ALM products roadmap

http://www-01.ibm.com/software/rational/jazz/roadmap/

IBM Rational Team Concert Editions Comparison

https://jazz.net/downloads/rational-team-concert/releases/2.0

VSTS & TFS 2008

VSTS Product comparison

http://msdn.microsoft.com/en-us/vsts2008/products/cc149003.aspx

TFS 2008

http://msdn.microsoft.com/en-us/tfs2008/default.aspx

TFS 2010 dashboards

http://blogs.msdn.com/bharry/archive/2009/05/19/tfs-2010-project-management.aspx

Magic Quadrant for Software Change and Configuration Management for Distributed Platforms

2009-04-28T20:33:00.000-04:00

Gartner recently revised and corrected its previously released “Magic Quadrant” report from the end of March. Those interested can get the report here:

http://mediaproducts.gartner.com/reprints/microsoft/vol4/article9and10/article9and10.html

Not a lot of news regarding IBM Jazz vs. Microsoft TFS comparison in the previous Gartner assessment (MarketScope for Application Life Cycle Management). The noteworthy item is that Gartner assessed Telelogic products separately from Rational Jazz products, even though Telelogic is part of IBM Rational, at least in theory. IBM intends to merge the legacy Rational products and Telelogic products into Jazz platform. It has been challenging to sort out what sets of products do what and what is the future direction for Rational products. Here are articles and IBM presentations about IBM Rational product roadmaps:

http://www.sdtimes.com/SearchResult/33043

http://www-07.ibm.com/hk/e-business/events/archives/rtc/downloads/3_Jazz_and_the_Rational_Product_Roadmap.pdf

http://www-05.ibm.com/dk/news/events/itupdate/pdf/2_Requirements_Definitions___Management_ved_Jan_Ekstroem.pdf

When “Magic Quadrant” report was issued, its evaluation criteria did not include total cost of ownership (TOC) in the product strategy or operations areas. The TOC would be an important piece of information in assessing new Jazz based products. For example, what are deployment and support costs related to supporting multiple repositories for ReqPro, ClearQuest, Requirements Composer, Quality Manager, DOORS, and upcoming Jazz products? What are the support costs of integrating those products? It seems that IBM Rational placement in the quadrant is more due to the pre-Jazz Rational tools market share than its new products.

Technorati Tags: ALM,Application Lifecycle Management,Change Management,Configuration Management,Gartner,Jazz,Jazz vs Team Foundation,Jazz vs TFS,Magic Quadrant,MarketScope for Application Life Cycle Management,Team Foundation,Team Foundation vs Jazz,TFS,TFS vs Jazz

Interface “inheritance” in C#

2009-04-28T18:17:00.001-04:00

I have had a little debate not long ago about pros and cons of interface inheritance in .NET C# language. It may be worth restating the main points of the discussion.

Definition from C# language specification: (http://msdn.microsoft.com/en-us/library/aa664578(VS.71).aspx)

An interface can inherit from zero or more interfaces, which are called the explicit base interfaces of the interface

Example: per definition above IComboBox inherits ITextBox, IListBox, and indirectly IControl interfaces. The official definition notwithstanding, note that you can also say the IComboBox implements the same interfaces without violating the meaning and implications of the resulting relationship.

interface IControl
{
void Paint();
}
interface ITextBox: IControl
{
void SetText(string text);
}
interface IListBox: IControl
{
void SetItems(string[] items);
}
interface IComboBox: ITextBox, IListBox {}

Next is interface implementation. A class can implement an interface. Unfortunately, in C# unlike VB and Java, the syntax for inheritance and implementation is the same, i.e. the syntax simply uses “:” operator. Result – lots of confusion.

interface IMyInterface {}
class MyClass : IMyInterface {}

The difference becomes a little clearer when you consider this example:

public interface IMyBaseInterface
{
 void DoA();
}
public interface IMyDerivedInterface : IMyBaseInterface
{
 void DoB();
}
public class MyClass : IMyDerivedInterface
{
 void DoA();
 void DoB();
}

The result of MyClass explicitly implementing IMyDerivedInterface is that it implicitly got saddled with a requirement to also explicitly implement IMyBaseInterface.

“So. What exactly is the problem?” After all, Microsoft is using interface inheritance in .NET framework for ICollection : IEnumerable definition and the like. Here are my objections to the interface inheritance practice on a broad scale:

Interfaces are contracts. Implicit contracts are like a programming fine print. An interface is a pure definition and always requires a class to implement the declared contract behavior. Per the example above, MyClass indirectly realizes the contract IMyBaseInterface behavior, but has to explicitly implement it nonetheless. A better practice is simply for IMyDerivedInterface not to inherit IMyBaseInterface and for MyClass to explicitly implement both IMyDerivedInterface and IMyBaseInterface interfaces. The result is the same without the “fine print” contract. This way, another class wanting to implement only IMyDerivedInterface would not be forced into implementing DoA() of IMyBaseInterface interface.
```
public interface IMyBaseInterface
{
 void DoA();
}
public interface IMyDerivedInterface
{
 void DoB();
}
public class MyClass : IMyDerivedInterface, IMyBaseInterface
{
 void DoA();
 void DoB();
}
```

Interface inheritance practice contradicts polymorphism through interface implementation that emphasizes using a single interface behavior to interact with objects of different types that implement it. From the previous example, interface IMyBaseInterface is always implicitly dragged into every implementation for every type that is simply trying to implement only IMyDerivedInterface methods. This is no longer a single behavior for a single interface.

Interface inheritance practice leads to unnecessary code duplication instead of code reuse. Even in a case of ICollection : IEnumerable interface definition, I wonder if such tacking on of IEnumerable contract was necessary. In a perfect world, one would be better off inheriting from an abstract class or a class that has IEnumerable rudimentary implementation once: i.e. the showcase of reuse with inheritance. I am not completely opposed to interface inheritance. Even ICollection : IEnumerable may have additional valid considerations I am missing. However, on a broad scale, interface inheritance adds more contract “fine print” and forces potentially unnecessary implementation and code duplication.

Interface is a contractual constraint. It has no behavior of its own, and thus, produces no value of its own. Interface inheritance makes the contractual constraint on an implementing class even more convoluted, but still produces no value of its own: all interfaces in the inheritance tree still need a class to produce any value.

Finally, in spite of C# interface inheritance definition and terminology in the C# language spec, .NET framework compiles all interface “inheritance” definitions as interface implementation. For example, the compiled ICollection : IEnumerable interface definition is interpreted as ICollection implements IEnumerable, not inherits. That is true for generics too. You can the example below for yourself:

Upon the breakpoint, check ic variable, and note the BaseType value:

Now check the result of ic.GetInterfaces():

This is a long way to say: interfaces are to be implemented, not inherited from. Do not use interface inheritance unless it is unavoidable, and by “unavoidable” I mean “almost never”.

Technorati Tags: .NET,C#,Interface Implementation,Interface Inheritance

IBM/Telelogic Announces Integration Between DOORS and TFS

2009-03-05T21:35:00.000-05:00

DOORS is a requirements management solution by Telelogic. IBM acquired Telelogic in 2008. DOORS has a faithful following, and it is popular with many government agencies, companies writing applications for embedded devices, some Fortune 100 companies, military and defense contractors, and with industries that are subject to stringent regulations. DOORS/TFS integration will add a great deal of flexibility to Team Foundation/Visual Studio users in terms of gathering, organizing, managing, and analyzing requirements. On the flip side, analysts will be able to follow the requirements traceability from DOORS to design to implementation to test cases to results to bugs etc. Below is the link to Telelogic’s announcement:

http://www.telelogic.com/download/get_file.cfm?id=5912

Technorati Tags: DOORS,ALM,Team Foundation,TFS,Application Lifecycle Management,Requirements Management

ClearQuest integration with Team Foundation Server

2009-02-22T18:46:00.000-05:00

Should CQ and TFS ever be integrated?

As a rule of thumb, the answer is NO. Team Foundation Server (TFS) is an Application Lifecycle Management solution that covers 9 out of 10 ALM disciplines listed in the previous related article. On top of that, TFS implements most, if not all, of the major Change Management features of ClearQuest (CQ). On the other hand, ClearQuest can be deployed on Windows or Linux. It may be deployed as a Unified Change Management solution, as a part of Team Unified Platform suite, or, in the future, as a part of a Jazz based ALM.

When CQ and TFS should not be integrated?

When an organization owns and operates both the TFS and CQ at the same time, it incurs redundancy (most likely unnecessarily) and related administrative and support costs. Whether the move is from TFS to ALM with CQ or vice versa, the goal is to migrate to one or the other product and not to make the redundancy and its overhead permanent. This is a fiscal, operational, or a common sense argument, not a technical one. However every sane CIO/COO/CTO or a manager with budgetary responsibilities should ask such a question and get an answer rather quickly. Adopting a longer than 6 months outlook and keeping the “migration vs. integration” discussion aligned with organization’s overall IT strategy would likely help with making better decisions.

Plausible scenarios for integration

Obviously, there are circumstances that fall outside of the “rule of thumb” constraints. Below are several common examples where integration, as opposed to migration from CQ to TFS, may still be necessary:

There is significant development taking place outside of Windows platform and outside of TFS supported ALM activities: SCM in Linux or UNIX environments; UNIX/Linux automated build, testing, and deployment. In other words, the TFS ALM features are largely unavailable in the non-Windows environment where CQ solution is already successfully deployed.
It is more expensive to migrate to TFS the CQ environment with its own extended/external relationships to ClearCase, RequisitePro, linked design model elements or code in Rational Solution Architect, Rational Portfolio Manager, etc.

High level roadmap on how CQ and TFS can integrate

Manual synchronization

Very Basic, using existing out of the box TFS and CQ features. I would not recommend this method: it is quite laborious, very error prone, and not sustainable in the long term.

TFS provides ClearQuest converter command-line tool out of the box. The tools is intended for migration of CQ repository items into TFS. Theoretically one can setup updates from CQ to TFS as follows:

Define a date based queries in ClearQuest that returns new unsynchronized records for each record type of interest.
Follow the steps to analyze and migrate records outlined in MSDN
Optionally add TFS integration fields omitted by the converter
Run the CQ converter tool (with date based queries in CQ) to copy the new items into TFS

ClearQuest ships with the ClearQuest Import utility (Windows GUI app) that allows importing CSV file records into ClearQuest database repository. In order to setup synchronization from TFS to CQ:

Open Work Items query for each item type of interest in Excel. Save the results as a CSV file.
Open the CSV file and change the column names to be the same as the expected CQ import schema record fields. It may be necessary to add calculated fields to satisfy CQ import record schema. Save the CSV.
Run CQ Import utility, specifying whether the records are new or being updated.

NOTE: such import/export does not transfer change history

Batch synchronization

Building custom synchronization

One should take advantage of existing work done in the Migration and Synchronization Toolkit. The customized solution would rely on using ClearQuest COM API (cqole.dll) and TFS API. On one hand such solution would have to re-implement functions of TFS CQ converter, plus synchronization checks whether to insert or update new records. On the opposite side, such solution will use CQ API objects to insert and update CQ records from TFS.

Visual Studio Plug-In

Another way to customize synchronization between TFS and CQ from a single IDE is to create a Visual Studio plug-in. One scenario that may be more efficient is on-demand synchronization, where VSTS plug-in accesses 1:1 (shadow copies) related records in TFS and CQ and respectively updates them at the time of access. VSTS IDE extension would likely be the nicest way to leverage and use CQ and TFS integration, but it would also be the most expensive. If the long term use of such integration and productivity gains can justify it -- more power to you.

Parting thoughts

Perhaps more important than integration between CQ and TFS are the questions of future migrations and integrations between TFS and Jazz (Team Concert, etc.). These questions will be part of my product research agenda for IBM Jazz ALM suite.

Technorati Tags: ALM,Application Lifecycle Management,Change Management,ClearQuest,ClearQuest Team Foundation integration,ClearQuest TFS integration,CQ,CQ TFS integration,Team Foundation,Team Foundation ClearQuest integration,TFS,TFS ClearQuest integration,TFS CQ integration,Visual Studio,VSTS

MarketScope for Application Life Cycle Management

2009-02-09T23:47:00.001-05:00

Gartner had a report issued in December of 2008 about Application Life Cycle Management market and the main players. Those interested may get the full report here. The report contains several noteworthy observations in regards to IBM Jazz and Microsoft Team Foundation.

In the IBM related section of the research note, it is a bit surprising that many of the same issues raised in the ClearCase/ClearQuest UCM vs. Team Foundation Server post are also raised. Specifically, Gartner analysts point out that IBM Rational “has been hampered by a mass of products built with different technologies amassed through acquisition.” On account of “pre-Jazz” ALM products, the analysts state:

IBM’s pre-Jazz solutions have been able to handle some of the largest and most complex development projects, but they carry a tag of being difficult to learn, expensive to administer and operate, and they now seem somewhat outdated when viewed in terms of current development trends, such as agile.

The history of Rational and IBM acquisition did result in overlapping products, including the ALM domain. On top of that, the current release of the Jazz based products, namely Team Concert, Requirements Composer, and Quality Manager is not yet an integrated suite. According to IBM Rational product roadmap, those products should work as an ALM suite in the future. However, they do not in this release. Having said this, Gartner analysts have put a great deal of credit into the future ALM Jazz implementations.

We rate IBM as a Strong Positive because of its current market strengths and breadth of portfolio. This gives the company a broad base to sell into. In the midterm, gaps in the project and portfolio management offerings will handicap some broader integrations. The open development model of Jazz, coupled with IBM’s aggressive introduction of new tools and renovated Rational offerings, sets a strong pace. Jazz is a solid architectural foundation for further innovation.

In the Microsoft section, there are a few statements that did not quite make sense, for instance: “gaps remain in some management and execution tool areas.” What about MSBuild? How about MS Project and Project Server integration? Configuration management? Change management? Requirements management features of TFS? Regarding Microsoft, analysts come to this conclusion:

We rank Microsoft as Positive. The company has a strong reach in the market, and moderate pricing for a large, stable provider. It has a proven scalable architecture, but it needs to complete the toolset. Furthermore, Microsoft needs to mature its sales force so that it can more consistently reach enterprise buyers.

Without familiarity with other vendors and ALM offerings outside of IBM and Microsoft, it would be difficult for me to validate Gartner’s research and conclusions about the other products. The report repeats some marketing language from the companies, but leaves the reader with unanswered questions about its conclusions.

Technorati Tags: ALM,Application Lifecycle Management,Change Management,Configuration Management,Gartner,Jazz,Jazz vs Team Foundation,Jazz vs TFS,MarketScope for Application Life Cycle Management,Quality Manager,Requirements Composer,Team Foundation,Team Foundation vs Jazz,TFS,TFS vs Jazz,Visual Studio,VSTS