Visual Studio

The URL X for Web project Y is configured to use IIS as the web server but the URL is currently configured on the IIS Express web server…

Rick G. Garibay — Thu, 08 Nov 2012 17:06:10 GMT

I was working on some demos today moving from a VM to my core host OS and when I tried to open the solution in VS12 that contains a handful of ASP.NET and WCF Service application projects, VS refused to so so, reporting the following error:

The URL X for Web project Y is configured to use IIS as the web server but the URL is currently configured on the IIS Express web server. To open this project, you must edit the 'C:\Users\User\Documents\IISExpress\config\applicationhost.config' file to change the port of the site currently using the URL in IIS Express.

I remembered that I had shut down IIS because I was working on some node.js stuff, so I started all services and still had no luck.

From there, I went into the config file for IISExpress as directed and changed the ports to something other than 80, still to no avail.

The solution was to open the .csproj files, find the UseIIS element and change it to False:

<VisualStudio>
      <FlavorProperties GUID="{349c5851-65df-11da-9384-00065b846f21}">
        <WebProjectProperties>
          <UseIIS>False</UseIIS>
          <AutoAssignPort>True</AutoAssignPort>
          <DevelopmentServerPort>4383</DevelopmentServerPort>
          <DevelopmentServerVPath>/</DevelopmentServerVPath>
          <IISUrl>http://localhost/StatusStreamClient</IISUrl>
          <NTLMAuthentication>False</NTLMAuthentication>
          <UseCustomServer>False</UseCustomServer>
          <CustomServerUrl>
          </CustomServerUrl>
          <SaveServerSettingsInUserFile>False</SaveServerSettingsInUserFile>
        </WebProjectProperties>
      </FlavorProperties>
    </VisualStudio>

Of course, you’ll need to reset this though the project properties based on whether you want to use IISExpress or IIS to host your application.

I’m not sure if this is a bug or an environmental issue, but regardless, I can’t imagine why the presence of a web server or lack thereof should ever be a reason to stop a solution from loading projects, ever. If I have time, I may log this to Connect, and if anyone has any insights, please let me know.

Until then, hope this help should you run into the same issue.

Visual Studio 2012 Keynote Deck and Notes

Rick G. Garibay — Sat, 06 Oct 2012 01:16:22 GMT

I had the pleasure of being invited to keynote the Visual Studio 2012 Launch at Microsoft Tempe on Monday and would like to thank Microsoft for having me and everyone for attending.

I’ve been really impressed with the VS 2012 bits since working with the previews and it was a great privilege to showcase all the amazing features in the IDE and new version of TFS.

In my role at Neudesic, I spend a lot of time talking to customers about their challenges and how we can help make them more productive. The reality is that there is a tremendous shift happening in the way that IT operates and is consumed today. Compared to just 5 years ago, organizations that want to succeed must leverage technology in a manner that allows them to both grow and innovate as opposed to merely running their legacy assets. The emergence of devices, and corresponding customer expectations to be productive anywhere, on any device has forced new, modern trends and work styles that IT must contend with or they will simply be left out.

Often, I talk to customers about this through an integration lens, but it applies just as equally to Application Lifecycle Management (ALM). While I strongly believe that integration is a core strategic enabler to unlocking an organization’s potential to maximize their investments in Systems of Record assets enabling them to compose existing assets with new capability to grow the business in new ways that differentiate them from the competition while driving innovation, none of this is possible without the right people, technology, process and tools.

I believe that one of Microsoft’s biggest value propositions is that it provides a single, unified platform for delivering capabilities both on-premise and in the cloud. This single platform approach extends from devices; including desktops, laptops, tablets and smart phones to always available compute resources in the cloud or on-premise. This is compelling for many reasons, not the least of which is the developer economics of working within a platform that embraces both native and web development styles providing a first class tooling experience for each without compromise.

I’ve worked with Visual Studio and TFS since the 2005 release and while the product has matured and grown significantly with each subsequent release, Visual Studio 2012 and TFS 2012 is really a coming of age. The user experience is exceptionally polished, and while I will admit that I was very vocal on some of the changes from the 2010 aesthetic, the final product is fast, efficient and fluid.

Some of my favorite new features in the new release includes local workspaces. With local workspaces (now the default), we can ensure that we don’t lose productivity (or our precious code) when on the go. Detecting changes to files under source control and adding new files- whether within the IDE or using another tool just works.

And Team Explorer just flies. Asynchrony is no longer an esoteric, dark art but a requirement for delivering responsive, fast user experiences and Team Explorer in VS 2012 is a great example of lazy loading and asynchronous messaging for enabling a great user experience.

I also love the new My Work feature. Distractions are an unfortunate part of every developer’s day and it seems that just when you are in the zone with all of the right files open, break point set getting close to completing that feature of fixing that defect, you get that emergency call that takes you away from your work. With My Work, you can simply suspend your current working session and Visual Studio will literally dehydrate all of your context including files, break points, etc. until you return, leaving your IDE clean and ready for the next fire. When you are done saving the world, you can simply resume your work and the IDE is literally rehydrated just as you left it. It really is amazing.

Speaking of information radiators, the TFS web client is beautifully redone. All of the metrics that your team values can be added to your team/area’s dashboard as a favorite. While I’ve always been an IDE zealot as far as working with WIs, queries, etc. the management experience in the new web client is exceptional. I can prioritize stories, do release planning on the fly and get a snap shot of how utilized or under allocated my team is with just a glance or by reviewing the new Taskboard feature which provides a view into state of work by team member or as a team.

As the pace or speed at which the business expects IT to be able to deliver value, particularly within systems of innovation like web sites, web apps, etc., the tolerance for misunderstood requirements has shrunk significantly. To quote the old adage: “You’ve built exactly what I asked for, but it isn’t at all what I want”, it is very easy to misrepresent and misunderstand requirements, particularly within the presentation layer. Many design technologists minimize this risk upfront by introducing wire frames and story boards. VS 2012 brings some entry level story boarding tools to developer hands by integrating with the most popular modeling tool out there: PowerPoint. Supporting mobile, native and web styles, it’s now easier to put together mock ups to gain feedback earlier in the development lifecycle when changes are least expensive.

Another very cool feature is the Feedback Client/Manager. Anyone who has ever worked with me on a project knows that I am a big believer in the importance of feedback, early and often. Whether that means ensuring that _everyone_ knows the status of the build (and owns the outcome) or has visibility to the backlog, current velocity and burndown, identifying meaningful information radiators (Alastair Cockburn’s term) is essential. As I always remind folks: If the first time the customer has seen your feature is in the demo meeting, you suck. Just as you wouldn’t pay a home builder to build your dream house and accept that you can’t visit as the foundation is laid, frame goes up, windows and dry wall go in, software is no different. By using the new Feedback Manager, you can invite your stakeholder/product owner/manager to review and explore your feature via an automated email that maintains traceability to your work item/story. From there, the stakeholder can walk through the feature, capture feedback via voice, images, video or text, and punt that actionable feedback right back to you. Of course, I would never suggest this as an alternative to having a conversation, but as teams become increasingly distributed, this is a great capability for ensuring you are getting feedback early and often.

Lastly, as a TDD zealot, I am really digging the improved support for unit testing. Everything from an improved test runner that reports execution time to support for fakes and stubs makes test-first development much more tenable without resorting to 3rd party tools or frameworks (not necessarily a bad thing, but you never know when an open source project might be abandoned leaving you and your team in a lurch).

Wow. Ok, that’s a ton of stuff and I haven’t event scratched the surface so I’ll leave you with the slides I shared and a link to download and evaluation Visual Studio 2012 and TFS toda http://www.microsoft.com/visualstudio/eng/downloads

New Microsoft Whitepaper on Extending WCF Apps for Windows Azure

Rick G. Garibay — Mon, 07 Mar 2011 18:51:38 GMT

I’m pleased to share that Microsoft has just published my whitepaper “Developing and Extending Apps for Windows Azure with Visual Studio”: http://www.microsoft.com/en-us/cloud/developer/resource.aspx?resourceId=developing-and-extending-apps

In this whitepaper, I summarize the significance of cloud computing today and disambiguate the differences between Software as a Service (SaaS), Platform and a Service (PaaS) and Infrastructure as a Service (IaaS) before providing you with an introduction to Windows Azure.

I then show you how to extend an existing WCF 4.0 application service for deployment to Windows Azure with Visual Studio by adding a Windows Azure Project and associating it with a web role. Then I demonstrate how simple Visual Studio 2010 makes testing a cloud application locally before packaging it for deployment to Windows Azure and walk you through the complete Windows Azure Management Portal experience.

If you are evaluating Windows Azure, and want to understand what the development, deployment and management lifecycle looks like with Visual Studio 2010, then this is the whitepaper for you!

Special thanks to my editor, Erik Ruthruff at A23 Consulting and the great folks at EPS for your team work and stellar collaboration.

Visual Studio 2010 Ultimate Event Content Download

Rick G. Garibay — Sun, 14 Mar 2010 01:45:01 GMT

Thanks to all who came out to the event in Phoenix, Salt Lake City & Las Vegas. We had a great turnout at all events with great questions and discussions.

Remember that the conversation continues on twitter.

If you attended the event and have a question or comment for any of the presenters, use the following hashtags:

Phoenix: #vs2010phx
Salt Lake City: #vs2010slc
Las Vegas: #vs2010vegas

Below are the presentations from all four sessions in each city:

Phoenix	A Lap Around Visual Studio 2010	Rick G. Garibay
Phoenix	Agile Management with TFS	Brendon Birdoes	*
Phoenix	No More "No Repro"	Brendon Birdoes	*
Phoenix	Architecture for Everyone	Rick G. Garibay
Salt Lake City	A Lap Around Visual Studio 2010	Rick G. Garibay
Salt Lake City	Agile Management with TFS	Jeff Leite	*
Salt Lake City	No More "No Repro"	Jeff Leite	*
Salt Lake City	Architecture for Everyone	Rick G. Garibay
Las Vegas	A Lap Around Visual Studio 2010	Rick G. Garibay
Las Vegas	Agile Management with TFS	Mickey Williams	*
Las Vegas	No More "No Repro"	Mickey Williams	*
Las Vegas	Architecture for Everyone	Rick G. Garibay

* Note that content for all venues is very similar but may vary from presenter to presenter. ~~All content for both venues will be available soon so please check back shortly.~~

Take Me with You! Ensuring Team Build Brings Dependencies Along for the Ride

Rick G. Garibay — Fri, 28 Aug 2009 03:05:14 GMT

As part of an automated build at a client, we currently have over 150 unit tests that run as part of each automated build. Some of the tests are also integration tests which serve to automatically smoke test the freshly compiled application code.

One of our apps makes use of an XML file that allows the ability to dynamically change behavior of a component without requiring an app domain recycle. A static method uses a FileWatcher to detect a change and applies the configuration changes at runtime accordingly. But I digress…

When Team Build executes your unit tests, it creates a special directory on the build agent called TestResults.The TestResults folder includes a .trx file that captures the build results in XML along with a folder for each build/run which isolates all required test assemblies and other dependant assemblies for execution. The App.config file will automatically be copied over and renamed to AssemblyName.dll.config. This is fine and dandy, but what about other dependencies like the XML file?

The answer is different depending on whether you are running your tests locally from Visual Studio or if Team Build is running your tests as part of an automated build, but you must be familiar with both techniques to accomplish a consistent and repeatable means for taking the XML file along for the ride under both scenarios which you will undoubtedly need to understand because chances are you are (or at least should be) running all unit tests locally before checking into source control, right? Right?

Local Dependencies

When running and debugging unit tests using Visual Studio and a just-in-time test runners like TestDriven.NET that have an external dependency such as an XML file, you must ensure the dependency is in the binary root relative to the executing assembly. This is also true when using other unit testing frameworks like NUnit, which I talk about here.

Right click the resource in the test project, click properties and set “Copy to Output Directory” to “Copy Always”:

This will ensure that the dependency is copied to the bin directory just as other dependencies like DLLs and App.Config/Web.Config are automatically.

At this point, the XML file can be referenced in the root of the bin which is relative to the executing assembly.

Team Build Dependencies

As I mentioned earlier, when Team Build executes unit tests, it moves all required assemblies and assembly dependencies to a TestResults folder. While this includes App.config and Web.config files, other dependencies are not copied regardless of whether you specify “Copy to Output Directory” to “Copy Always” as shown above. This makes sense, because when Team Build runs, the unit test project is no longer located with the rest of the source- instead it is copied to the TestResults folder and prepped for execution.

There are two ways to address this.

The first option is to mark each test method with a DeploymentItem attribute. This is documented here, so I won’t go into much into it. The basic usage is to mark you test method with the DeploymentItem attribute, providing a parameter with the path and filename of the dependency:

   1:  [TestMethod]

   2:          [DeploymentItem("../../MyExternalDependency.xml")]

   3:          public void FooShouldReturnBar()

   4:          {

5:

   6:             //...

7:

   8:          }

When the assembly that includes the test class loads, the attribute is reflected and the dependent file is copied to the TestResults folder. You can also add the attribute at the test class level and it will have the same effect.

The draw back of this approach is that it requires that you apply this attribute to the test class and it is really quite noisy because it is only used when running tests with Team Build or the Test List Editor.

To keep things cleaner, I prefer to make these dependencies configuration driven. So, similarly to setting the “Copy to Output Directory” to “Copy Always” for just-in-time testing, you can determine dependencies that should be copied to the TestResults folder using a global configuration setting that will apply to all tests: Test Run Configuration.

Go to Test, “Edit Test Run Configuration” and click on the configuration file as shown below:

Now, click on the Deployment option on the left, ensure “Enable Deployment” is checked, and either click “Add File” to add a specific file, or “Add Directory” to include the entire contents of a directory:

The localtestrun.testrunconfig file will be configured with the dependencies specified and this file will be consulted just prior to kicking off a test run to ensure that all dependencies are copied to the TestResults folder.

That’s really all there is to it. Thanks to Brendon Birdoes for turning me on to the DeploymentItem attribute which I was not familiar with.

Unit Testing Microsoft Sync Framework 2.0 & WCF

Rick G. Garibay — Tue, 18 Aug 2009 04:46:33 GMT

I just wrapped up some work for a client that entails exposing the Sync Framework 2.0 via WCF.

We are using Sync Framework 2.0 CTP 2 to support occasionally connected client scenarios between applications deployed out in the edge and core services hosted in the client’s cloud. I am using WCF to wrap the Sync Fx APIs to support interoperable synchronization support via SOAP 1.1. This way, any client can on-ramp with the core services and essentially become self-provisioned by initiating and initial synchronization to download required data necessary to come on line. In addition, when events happen out on the edge, the client can synchronize each event back to the cloud using an upload semantic.

There are many benefits to using the Sync Fx as opposed to rolling your own, and one benefit is the extremely simple provider model which makes basic synchronization scenarios a breeze, particularly between relational replicas such as SQL Server. Note however, that Sync Fx is fully extensible and capable of synchronizing any two memory streams.

So, the basic idea is that given a SyncProvider for the local and remote replica, any two data sources/applications can be synchronized:

In my scenario, the local client out in the edge utilizes the out of the box SqlSyncProvider. The goal was to expose the cloud over HTTP using SOAP, which required some understanding of the underlying APIs. From there, it was simply a matter of wrapping the Sync Fx APIs in a service layer, so that I would arrive at something like this:

By providing a proxy to the orchestrator, I was able to implement a proxy which is polymorphic with RelationalSyncProvider.

Immediately it should be obvious that this is not your typical integration scenario. Essentially, I am extending a framework by exposing it over WCF so that any orchestrator can leverage the WebSyncProvider.

I started the implementation by writing some tests. It was simple enough to extract an interface for the RelationalSyncProvider type because it is abstract. I used RhinoMocks to stub it, which worked great but where I ran into problems was in recording expectations on the return types because there are not a lot of test seams in the framework. With the absence of setters on main properties that I needed to assert, I needed a way to reach into the framework types and manipulate them so that I could develop the CUT (in this case the ServiceContract implementation) independent of the framework.

Publicize.exe works pretty nicely for what I was looking for.

For example, let’s say I want to stub a closed/framework type so that I can actually write my test without having to resort to integrating with the framework (which wouldn’t be a unit test at all), in this case, a couple of types in the Microsoft.Syncronization.dll assembly.

I run Publicize.exe Microsoft.Syncronization.dll and it generates a shadow assembly called Microsoft.Syncronization_Accessor.dll, which takes all types, adds _Accessor and exposes all non-public members as public as shown in Reflector on the right.

This pretty powerful.

I can now stub the return type of any closed/framework class and test as long as I am asserting *properties*, which is pretty common:

1:

   2:          [TestMethod]

   3:          public void GetChangesShouldReturnNumberOfChangesApplied()

   4:          {

   5:              MockRepository mockRepository = new MockRepository();

6:

   7:              RelationalSyncProvider provider = mockRepository.Stub<RelationalSyncProvider>();

8:

9:

  10:              using (mockRepository.Record())

  11:              {

12:

  13:                  // Set up the out parameter on RelationalSyncProvider Stub

  14:                  DbSyncContext changeDataRetriever = new DbSyncContext();

15:

  16:                  // Set up ScopeProgress property on DbySyncContext instance

  17:                  /*

  18:                   * Note that in order to test for number of changes applied, we need to reach into the

  19:                   * DbSyncScopeProgress and access the _totalChanges private member

  20:                   * so that public properties can be asserted. This is because the TotalChanges property only has a

  21:                   * getter, so the only way to influence the value is through it's backing field.

  22:                   */

23:

  24:                  DbSyncScopeProgress dbSyncScopeProgress = new DbSyncScopeProgress();

25:

  26:                  // Reference the actual object which will be accessed by the generated accessor

  27:                  PrivateObject obj = new PrivateObject(dbSyncScopeProgress);

28:

  29:                  // Generated accessor which wraps the type to be exposed using reflection.

  30:                  // Instead of writing the reflection code manually, Publicize.exe was run against the real assembly,

  31:                  // which in turn generated reflection wrappers for *all* types.

32:

  33:                  DbSyncScopeProgress_Accessor dbSyncScopeProgressAccessor = new DbSyncScopeProgress_Accessor(obj);

34:

  35:                  // Look ma, I am accessing a private field

  36:                  dbSyncScopeProgressAccessor._tablesProgress = new List<DbSyncTableProgress>();

37:

38:

  39:                  // Now we need to repeat the same process again for this type, which is at the heart of what we need to

  40:                  // gain access to.

  41:                  DbSyncTableProgress dbSyncTableProgress = new DbSyncTableProgress();

42:

  43:                  // Provides the accessor with a reference to the actual object

  44:                  obj = new PrivateObject(dbSyncTableProgress);

45:

  46:                  // Generated accessor which wraps the type to be exposed using reflection.

  47:                  // Instead of writing the reflection code manually, Publicize.exe was run against the real assembly,

  48:                  // which in turn generated reflection wrappers for *all* types.

  49:                  DbSyncTableProgress_Accessor dbSyncTableProgressAccessor = new DbSyncTableProgress_Accessor(obj);

50:

  51:                  // Set the _rowsApplied field so that the stubbed return instance of DbSyncScopeProgress can be asserted.

  52:                  dbSyncTableProgressAccessor._rowsApplied = 42;

53:

  54:                  // Add the dbSyncTableProgress to the private collection

  55:                  dbSyncScopeProgressAccessor._tablesProgress.Add(dbSyncTableProgress);

56:

57:

  58:                  // Now, set the property to our used and abused instance of DbSyncScopeProgress

  59:                  changeDataRetriever.ScopeProgress = dbSyncScopeProgress;

60:

  61:                  // Provider is implemented in COM so out params are prevelant (yuk)

  62:                  object changeDataRetrieverObj = changeDataRetriever;

63:

  64:                  // Set the expectation

  65:                  provider.GetChangeBatch(0, null, out changeDataRetrieverObj);

66:

  67:                  // Initialize params

  68:                  SyncIdFormatGroup idFormats = new SyncIdFormatGroup();

  69:                  SyncKnowledge destinationKnowledge = new SyncKnowledge();

  70:                  ForgottenKnowledge sourceForgottenKnowledge = new ForgottenKnowledge();

71:

  72:                  // Stub the return, including the object reference to DbSyncContext

  73:                  LastCall.Return(new ChangeBatch(idFormats, destinationKnowledge, sourceForgottenKnowledge))

  74:                      .OutRef(changeDataRetrieverObj).IgnoreArguments();

  75:              }

76:

  77:              IRelationalSyncManager manager = new RelationalSyncManager();

78:

  79:              // Inject the stub

  80:              manager.Provider = provider;

81:

  82:              SyncKnowledge localKnowledge = new SyncKnowledge();

  83:              DbSyncContext returnedContext = new DbSyncContext();

  84:              returnedContext.ScopeProgress = new DbSyncScopeProgress();

85:

86:

  87:              var changeBatch = manager.GetChanges(0, localKnowledge, out returnedContext);

88:

  89:              DbSyncContext context = returnedContext;

90:

  91:              Assert.IsTrue(context.ScopeProgress.TotalChangesApplied ==42);

92:

  93:          }

There is a bit of work here, but with a bit of elbow grease thanks to Visual Studio Test Tools, RhinoMocks, reflection and a little code generation the framework is testable.

Free Public Class: A Day in the Life of Scrum with VSTS 2008 and TFS- 6/2 in Phoenix

Rick G. Garibay — Sun, 31 May 2009 20:49:56 GMT

I will be delivering my last free public class, "A Day in the Life of Scrum with Visual Studio Team System 2008 and Team Foundation Server" to Microsoft Phoenix next Tuesday, June 2nd.

There are still a few seats available, so feel free to register (please see invitation below with Invitation Key 4DEAA2). If you would be interested in a private class for your team or organization, please feel free to contact me for scheduling.

Please join Microsoft and Neudesic for a day in the life of Scrum with Visual Studio Team System 2008 and Team Foundation Server! Agile methods are a set of development processes intended to create software in a lighter, faster, more people-centric way. Many development teams have adopted "agile" methodologies to manage change and to improve software quality. These methodologies promote continuous integration as a practice to build and test software products incrementally as new features are included, bugs are fixed, and code is refactored.

If you missed the first series of Agile & Scrum Essentials last fall; here’s your chance to attend the follow-on event where we’ll briefly revisit the basics of Agile and Scrum and provide a walkthrough of how to configure Visual Studio Team System 2008 and Team Foundation Server for Scrum. Participants will be familiarized with how key artifacts are managed within this popular process template for enacting Scrum in organizations.

Join us for this interactive event as we explore a “day in the life of a Sprint,” that will give you a practical perspective of how Scrum teams leverage Visual Studio Team System for end to end management of the planning, execution and control of Scrum projects. The day will end with an overview of what’s coming in Visual Studio Team System 2010!

Register

Welcome: 8:30 PM

Seminar: 9:00 AM-4:30 PM

Phoenix, AZ

June 2, 2009

Click here to register or call 1.877.MSEVENT (1.877.673.8368) with invitation code: 4DEAA2.

.NET Framework 4.0 Beta 1

Rick G. Garibay — Mon, 18 May 2009 21:00:00 GMT

I am thrilled to share that today, Monday, May 18th, the .NET Framework 4 Beta 1 will be available to MSDN Subscribers through MSDN Subscriber Downloads and to the general public on Wednesday, May 20th through Microsoft Downloads.

I have been fortunate to have my hands on a limited April CTP for some time now which is very close to what is included in Beta 1, so stay tuned for more information about VS 2010 and the WCF and WF enhancements in .NET 4.0 which are key areas that I will continue to focus on and share with you here.

Until then, here are some helpful links to get you started with NET FX 4.0:

Get the Bits

Download the .NET Framework 4 beta here from MSDN Downloads:http://msdn.microsoft.com/en-us/subsc ions/downloads/default.aspx?pv=18:370
On Wed, May 20th, you can obtain the Beta 1 bits here: http://go.microsoft.com/fwlink/?LinkId=151799

Learn What’s New

A First Look at VS 2010: http://www.microsoft.com/visualstudio/en-us/products/2010/default.mspx
New .NET Framework 4 features: http://go.microsoft.com/?linkid=9666478
Scott Hanselman's .NET 4 overview (PDC 2008) : http://channel9.msdn.com/pdc2008/TL49

Get Support from the Community

Beta 1 Forum is available here: http://social.msdn.microsoft.com/Forums/en-US/category/VSPreRelease,netdevelopmentprerelease,visualstudioprerelease,vstsprerelease

Stay tuned for posts in the next couple of weeks that will address the significance of this major release, particularly around VS 2010 enhancements and Connected Systems framework technologies. Until then, if you haven’t already, please take the time to upgrade to .NET Framework 3.5 which will make sure your upgrade path to .NET 4.0 is as seamless as possible.

Phoenix Visual Studio Team System Big Event was BIG!

Rick G. Garibay — Tue, 12 May 2009 00:29:16 GMT

Thanks to all who came out for the Visual Studio Team System Big Event on Thursday, May 7th! We had a great time with the Microsoft Developer Evangelist team, Microsoft Technical Specialists, MVPs and influencers who at the end of the full day of action packed training left no doubt that Visual Studio Team System is BIG!

Dan Weinman, Senior Consultant at Neudesic kicked off with the keynote on "Development Best Practices & How Microsoft Helps" and set the stage for what the day full of training had in store. Dan talked about the various roles that VSTS supports and how each role comes together to enact process under a single tool that maximizes transparency and communication on Agile teams.

Next, Brendon Birdoes, Principal Consultant at Neudesic delivered a great talk on Test-Driven-Development with Visual Studio. Brendon covered unit testing, including test first development and showed off the refactoring capabilities right within the IDE along with code coverage. Brendon talked about how important code coverage and quality assertions are to ensuring that your unit tests are as useful as possible in maintaining high degrees of quality within your software projects.

Following the excellent session on TDD, Visual Studio Team System MVP Dave McKinstry delivered a session entitled ""It Works on My Machine!" Closing the Loop Between Development & Testing" which discussed the close integration between testing tools in Visual Studio Team System and the code itself which minimizes the cost and complexity in task switching.

We were then treated by another excellent talk by Rob Bagby, Developer Evangelist on "Treating Databases as First-Class Citizens in Development". In this session, Rob made clear that database work can no longer hide from unit testing and how the Database Project in Visual Studio Team System makes synchronizing DDL and DML objects seamless and eminently testable.

I was lucky enough to show off the new Visual Studio Team System 2010 Team Architect bits which include fully compliant UML 2.1 diagram support as well as assembly, namespace, class and method visualization using the VSTS 2010 Architecture Explorer. I talked about VSTS 2010 Team Architect being yet another clear signal of Microsoft's commitment to modeling which is, and will continue to manifest itself in technologies like Windows Workflow, BizTalk Server, Entity Framework, and Quadrant to name just a few. As a Connected Systems guy, VS2010 Team Architect is really going to go a long way in helping me and my teams visualize the problem domain and partition our big balls of mud into the right architecture.

Speaking of which, I think my favorite new modeling feature in Team Architect is the Layer Diagram which lets you define your layers and then validate them at build time! What this means is that I can use a layer diagram to define separation of concerns and single responsibility principle and then make sure that team members are honoring the layer rules. It is just awesome to be able to map namespaces to a layer diagram, wire it up to the automated build and keep violations from every being delivered.

The day winded up with a great talk by Steve Lange, Technical Specialist on how to get the most out of TFS. The session was aptly called "Bang for Your Buck" Getting the Most out of Team Foundation Server, and Steve gave away some great tips on things you can do with your investment in TFS that you may not have even known about.

I want to thank Steve and Rob for inviting us to speak at this event. The room was full of great folks with lots of passion and great questions which is exactly what we like to see at these events. If you have any follow up questions that I wasn't able to get answered at the event, please don't hesitate to contact me.

Fix: Can't Set Breakpoints in Visual Studio 2008

Rick G. Garibay — Tue, 28 Apr 2009 20:03:29 GMT

I recently uninstalled a certain productivity enhancement tool for VS 2008 which shall remain nameless because they are a good group of guys and have been very nice to me.

I uninstalled the tool, namely because I felt I was becoming a bit too dependant on it. Certainly, VS features like intellisense and basic refactoring support are not things I would willingly live without, but I feel that the features in VS are probably adequate for my needs and my IDE was starting to feel a bit clunky.

So, I uninstalled this tool, and immediately intellisense was missing. Anoying. I went into Tools->Options and re-enabled Intellisense. Life was good, or so it seemed.

For the last 5 weeks, the bane of my existence has been the fact that I couldn't set breakpoints in my code. I could debug just fine if I right clicked + Breakpoints + Insert Breakpoint, or use F9, but when I tried to set the breakpoint on the left pane, as shown here, it just wouldn't work at all:

I was giving a class on TDD to one of my biggest customers today and in desperation, having right clicked + Breakpoints + Insert Breakpoint one too many times, I offered to buy lunch to the developer who could help me fix this. Now one developer offered the F9 option as workaround, which is better than a 3 step process, and this would have helped me out. Then, about 15 minutes later, another developer said they had the fix, and sure enough, he did!

The problem was that the "Indicator Margin" had been disabled. How did this happen? Why would this happen and what the hell is an Indicator Margin? Well, I don't have proof, but I am guessing that it is that "productivity" tool that did it when I uninstalled it.

The solution was simply to go into Tools->Options->Text Editor and enable Indicator margin as shown below:

I am forever indebted to this customer and am sharing this tip here in case this is driving you as nuts as it has me over the last month!