Babu George's Blog

Solution Realization Guidance

2009-08-01T09:31:00Z

It's always a challenge to manage the entire project life cycle by balancing requirements and iterations or milestones based on priority and relevant quality gates. It takes great effort to put in necessary quality initiatives to attain high quality deliverables through various metrics which include project execution and design/code quality gates.

Fortunately, there are many tools and guidelines which help project/program/product managers, architects/developers and other stakeholders to orchestrate and manage the whole process for high quality software solution realization.

For example, Visual Studio Team Suite (VSTS) provides a suite of products with out of the box features for templates/metrics calculations and hooks for extending the environment further to incorporate desired quality gate measuring mechanisms, validation policies, templates, and so on.

While VSTS/Team Foundation Server (TFS) provides features such as MSF for Agile / MSF for CMMI and provisions for customizing templates for project governance/solution realization process, features like Code Metrics, Code Analysis, Architecturing Process tools & guidance, etc help managers, architects and developers exploit these tools and guidance for better quality approaches and predictable delivery.

A few useful links …

Application Platform Optimization

Application Lifecycle Management (ALM) Offerings

Team Development with TFS Guide

TFS 2008 Branching Guide 2.0

Visual Studio Team System Tutorial

Team Foundation Server Frequently Asked Questions

Visual Studio Team System: Process Templates and Tools

Developer Support Team Foundation Server

MSBuild & TFSBuildLab

Architecture & Design

Design/Code Metrics

VSTS & Testing

Unit Testing

Unit Testing Walkthrough

Pex & Unit Testing

Performance and Caching Platforms

2009-06-28T19:40:00Z

The areas that I've focused in the past for achieving the desired levels for the key architecture quality attribute for software solutions, performance, include fine tuning of database queries and introduction of caching at various layers. While there are multiple approaches available for caching frequently used data to avoid expensive network round trips and high payloads for better performance, the project code named 'Velocity' deserves special attention.

"Microsoft project code named “Velocity” provides a highly scalable in-memory application cache for all kinds of data. By using cache, you can significantly improve application performance by avoiding unnecessary calls to the data source. Distributed cache enables your application to match increasing demand with increasing throughput by using a cache cluster that automatically manages the complexities of load balancing. "

Blogs on Velocity

Visual Studio 2010 and .NET FX 4 Beta 1

2009-05-21T08:16:00Z

Visual Studio 2010 and .NET FX 4 Beta 1 available for download now ...

http://www.microsoft.com/visualstudio/en-us/products/2010/default.mspx

Polyglot Programming & DLR

2009-04-19T22:20:00Z

Using multiple programming languages or paradigms, while implementing software solutions, are not uncommon anymore. For example, many of us definitely have been using C#, SQL and Scripting languages to implement applications. Composing multiple programming languages to build solutions, polyglot programming, is in practice for a while. We can extend this paradigm further with the more powerful, yet simple, ways of mixing Dynamic Languages Runtime (DLR) based programming languages like IronRuby and IronPython as well.

Here are a few links:

Mixing And Matching Languages

First Look at IronRuby

IronRuby Home Page

Dynamic Language Runtime (DLR)

Domain Model to Code

2009-03-21T14:26:00Z

Business Modeling and translating the model into analysis and design models have been a practice in the industry for while. Identifying the basic business entities as part of business analysis provides a way to create a candidate model structure for the software the solution and even for the persistence or database schema.

Many a time, analysis and design modeling process help architects identify the candidate architectural patterns or design patterns suitable for the solution. From a practical perspective, keeping the business domain model, analysis model and design models separate and in sync with the code (implementation model) become extremely challenging over the time.

One approach could be, using the analysis model as a transient model while translating business domain model into a design model so that the required architectural patterns and the structure of the solution are identified during the process and then dropping the analysis model altogether. That'll leave us with business domain model and design model.

If we can combine business domain model and design model into a single model which provides views of both from business perspective and design perspective, it'll be great and easier for us to maintain a single business domain cum design model. Now the process involved in identifying the business entities and expanding them into entities of design behavior while retaining the business context intact within the model could be a challenge.

A recently published article in MSDN, which provides an introduction to domain driven design, seems to be interesting. It talks about context maps, entities around business problem context and patterns (layered architecture, anti-corruption layers and so on) to be used for designing solutions.

Probably, we can also look at other best practices around architecting & designing such as an MVC approach and multiples views while emphasizing the modeling aspect to keep the business domain model and the code in sync. Now, Identifying the entities through a business analysis process can be challenging as well. One of the approaches could be the one stated in Object Models by Peter Coad which provides a few sample case studies in this regard.

ASP.NET MVC Release Candidate

2009-02-06T21:38:00Z

ASP.NET MVC RC1 Refresh release is available for download now which provides a new Model-View-Controller (MVC) framework on top of the existing ASP.NET 3.5 runtime.

Related URLs:

Download ASP.NET MVC RC1 Refresh

ASP.NET MVC

Pex (Program EXploration)

2009-01-24T15:20:00Z

We've been experimenting with Pex (Program EXploration) which produces a traditional unit test suite with high code coverage. These generated unit test cases takes parameters, calls the code under test, and states assertions. Essentially, Pex does a white box program analysis and provides higher code coverage.

Per Peli de Halleux's blog, major highlights of Pex Version 0.9 release are: Pre-Release license for Visual Studio 2008, better test framework integration and partial support for Visual Basic.NET/F# (read the full release notes)

Other References and download URLs of Pex:

Nikolai Tillmann's Blog

Pex – Automated White Box Testing for .NET

http://msdn.microsoft.com/en-us/devlabs/cc950525.aspx

http://research.microsoft.com/en-us/projects/pex/

Architecturing Process & VSTS 2010 CTP

2008-12-07T14:31:00Z

I have been playing around VSTS 2010 / TFS 2010 / .NET 4.0 CTP features for a while. It's available for download at the MSDN site in a VPC format with Windows 2008 server as the host. This VPC provides a few sample TFS projects and a few VSTS 2010 solutions as well.

There are a lot of cool features which make the architecturing process much easier using VSTS 2010 / UML 2.1 elements for Requirement Analysis, the associated Use Case realizations and translation of design into implementation. Feature for calculating code metrics has been enabled too as in VSTS 2008.

You can find the following templates and the associated tool box elements for modeling :

Activity Diagram
Use Case Diagram
Sequence Diagram
Layer Diagram
Logical Class Diagram
Component Diagram

A few reference URLs:

http://blogs.msdn.com/camerons/

http://blogs.msdn.com/camerons/archive/2008/09/30/vsts-2010-and-net-4-0.aspx

http://blogs.msdn.com/camerons/archive/2008/06/25/dsl-uml-pragmatic-modeling.aspx

Visual Studio 2010 and .NET Framework 4.0 Overview

http://msdn.microsoft.com/en-us/vs2008/products/cc948977.aspx

Creating a Project Template for "The 4+1 View Model of Software Architecture"

Code Metrics

2008-11-13T22:00:00Z

One of the challenges, I always faced was the availability of approaches for quantification of the aspects such as right coupling among classes for better design; less # of lines of code within a class/methods and the complexity measure of the code to take the necessary actions to make the code base maintainable and of higher quality. VS2008 provides a few metrics in this regard. I felt these metrics definitely help us fine tune the quality of the code and even the class design through a statistical approach.

http://blogs.msdn.com/fxcop/archive/2007/10/03/new-for-visual-studio-2008-code-metrics.aspx

• Maintainability Index
- the maintainability index has been re-set to lie between 0 and 100. How and why was this done?

• Cyclomatic Complexity
- calculated by counting the number of decision points (such as if blocks, switch cases, and do, while, foreach and for loops) and adding 1. This number is also a good indication on the number of unit tests it will take to achieve full line coverage. Lower is typically better.

• Depth of Inheritance
- depth of inheritance indicates the number of types that are above the type in the inheritance tree.

• Class Coupling
- indicates the total number of dependencies that the item has on other types.

• Lines of Code
- measure of the total number of executable lines of code. This excludes white space, comments, braces and the declarations of members, types and namespaces themselves. Lower is typically better

Reference:

http://blogs.msdn.com/fxcop/archive/tags/Code+Metrics/default.aspx
http://blogs.msdn.com/fxcop/archive/2007/11/20/maintainability-index-range-and-meaning.aspx
http://blogs.msdn.com/fxcop/archive/2007/10/03/new-for-visual-studio-2008-code-metrics.aspx

Distributed Computing Patterns

2008-10-03T07:14:00Z

The latest Microsoft Architecture Journal (#17) talks about distributed computing and the associated architectural patterns.

A few of our colleagues, at Managed Solution team, have put together an excellent article based on patterns harvested from our customer engagements, mapping real world real-world scenarios to patterns and then describing how said patterns were implemented on current technologies. This article discusses various aspects with respect to the architectural patterns found in common scenarios such as
1. implementation of applications/services;
2. consumption of services from within and external to organizations; and
3. administration of services or composite services.

This article also talks about Distributed Connectivity Service (DCS), a wizard-driven toolkit (software factory) and runtime, to provide guidance on developing and hosting business processes. This article further discusses the service virtualization aspects and architectural patterns exposed through Managed Service Engine (MSE), BizTalk and Enterprise Service Bus (ESB) Guidance components.

Read on ...
"Architectural Patterns for Distributed Computing"

Architecture Resource Center

Debugging .NET Framework Source

2008-09-23T15:01:00Z

I just debugged through the .NET Framework assembly source code like the way I used to do MFC source debugging earlier, except that the symbols and source are downloaded while debugging ...It’s much easier with VS 2008, especially the symbol download for debugging ... Looks cool ...

Configuring Visual Studio to Debug .NET Framework Source Code

http://blogs.msdn.com/sburke/archive/2008/01/16/configuring-visual-studio-to-debug-net-framework-source-code.aspx

Models, Views, and Controllers

2008-08-30T13:17:00Z

A good video on Understanding Models, Views, and Controllers.

http://www.asp.net/learn/mvc-videos/video-396.aspx

http://www.asp.net/learn/mvc/tutorial-02-cs.aspx

MVC Analysis Approach and ASP.NET MVC

2008-07-26T23:19:00Z

The ASP.NET MVC team is in the final stages of finishing up a new "Preview 4" release. See Scott Guthrie's Blog: http://weblogs.asp.net/scottgu/archive/tags/MVC/default.aspx .

ASP.NET MVC makes it very easy to implement a model-view-controller (MVC) pattern based Web applications. It also makes the analysis and designing process much simpler for translating Use Cases / User Scenarios through a Boundary / Controller / Entity classes transformation process as detailed in the well respected book "Software Reuse: Architecture, Process and Organization for Business Success", authored by Dr.Ivar Jacobson, et al. This approach definitely helps designers identifying the relevant classes for the UX, Business layers for a Front Controller pattern based implementation. I always felt that it also helps architects defining application architecture through a process beyond just boxes and lines in describing the architecture.

A few relevant URLs:

Microsoft ASP.NET MVC
http://www.asp.net/mvc/

ARCast - Process Legend Ivar Jacobson
http://channel9.msdn.com/shows/ARCast+with+Ron+Jacobs/ARCast-Process-Legend-Ivar-Jacobson/

"UML Extension for Objectory Process for Software Engineering" - This document discusses on Analysis Subsystems which include analysis service packages, analysis classes (such as entity, boundary, and control), and relationships.
http://www.omg.org/docs/ad/97-08-06.doc

Taming Tough Cookies ...

2008-06-09T21:02:00Z

"A Cookie Manager Class for Web Applications"

It has been a while since I had written an article, "A Cookie Manager Class for Web Applications" (http://www.ddj.com/cpp/184401425?pgno=4), on handling Internet Cookies. I used primarily C++/STL, WinInet SDK and Cookie specifications provided by Netscape and RFC 2109. Looks like RFC 2109 has been replaced with RFC 2965 per the information available in http://www.rfc-ref.org/RFC-TEXTS/2109/index.html .

Cookie class (System.Net namespace) in the .Net Framework:

Currently, Cookie class (System.Net namespace) in the .Net Framework provides the support for Netscape, RFC 2109, and RFC 2965 based cookies.The Cookie class is used by a client application to retrieve information about cookies that are received with HTTP responses. The following cookie formats are supported during parsing of the HTTP response headers: Netscape, RFC 2109, and RFC 2965.

http://msdn.microsoft.com/en-us/library/system.net.cookie.aspx

More on the Cookie Specifications:

RFC 2965 - http://www.rfc-ref.org/RFC-TEXTS/2965/

Netscape specification: http://wp.netscape.com/newsref/std/cookie_spec.html

RFC 2109 is obsolete now - see the following URL - http://www.rfc-ref.org/RFC-TEXTS/2109/index.html