Data Dude + Developer Edition = Team Developer

{From My VSTS KB}

In today's press release titled: "Visual Studio 2010 and .NET Framework 4.0 Overview" MS also announced the merge of the Developer Edition and Database Edition SKU's.

From Gert’s post:

What does this mean?

In the next release of Visual Studio Team System we will be merging the feature sets of the Development Edition and the Database Edition into a single product. The new product – part of Visual Studio Team System codename “Rosario” – will include all of the features in the Development Edition and the Database Edition as well as new capabilities delivering even more value in a single product. This will provide a more complete set of capabilities for building software in today’s data-driven environments. Bringing these two feature sets together enables you to take advantage of the core tools for application development as well as the necessary tools for database development, including performance profiling, code analysis, code metrics, code coverage, database refactoring, Schema Compare, Data Compare, and more.

As an MSDN subscriber we want you to realize the benefit of this merged feature set now, which is why we are extending this exclusive offer. If you have either the Visual Studio Team System 2008 Development Edition with MSDN Premium subscription or the Visual Studio Team System 2008 Database Edition with MSDN Premium subscription, on October 1, 2008 you will have access to both the Development Edition and Database Edition through MSDN Subscriber Downloads. This change also applies to customers who purchased Visual Studio 2005 Team Edition for Software Developers with MSDN Premium Subscription and Visual Studio 2005 Team Edition for Database Professionals with MSDN Premium Subscription.

Team Foundation Menu Doesn't Exist In VB6 After MSSCCI Isntallation

I spent hours to understand why it happened…

My customer has VB6 SP5, we installed Team Explorer 2008, MSSCCI provider…and nothing! I started the VB6 IDE, but I cannot find any source control or Team Foundation menu's.

Then I found this thread.

The Solution:

Add the line:

vbscc=1

To c:\windows\vbaddin.ini

Then restart VB6, and you get a new menu item: Tools, Team Foundation.

Expression Blend & Team System

Many customers ask me the same question: does Expression Blend can talk with Team System / Source Control?

The answer, unfortunately, is no. Blend does not have the ability to use a source control repository and actually strips out any source control binding it finds in a project file.

Virtual Team System User Group

From: http://vstskb.net  - http://feeds.feedburner.com/~r/vstskb/~3/394418841/

Paul Hacker and Dave McKinstry have started a virtual Team System user group. The user group will use Live Meeting for demos and talks, holding the social side of the user group meeting over in Second Life.  For more information and to register visit: http://www.tsug-ve.com/

The first meeting will be held on September 18, 2008 at 6:00 PM SLT.

For the meeting time in other time zones, click here.

VSTSDB 2008 GDR CTP16

Gert just posted about the release of CTP16 of the Visual Studio Team System 2008 Database Edition GDR release.

From Gert’s post:

This release adds the following features:

• VSDBCMD.EXE
  • We added independent commandline deployment and reverse engineer, which can be used on machines that do not have Visual Studio installed, in order to deploy the results of a database project build (.dbschema file), or if you need to generate a .dbschema file so you can for example compare it, this commandline tool will let you do that as well.
• Database Project (.dbproj) Upgrades
  • CTP15 enabled upgrade of project files, but did not included updating Data Generation Plans (.DGEN files), which now be upgraded when they are opened the first time inside the DGEN designer.
• Schema Compare
  • You can now choose the SQL Command Variables (SQLCMD) to use during a Schema Compare session by clicking the “Specify SQLCMD variables” button on the Schema Compare toolbar. This will allow you to compare projects that are using SQLCMD variables and provide the contextual information via the variable values.
  • You can now set the Schema Compare options at the session level, in addition to Tools->Options, by clicking the Settings button on the Schema Compare toolbar.
  • And you can now save your Schema Compare session and reopen it again. We also added an item template for this, name "Schema Comparison"
    
• Extensibility
  • We finished the namespace and assembly naming cleanup. As a result all assembly names and namespaces have been changed. This means if you have code leveraging our extensibility mechanisms you need to update the assembly references and namespaces in your code.
  • We added the ability to add your own refactoring types! So now you can create your own refactoring command and have it change all the required references inside the schema. This is above and beyond the ability to create your own refactoring targets (the sources your want to change by an refactoring type), static code analysis rules, data generators, data distributions and test conditions.
  • We now also offer public access to our TSQL parsers for SQL Server 2000, 2005 and 2008, including the script generator functionality.
• And then there are many more enhancements in the parser, interpreter, validation, build and deploy.

Pre-requisites:

CTP16 requires the following components to be installed:

• Visual Studio 2008 SP1 RTM
• Microsoft SQL Server Compact Edition 3.5 SP1

Download location:

You can download CTP16 from the following location:

• http://download.microsoft.com/download/0/a/e/0ae1153a-8798-474a-93e6-d19299f37c8b/setup.exe
• http://download.microsoft.com/download/0/a/e/0ae1153a-8798-474a-93e6-d19299f37c8b/Readme.mht
• http://download.microsoft.com/download/0/a/e/0ae1153a-8798-474a-93e6-d19299f37c8b/VSTS 2008 Database Edition GDR Documentation.zip

NOTE: If you have a previous version of the GDR installed, you will have to first uninstall this and then install the latest CTP16 bits.

CTP15 of the GDR release of VSTSDB is available

Gert just announced that they just released a new CTP of the upcoming 2008 update, Microsoft® Visual Studio Team System 2008 Database Edition GDR.

You can download it from MSDN:
http://www.microsoft.com/downloads/details.aspx?FamilyID=bb3ad767-5f69-4db9-b1c9-8f55759846ed&displaylang=en

Most important changes:

• Project upgrade is now in place.
• Mixed projects are no longer supported, from now on server projects represent only server creatable objects and user objects that need to be deployed to “master”. Another change is that server options will not get deployed; we only validate the settings as pre-requisites for a deployment. As such server options (sp_configure) have been added to the project system.
• The interpreter now understands temporary tables, table variables and select into column sources.
• The Static Code Analysis MSBuild task was added
• XSD Reference user interface support is enable, but it does not yet create XML Schema Collections
• And lots of fixes since CTP14

 

Share this post :

VSTS 2008 Team Foundation Server Power Tools - July 2008 Release

The Visual Studio Team System 2008 Team Foundation Server Power Tools is a set of enhancements, tools and command line utilities that improve the Team Foundation Server user experience.

The latest power tools release can be found here: TFS July 2008 Power Tools. 

See BHarry’s blog for an overview of all the great enhancements and make sure you download and install it.

The following tools are installed with the tfpt.msi package:

• Command line tool (TFPT.EXE)
• Team Explorer IDE menu additions
• Build Notification tool
• TFS Best Practices Analyzer
• Process Template Editor
• Work Item Templates
• Custom check-in policies
• TFS Server Manager
• TFS Users tool
• Alert Editor

Also available is the WssExt64Bit installer which provides the ability to install the Team Foundation Server WSS extensions into a 64-bit WSS instance. The RTM version of the WssExt installer that ships with Team Foundation Server 2008 does not support 64-bit WSS sites.

For more information, see Visual Studio Team System 2008 Team Foundation Server Power Tools.

Share this post :

Configure Team Foundation Build for an Incremental Build

A question I got today: "How can I configure my Team Build for an incremental build?".

So, it's simple.

Team Build 2005

Add the PropertyGroup definition to the end of the TFSBuild.proj file, before the closing </project> tag.

Set the following properties:

   <PropertyGroup>
      <SkipClean>true</SkipClean>
      <SkipInitializeWorkspace>true</SkipInitializeWorkspace>
      <ForceGet>false</ForceGet>
   </PropertyGroup>

 

Team Build 2008

Set IncrementalBuild property to true. To do it, add the PropertyGroup definition to the end of the TFSBuild.proj file, before the closing </project> tag.

   <PropertyGroup>
      <IncrementalBuild>true</IncrementalBuild>
   </PropertyGroup>

 

Source - msdn:

Team Build 2005: http://msdn.microsoft.com/en-us/library/aa833876(VS.80).aspx

Team Build 2008: http://msdn.microsoft.com/en-us/library/aa833876.aspx

Templex-Sharing Team System Process Templates

We always asked for a library of process templates available and also easy way to share ones we created.

Templex is a new CodePlex project has just been created for this purpose. 

From the project’s page:

This CodePlex projects serves as a repository for open source Team Foundation Server (TFS) process templates, work item type definitions and report definitions. TFS uses process templates to configure new team projects. Each process template includes the following:

• TFS Security groups and permissions
• Initial set of Areas and Iterations
• Work item type definitions
• Initial set of work items
• Work item querys
• MS Project Mappings
• Version control permissions and settings for check-out and check-in
• Project portal document library settings, including an initial set of documents
• SQL Reporting Services report definitions

Once a team project is created, the following configuration items can be imported, exported and modified:

• Work item type definitions
• Work item queries
• Report definitions

 

 

http://www.codeplex.com/templex

VSTS 2008 Database Edition GDR June CTP

Yesterday, at TechEd 2008 Developer, Data Dude team announced the immediate availability of the first public CTP of the Visual Studio Team System 2008 Database Edition GDR (General Distribution Release).

 

The GDR is available now for download but before you install it, make sure read the installation requirements. If you have DBPro Power Tools installed, uninstall it first. AND you'll need to have Visual Studio 2008 Service Pack 1 Beta installed

 

 

From Gert's post:

What is in the GDR?

In addition to enabling SQL Server 2008 database projects, the GDR release incorporates many of the previously released Power Tools functionality as well as several new features. The new features include explicit separation of Build and Deploy, separation of Database and Server project, improved project reference support, T-SQL Static Code Analysis and integration with SQL-CLR projects.

Architectural changes

• No more DesignDB; one of the most important architectural changes is that the Database Edition no longer requires a local SQL Server instance to host the "Design Database" to open and validate a database project.
• Single model, everything is now loaded in a single model representation. The model now represents all object types, which removes the need to have certain objects represented as Pre or Post Deployment scripts. This means that for example logins, rules, defaults, asymmetric keys, symmetric keys, certificates, etc. are now schema objects and therefore fully participate in schema comparison and build/deploy. Pre or Post Deployment scripts still exist, but are only used to perform none schema object related operations.
• The model is no longer 100% memory resident, in today's version all model information has to reside in memory, this change dramatically lowers the memory consumption of the product.
• Provider based, the underlying implementation of the project system and schema model are changed to be provider based. Providers are refer to as "Database Schema Providers" or DSP's for short. The GDR release will ship with 3 providers supporting SQL Server: 2000, 2005 and 2008. However if you watch the Tech*Ed keynote this morning, you saw that IBM is working on a provider to support DB2 and there are others that are working on providers for other database management systems.
  • Providers are not restricted to relational database systems, in the future we will be adding providers that support dimensional and hierarchal data stores.

Project System

• Database & Server project separation
  • We separated out the existing database project in to two project flavors: database and server. The server project represent those schema objects that are server wide, for example logins, linked servers, server side DDL triggers etc. Database projects represent the objects inside the user database. The split enables a team to define a standard a configuration for their SQL servers and reference it from their Database Projects. The goals is to have a single point of definition and to be able to share this definition between projects and deployments.
    • The separation is implemented using a property inside the project file. There are effectively 3 modes: server, database and hybrid. The hybrid project represents the overloaded project model as it exists today where server and database objects are mixed inside a single project. This model is there to support existing project upgrades.
• Partial projects
  • Allow code sharing between projects by including files from a different project, where the code is included "as-is" from the originating project and the source code control ownership remains with the originating project. This enables code reuse between projects and while resulting in a single deployment unit.
• Composite projects
  • Composite projects, enables database projects and/or .dbschema files to contribute to another project. This enables the separation of development roles and responsibilities and composition of Databases using multiple projects. It extends the existing database reference implementation, by allowing to contribute in to the same database, where the existing database projects have to represent 3 or 4 part name references.
• Single sourcing of external artifacts
  • You can now create a reference to a SQL-CLR (VB.NET or C#) project, or the binary output of a project and turn it in to a ASSEMBLY inside the project. This enables single sourcing of artifacts that are developed outside the context of the database project. For the final release we will also allow references to XSD files which will become XML Schema Collections inside the database schema.

SQL Server 2008 Support

• The GDR adds a new project for supporting SQL Server 2008. The June CTP has support of the new SQL Server 2008 data types, both intrinsic (date, datetime2, datetimeoffset, time), build-in SQL-CLR types (geography, geometry, hierarchyid), support for the new DML MERGE syntax and support for table typed parameters. The remaining SQL Server 2008 syntax and functionality will be added in future CTP's.

Build & Deploy

• One of the other main changes in the GDR is the separation of the build and deployment process. Build now produces a single portable artifact file, a .DBSCHEMA file. The DBSCHEMA file is an XML representation of your complete schema. The DBSCHEMA is then fed in to the redistributable deployment engine.
• The deployment engine now uses the exact same database model as Schema Compare, which guarantees the same results between the two parts of the system.

Refactoring

• The biggest change in refactoring is the addition of a patented implementation of a feature named "Preservation of Intent". This enables the deployment of refactoring changes as intended by the user. For users this means that renames are deployed as renames not as drop/add statements, move aschemas as move schemas etc.
• Besides that we are adding new refactoring types that we previously in the Power Tools:
  • Wildcard Expansion
  • Move Schema
  • Fully Qualify
• And we are enabling extensibility for refactoring which enables users to develop and deploy custom refactoring types and targets.
  • Types are the refactoring operations, where targets are the artifacts you want to apply the refactoring operation to. An example of a refactoring type is: table split or upper case all keywords. An example of a refactoring target is an Reporting Services RDL file, which contains references to database schema objects, which if you change thos, you want to update them as part of the refactoring operation.

Schema Compare

• Schema Compare now uses the same underlying database model as build and deploy, guaranteeing fidelity between the results. This allows the user to compare any combination of Database Projects (.dbprj), live Databases or .DBSCHEMA files.  So comparing project to project, project with a DBSCHEMA file, or a DBSCHEMA file with a live database.
• We added the ability to limited the schema comparison based on object types (Object Type Filtering) and we added additional Ignore filtering options.
• We also enabled the substitution of SQLCMD variables, allowing correct comparison when using SQLCMD variables for references or in other parts of your code.

T-SQL Static Code Analysis

• T-SQL Static Code Analysis, and the accompanying MSBuild task, are now part of the main product.
• And we added the ability to develop and deploy your own custom T-SQL Static Code Analysis rules.

Dependency Viewer

• The Power Tools to view the dependency relationship between objects inside your schema, is now part of the base product.

Database Unit Testing

• Database unit testing now supports execution of tests using different ADO.NET providers and it also enables unit testing when using multiple database projects.

• Data Generation

• We made some general design-time enhancements Data Generation like adding support for undo/redo and separation of the population status into new display window.
• The Foreign key generator can now be replaced by custom generator.
• And we made some runtime enhancements, by default the Data Generator now uses the SqlBulkCopy interface to populate target tables, which results in a general performance improvement during data load time.
• We also introduced the concept of Data Sinks which allow the user to register different outputs, for example we can generate data to files instead of to a live database, so data can be loaded out-of-band using BCP or BULK INSERT. 
• And last but not least we were able to significantly trim the size of the .DGEN file. 

Public extensibility:

• The last piece we changed in the GDR is to expose more extensibility points in to the system. In the GDR we are not allowing new providers to be plugged in this will be available in the next release, but we do allow users to extend the system by writing their own:
  • Data Generators
  • (Statistical) Data Distributions
  • Test Conditions
  • T-SQL Static Code Analysis Rules
  • Refactoring Types
  • Refactoring Target
• We also made the deployment engine a redistributable component, so you can deploy DBSCHEMA files programmatically.

Microsoft Source Analysis for C#

Microsoft announce the public release of a new developer tool -  Source Analysis for C#.

Inside Microsoft this tool's name is StyleCop and it enforces code style guidelines on the code we write

Source Analysis comes with a set of default rules analyzers covering approximately 200 best practice rules. These rules are full compatible with the default layout settings in Visual Studio 2005 and Visual Studio 2008.

Specifically, these rules cover the following, in no particular order:

• Layout of elements, statements, expressions, and query clauses
• Placement of curly brackets, parenthesis, square brackets, etc
• Spacing around keywords and operator symbols
• Line spacing
• Placement of method parameters within method declarations or method calls
• Standard ordering of elements within a class
• Formatting of documentation within element headers and file headers
• Naming of elements, fields and variables
• Use of the built-in types
• Use of access modifiers
• Allowed contents of files
• Debugging text

After installation, Source Analysis can be run from within the Visual Studio IDE. You can set this up to be run as a part of your build process as documented here. Since this is plugged in as a MsBuild project you can use it in as a part of Team Foundation Build process as well.

 

Running Source Analysis:

And the results are:

 

Download it from: http://code.msdn.microsoft.com/sourceanalysis

Read full details:http://blogs.msdn.com/sourceanalysis/archive/2008/05/23/announcing-the-release-of-microsoft-source-analysis.aspx

Rosario Preview #4: Tester Edition

Visual Studio Team System Code Name "Rosario" Test Edition provides new functionality that lets you easily create, manage, edit and run manual tests. Read about manual tests here.

The new Tester Edition is great that address the needs of the UI testers.  This post is a preview of the main features in this edition.

(Click on images to enlarge)

 

Planning a Testing Effort

Camano is a standalone application that allows users the ability to author, plan and manage a testing effort from a simple UI specialized for displaying test artifacts.  Planning a testing effort gives you the ability to manage your manual testing efforts and report on your progress. By using this functionality, you can create test plans that show what you plan to test for a specified period of time. Also, you can create test configurations that specify the test environments for your tests.

 

 

Camano's main window

 

Test Case Planning

 

Test Suite

The manual test cases you create are associated with a specific team project. You can add test steps, validation steps, and parameterized data to the manual test case.

You organize the manual tests into test suites, and then you create a test plan to define which test suites will be run on specific test configurations. You can select the tests you want to run from the test plan.

 

Executing Manual Test Cases

When you run a manual test, you can optionally make a video recording of the test case. You can add comments, screenshots, and other files as you run the test. If the test fails, you can create a bug. This bug is automatically populated with any of the following information associated with this specific run of the test case:

• Test steps

• Validation data

• System information

• Video recording

• Screenshots

• Log files

• Action log

 

Because this functionality is integrated with the other parts of the Visual Studio Team System, you can publish the results to your Team Foundation Server.

 

 

Automate a manual test & add validation

Suppose we asked to convert the test into a coded UI test that can run in un-attended mode, we can generate the code from the background recording & then adds validation code using Visual Studio:

 

Create new UI Element

 

Adding validation code

 

Related posts:

• Download the VPC.
• Preview #1 - Source Control Features.
• Preview #2 - Team Build
• Preview #3 - Development Edition

Error when Creating Database Projects

Recently I got a question about permissions error that  occurred when trying to create database project in the local instance of Microsoft SQL Server used for design-time validation. The error was: "CREATE DATABASE permission denied in database 'master'".

Workaround

To create database you must be a member of the dbcreator and securityadmin fixed server roles in the server instance that you specified for design-time validation.

First, ensure that the instance name that is specified for your design-time validation database is correct.

Second, a user with sysadmin permissions should run the following script on your design-time validation database:

USE master
GO
GRANT EXECUTE ON sp_detach_db TO public
GO

For more information read Required Permissions in Database Edition.

How To Deploy Data Dude Project Changes using Team Foundation Build

When you want to build and deploy database projects with team build you need to edit the database project file and the Team Build file. That's because database projects store any non-default values for the TargetDatabase, TargetConnectionString, and DefaultDataPath properties in a <ProjectName>.dbproj.user file.  *.user files are not checked into version control in order to let every user use different values.

 

Step 1 - Modify build project file (team build .proj file)

Open the BuildDefinition.proj file, and at the bottom of the file, between the </ItemGroup> element and the </Project> element, add the following:

<Target Name="AfterDropBuild">
  <MSBuild Projects="$(SolutionRoot)\SolutionName\ProjectName\ProjectName.dbproj" 
      Properties="Configuration=Default;OutDir=$(SolutionRoot)\..\binaries\Default\" Targets="Deploy" />
</Target>

 

Step 2 - modify the database project file

The target connection and database are stored in the ProjectName.dbproj.user file, which is user specific and not typically checked in to version control. You require those settings to deploy your database. Therefore, you must modify the ProjectName.dbproj file manually to specify the target connection and database.

Copy the lines that contain the definitions for the TargetDatabase and TargetConnectionString properties from the section in the ProjectName.dbproj.user file for the configuration that you want to build. These lines will resemble the following:

<TargetDatabase>MyTargetDatabaseName</TargetDatabase>
<TargetConnectionString>Data Source=ServerName\InstanceName;Integrated Security=True;Pooling=False</TargetConnectionString>

If TargetDatabase and TargetConnectionString already contain empty elements, you should overwrite those entries.

 

More into at the msdn page.

New Rosario Specifications

In addition to my previous post about influencing on TFS future, the TFS team has just uploaded two of the new Rosario Specifications:

• Organize team queries and my queries using a folder hierarchy and
• Team Foundation Server Bug Submission Portal.

 

To post feedback or ask questions about these Forums please use the forum located at: Discuss and Provide Feedback Here

1. Resolve Improvements
2. Core Linking Work Item Tracking
3. Send Mail from TFS
4. Add to Source Control
5. Enterprise Team Foundation Server Management
6. History Improvements
7. Improved Label Dialog
8. Organize team queries and my queries using a folder hierarchy
9. Team Foundation Server Bug Submission Portal

BDW, You can taste Rosario here!

March 2008 TFS Power Tools now available

Brian Harry has just announced that the March 2008 Team Foundation Power Tools have been released:

We've just released a new version of the TFS Power Tools.  This new Power Tool release will work only with the VS/Team Explorer 2008 client (but against either a TFS 2005 or TFS 2008 server).  If you haven't taken the time to upgrade yet, I highly recommend it - you are missing out on lots of great new value we are delivering.

This release includes:

• Process Template Editor support for custom work item controls
• TFSServerManager client
• TFS BPA support for Windows Server 2008
• Work Item Template improvements Scriptable Team Project creation
• Support for 64-bit Sharepoint farms
• Unshelve to a different branch
• Improvements to tfpt review
• Delete global lists in the work item tracking system
• Update bound Microsoft Office docs when the TFS server name changes
• Performance improvements in tfpt online

Click here to download.

Enjoy!

Rosario Preview #3 - Developer Edition

The 3rd preview of Rosario's April 2008 CTP will focus on the Development Edition. This edition has some great features, my favorites are: Historical Debugger, Standalone Debugger and Rule Sets for Code Analysis.

(Click on image to enlarge it)

Historical Debugger

Visual Studio Historical Debugger captures and records what the application does while it is running. When an error occurs, you can quickly find the root cause by investigating the information that was recorded by the Historical Debugger. At any time during debugging, you can go backward and forward in time to determine where an error occurred.

Historical Debugger increases debugging productivity by reducing the time it takes to reproduce and diagnose an error in your code.

 

Code Analysis with Rule Sets

We are presented with a list of built-in rule sets when we configure Code Analysis. We can either use the minimum recommended rules, or we can select alternative rule sets that relate to our project type. In either case, the rule sets can also be customized to fit your project requirements
For example, you can select a rule set that is suited for scanning code for a publicly available API.

 

Available Rule Sets

Rule Set	Description
All Rules	This rule set has all rules enabled.
General API Design Guidelines	This rule set contains rules that apply to any API, especially if the API is intended for external use. These rules closely follow the design guidelines for the .NET Framework. Use this rule set if you are building a programming interface such as a class library, Web service, WCF service or workflow library.
General Web Development Guidelines	This rule set contains rules that apply to Web development. This includes Web applications, server controls, AJAX and Web services. This rule set enables additional security and performance rules that help ensure that your Web site is reliable.
General Windows Application Guidelines	This rule set contains rules that apply to Windows application programming. Use this rule set to help you assess the quality of your Windows application. This rule set applies to Windows Forms applications, console applications, WCF applications, WPF applications and workflow applications.
Legacy Code Cleanup	This rule set contains rules that can help clean up legacy code. The rules that are violated can be fixed without having to change the public interfaces of your code. Therefore, they are ideally suited to cleaning up a legacy code base. These rules apply across all project types for which analysis is enabled.
Minimum Recommended Rules	This rule set has the minimum set of rules enabled. If you encounter warnings when a scan with this rule set is enabled, it is likely that there is an error in your code.
Release Criteria	This rule set contains rules that should be applied to an application that is undergoing final checks before release.

 

Debugging with the Standalone Debugger

Visual Studio Stand-Alone Debugger is a lightweight, stand-alone debugger that allows you to quickly diagnose problems in development, test, and production environments.

Visual Studio Stand-Alone Debugger (VSSD) does not require setup or configuration, which makes it ideal for situations where it is important to have minimal impact on the environment. In addition, deploying Visual Studio Stand-Alone Debugger is as simple as copying a few files. We can carry Visual Studio Stand-Alone Debugger on a USB thumb drive for “Just-In-Time” troubleshooting....

Creating the Standalone Debugger

 

Wizard ...

 

 

This is the wizard's product - folder which contains the debugger...

 

And the debugger!!

 

Once the Standalone Debugger is running, we can click the “Attach: Process” link on the start page to start debugging.

Additionally, the VSSD does not touch the system's registry. The VSSD uses most of the features that are available in the Visual Studio Debugger.

Summary

The development edition  has several new features, most of them in the area of the debugging and testing. I'm sure that the productivity of the developers and the quality of code will increased.

 

Enjoy!!

 

Posts about Rosario:

• Download Rosario CTP 12 VPC
• April 2008 CTP page
• Rosario's tag

Rosario Preview #2 - Team Build

This is the second post in a series about April CTP of Rosario's.

Team Build System Based on Windows WorkFlow Foundation

The new Team Build system in Rosario built on Windows Workflow Foundation, featuring dynamic build machine allocation from a machine pool and distributed build functionality.

 

New Term - “Build Controller”

In Rosario, Team Build uses an agent/controller architecture where the controller is responsible for managing a pool of agents. Notice the notion of “Tags” which let you define metadata for a build controller/agent. Then you can target your builds at agents/controllers that have a specified tag.

Controller that hosts a build execution is the pool of build machines where the build will run. Additionally, the workflow that comprises your build process will run on both the controller and the agent with coordination activities occurring on the controller.

No doubt, Rosario's Team Build introduce interesting issues especially the support in WF - it seems that most of the problems in the area of custom task(s) can be handled by this issue. I'll check it out and post about it later.

Enjoy!!

Posts about Rosario:

• Download Rosario CTP 12 VPC
• Rosario's page
• Rosario's tag

Team System Web Access 2008 SP1 and Work Item Web Access 2008 CTP's Available

Community Technology Previews (CTP) for Team System Web Access 2008 SP1 and Work Item Web Access has just released by Hakan Eskici and TFS team.

Team System Web Access (TSWA) 2008 SP1 (CTP)

• What's new in TSWA 2008 SP1
• Download the CTP for TSWA 2008 SP1

Work Item Web Access (WIWA) 2008 (CTP)

• What's WIWA?
• Download the CTP for WIWA 2008

Rosario Preview #1 - Exciting Enhancements Of The Version Control

This is the first post in a series I'm writing about Rosario's tidings.

The first taster will be about the new enhancements in the Source Control area.

So, what's new there?

• Editable source location field

 

this enables us to navigate to other place in the tree easier, also copy this location.

• Last checkin column

we don't need to open the history in order to know when the file was checked-in.

• Hyperlinks to local working folders

great feature - click on this link opens the local mapped folder .

• Simplified workspace mappings

  • Now you can  cloak folders from the mappings
  • Mapping a folder from the source control itself without opening the workspace manager.

Map to local folder:

Cloak folder:

 

• A new Add Files to Source Control wizard and support for drag and drop from Windows Explorer to Source Control Explorer

We can add files from the tree and a wizard is opened. The wizard helps us to map a folder if it's not mapped and even exclude items.

 

• Enhanced, non-modal conflict resolution experience, integrated into the pending changes tool window

• New history view that shows labels applied to a file