MSDN session Application Lifecycle Management with Visual Studio Team System (19/12/2007)

Hello,

Yesterday I attended the MSDN evening session about Application Life cycle Management (ALM) with Visual Studio Team System (VSTS).

It was very interesting and very well presented by Yves Goeleven (Compuware Belgium). He was very knowledgeable about the subject and VSTS in particular. His presentation was a good mix between slides and demo's so you had a good feel what actually was meant.

Still I have some "concerns" about the subject. Concerns are formulated as "I wish I knew how to ...."

• Position VSTS/TFS as an ALM tool or more as an SDLC tool? Yes there are hooks (extensibility)....
• Capture the requirements from the customer in VSTS? And manage them in VSTS? Yes a wokitem will be the "materialization" of a requirement. But is this still the language of the customer?
• To model use case diagrams, UML class diagrams , User stories
• To integrate with operations (deployment, monitoring, incidents , capacity management)

I looked up the the terms ALM and SDLC. Application Lifecycle Management (ALM) is the administration and control of an application from inception to its demise. It embraces requirements management, system design, software development , testing , configuration management and operating the information system. The following picture tries to capture that idea.

Key is that the life of application does not start at the beginning of development. It start somewhere in the “business”. The end of application is not when it is delivered or even installed. It must be kept up and running to serve the business. It is also called life cycle because in effect an “application” is never finished. It is not something like a tangible product that rolls out a factory. It’s an ongoing process where new insights and requirements shape the life of an application, hence application life cycle management. As the business changes, information requirements change, and the cycle continues. Sometimes resulting in the demise of an existing system and the birth of a new application.

The software development Lifecycle (SDLC) on the other hand has everything to do with developing the information system. But it gets kicked of by the business and hands over application to operations. It is also a lifecycle because within one ALM cycle because it is the rare exception that everything is said from the beginning. So there can be several iterations before an applications gets to be delivered to the business. On the other hand of course a change request or new requirements can trigger of a new ALM cycle.

In order to achieve business objectives within an organization via information systems, user functional and non functional requirements must be defined in a consistent manner, prioritized and monitored. The administration and control of the information needs of users (Requirement Management) is therefore primary motor in the ALM and de facto also in the SDLC. All the “knowledge” that’s is necessary to transform these requirements into an information system is produced during the SDLC and put into a repository (or a collection of repositories). This will for the test basis for the test cases that will be used to verify it the information does what needs to do.
The SDLC will take that the requirement will be turned into architecture and design specifications which will eventually lead into code doing what the business expects it to do. Herein lies the objective of testing. Testing actually is conducted throughout the SDLC. Testing preparation can even start as soon as the requirements are written down (testable requirements concept). During development in the form of unit and unit integration testing or system testing (functional, security , performance ,etc). Before the application get rolled-out, the business itself can conduct test in the form of user (functional) acceptance test. Also operations can conducts acceptance tests that verify the operational requirements.

The input for establishing these test case are the expectations of the business. Ideally written down in the form of requirement, detailed functional specification and design documents. So there is a strong link between all the knowledge of what the system must do and all the information of how system is going to be tested.

A integrated system (or an integrated set of tools) should bring some added value to manage this link. Because the objective of testing is to report if the system does what it needs to do. So traceability is a key feature of this tool. Other benefits are accountability (who did what when), visibility (what did we do so far).

So if we would define testing as a kind of “fit-for-purpose” activity, testing is another gatekeeper in the life cycle. With the results of testing the stakeholders (customer/project lead) can take a decision based on facts if there will be release or not (ALM cycle) or within the SDLC cycle if something has to be corrected before release.

Monitoring the information system in production and the actual usage of the application will further keep the ALM cycle running by incident reporting (functional and non-functional).

So were does VSTS/TFS fit in this story?

I tried use the following picture to get some (visual) answers.

I can see several aspects being covered by VSTS while others (at this time) seem to not be (immediately) clear to me. Maybe this will change over time as learn more about ALM and VSTS/TFS in particular? I would be glad to hear your insights on the subject.

Best regards,

Alexander

Trigger TimedSubscription programmatically

Hello,

Subscriptions are a way to kickstart Reporting Service in delivering a report to somewhere instead of you asking for the report through a URL access request (portal or custom app). This is also callled push versus pull.

You can configere a timed event to trigger off those kind of subscriptions. But in some occasions you want some "custom" event to trigger of a subscription. You can not configure something like that through the configuration tools (reportmanger or SqlServer Management Studio).

Lukasz Pawlowski (http://blogs.msdn.com/lukaszp/archive/2005/10/07/478391.aspx) explained a way to tell Reporting Services to kick of a subscription with the SOAP API of Reporting Services. There is a method called FireEvent that can trigger the subscription. Lukasz suggests creating a dummy schedule that is will never run because it's configured in the passed. The report subscription you want to launch uses this dummy schedule. In a program you call the Firevent method on the reporting WebService .... and your report is delivered as you specifed it in your subscription.

I will show some screenshots how I did it, following Lukasz's tips.

So this is the report I want to be delivered on a file share in PDF.

First I make a dummy shared schedule. But one that will never fire a time event.

Now I create a new subscription on the report I showed before. It will use the shared schedule as Time Event generator.

In order to launch this subscription I must simulate a time event. The SOAP API of Reporting Services just gives me that.

This is a code snippet in VB.NET 2005 of how you could just do that.

It is important that you use the ID (ie. GUID) to specify the subscription. You can also look it up in the Subscription table of the reportserver database.

But before you go off and launch this code one thing is left to be configured (besides the folder share of course) . The account under which this program must execute will need "generate event" privilege on Reporting Service level. Because this is a single machine demo setup (november 07 CTP of Rosario). The user tfssetup is also as system admin on RS. So i just checked the checkbox for generating events on the RS syst. admin role .

The code snippet you just so will actually write an entry in the reportserver.Event table. The RS service will pick it up and act upon it. In our example it will write a pdf file into the file share folder (on the local disk ).

Have fun.

Best regards,

Alexander

Navigation button Visual Studio 2005

Hello,

When you open a freshly installed Visual Studio 2005 , you might miss certain things. For example the navigate backwards and forward button. Very handy when you navigate throughout your code.


You can easily add those buttons but nevertheless it is a bit strange that are not included by default (at least not on my machine) In VS 2008 (at least in the Rosario November edition) they are present and even a litlle bit smarter too. You can choose where you want to go back.


Open the "tools" menu and go to the "customize" menu-item.In the "view" category you will find the two missing buttons. When you select them , you can drag-and-drop them on your toolbar.

In Visual Studio 2008 you get the navigation buttons by default at a little bit more!

Best regards,

Alexander

Refactor!™ for Visual Basic® .NET 2008 and 2005

Hello,

In VS 2005 you have a refactor possibility in C# but there was none out-of-the-box in VB.NET. In VS 2008 it is still the same (at least in the Beta edition) for VB.NET. You still have to reside to third party products. Something odd to me because I would think that they would have had plenty of time to see how their C# colleagues did it . I guess they give the Visual Studio Eco system some crumbles from the table ...

DevExpress offers a FREE refactor product for Visual Studio. There was already a free version for VS2005. Now they have updated their refactor utility for VS2008. But the good news is that you also can use it in VS 2005. Moreover by registering, you are entitled to download and use a set of bonus refactorings for Visual Basic .NET including:

• Create Method Contract
• String Composition to String.Format
• Rename Local
• Safe Rename

Check out their web-site (http://www.devexpress.com/Products/NET/IDETools/VBRefactor/) for a complete overview of the refactors the add-on offers.

The latest incarnation is called Refactor! Free VB.NET with Bonus Refactorings v2.5.8 release 11 october 2007

• Standard Version for Visual Studio 2005, 2008 (size 20,197,328 bytes)
• Bonus Refactorings for Visual Studio 2005, 2008 (size 222,550 bytes) Only after registration.

An example of a refactor form the bonus pack : String.Format. Very handy!

Here some screenshots while executing the String.Format refactor

Regards,

Alexander

RDB Transactions [HYC00]

Today I got an error message when I tried to connect to an RDB data server through the ADO.NET ODBC brigde surrounded in a System.transaction. I'm using the ODBC driver for Oracle 3.02

So the following piece of code gives an error



Using tx As New TransactionScope
Using con As New Odbc.OdbcConnection
con.ConnectionString = "Driver={Oracle RDB Driver};server= ......"
con.Open()
' do your work here
tx.Complete()
End Using
End Using


The following error is thrown : System.Data.Odbc.OdbcException: ERROR [HYC00] [Oracle][ODBC]Optional feature not implemented. Meaning that the driver does not support the version of ODBC behavior that the application requested.


but when i slightly change the code, it works fine

Using con As New Odbc.OdbcConnection
con.ConnectionString = "Driver={Oracle RDB Driver};server= ......"
con.Open()
Using tx As New TransactionScope
' do your work here
tx.Complete()
End Using
End Using

Also using ODBCTransaction Object works fine

Dim tx As Odbc.OdbcTransaction = Nothing
Dim con As System.Data.Odbc.OdbcConnection = Nothing
Try
con = New System.Data.Odbc.OdbcConnection
con.ConnectionString = "Driver={Oracle RDB Driver};server= ......"
con.Open()
tx = con.BeginTransaction
'do your work here
tx.Commit()
Catch ex As Exception
If tx IsNot Nothing Then tx.Rollback()
Throw
Finally
If tx IsNot Nothing Then tx.Dispose()
If con IsNot Nothing Then con.Dispose()
End Try

So morale of the story ... somewhere System.transactions uses ODBCtransactions ?

Any info is welcome!


Regards,

Alexander

VISUG-devmatch 18/10/2007 - Datasets vs. OO

During this evening event , the Belgian Visual Studio user group (http://www.visug.be/) invited two speaker to present their views regarding datasets-oriented development and a more object-oriented way of working respectively.



Kurt Claeys (Ordina) was the advocate for the dataset approach while Yves Goeleven (Compuware) "preached" the Domain-Driven Design(DDD) way. Both did a good job !

Benefits (What did I learn)

• Use dataset-approach in application that needs to be build fast.
• Use dataset-approach If you are more at ease with the relational model than OO-models.
• Use a dataset to persist information on a PDA . You can use the dataset xml features for that.
• Check out the new dataset features in VS2008 . You can separate the generated TableAdapters from the dataset type in different projects. So you make a assembly with dataset types that are shared on several layers and/or tiers. There is also a "manager" that handles multi-table updates.
• Microsoft continues to invest in Datasets (VS2008 , LINQ to Datasets).
• But Microsoft also tries to keep up with the DDD camp (Entity Framework)
• There is also stuff in between LINQ to SQL
• Domain-driven design(DDD) is object-oriented design with emphasis on the problem domain. The domain model is the basis. I should catch up on that (http://www.domaindrivendesign.com/).
• DDD is difficult. Expect big learning curve.
• Don't expose domain layer immediately to UserInterface layer. You should consider other objects to transport the information of an entity (DDD for principal domain object representing something valuable for the business (customer order, etc).
• Use an ORM to help you bridge the Object-Relational mismatch
• You need involvement from all stakeholders to do DDD to practice the Ubiquitous Language principle.

Concerns (What did I miss)

• Example of DDD applications (or parts of ) to see side-by-side difference. Kurt prepared a lot of example applications to support his viewpoints.

Best regards,

Alexander

Datasets versus custom objects

Here is a list of benefits and concerns for each approach I compiled from various Internet sources and books. If you see other points or disagree with (some) things , don't hestitate to drop a line.

Datasets (.NET2.0)

Benefits

• Disconnnected data-container out-of-the box
• Typed datasets enhance ease-of-programming compared to "plain" datasets
• Table dataAdpaters automatically generated
• Visual designer in VS.NET to create typed datasets manually or via server explorer
• Add new data source wizard creates Typed datasets from database schema.
• Full two-way data-binding capabilities
• Built-in support to receive notifications when something changes inside.
• Search/sorting capabilities out-of-the-box (some help of DataView class)
• Work together with data adapters to retrieve and persist data.
• You can define relationships between tables (referential constraints)
• You can define constraint on columns (Uniqueness)
• Can hold many kinds of data types (.NET framework)
• The DataSet is serializable out-of-the-box (also binary )
• Has integrated XML capabilities
• Has built-in support for optimistic concurrency
• You can add custom logic in typed Dataset partial classes
• Using annotations, you can change the names of contained objects to more meaningful names without changing the underlying schema, making code easier for clients to use.
• handle NULL values out-of-the box
• Lot of third party controls support datasets
• Multiple version of a column value can exist and is available out-of-the-box (row state , GetChanges, Merge)
• With SQLdataAdapters you can load muliple tables in a dataset at once

Concerns

• Everything is represented in .NET Object type. There is a lot of casting/boxing going on
• Datasets used in webservices are not ideal from interoperability standpoint
• relational API maybe too restrictive (Tables and Relations properties). Need for special methods to represent/manipulate business entities.
• DataSet is tied directly to the database model. Abstractions are more diffeiclut . you must adhere to thinking in tables and related concepts.
• Inheritance. Your typed dataset must inherit from DataSet, which precludes the use of any other base classes.

Custom Collections

Benefits

• provide the means to expose data in easy-to-access APIs without forcing every data model to fit in the relational model. You can still make a one-to-one mapping with the database but you can more easily use OO technisues to model the your problem domain.
• Advanced relationships like inheritance are possible.
• You can add any behaviour that is needed. Custom entities can contain methods to encapsulate (simple) business rules. Custom entity classes can perform simple validation tests in their property accessors to detect invalid business entity data.
• custom class can be marked as serializable
• Code can be easier to understand/maintain
• LINQ To SQL, Entity Framework are special features in future version of .NET. So MS recognizes benefits of this way of working (or is it under market pressure :)
• using custom classes makes for easier unit testing

concerns

• Programming effort can be bigger than all-dataset scenario
• you must implement a interfaces in order to provide for effective containment and data-binding capabilities
• Mapping custom collections and entities to a database can also be a complicated process that can require a significant amount of code (need for code generation/ORM tool)
• To support optimistic concurrency time stamp columns must be defined in the database and included as part of the instance data.
• Support for multiple versions of data state within an entity must be coded.
• No Searching and sorting of data out of the box. You must define your own mechanism to support searching and sorting of entities.

Sources & recommended reading

• DataSets vs. Collections, Dino Esposito, http://msdn.microsoft.com/msdnmag/issues/05/08/CuttingEdge/default.aspx
• Designing Data Tier Components and Passing Data Through Tiers , MSDN Practices&patterns, http://msdn2.microsoft.com/en-us/library/ms978496.aspx
• Dataset versus objects, Paul Stovell, http://www.paulstovell.net/2006/10/18/DataSets+versus+Objects.aspx
• Data Binding with Windows Forms 2.0: Programming Smart Client Data Applications with .NET , Brian Noyes, Microsoft .NET Development Series