Visual Studio 2012 Logo
I had the opportunity to participate in a demo as well as start using Visual Studio 2012, and here is what I came away with.

I liked:

  • TFS Web access looks kind of usable, which is in stark contrast to 2010.
  • Product Backlog Items’ or PBI’s can be hierarchical.
  • Allows for the manual exlusion of files from pending changes
  • Allows the user to define exclusion rules as well. This sounds vaguely like something else that I’ve heard of.
  • Typescript provides strongly typed javascript that gets compiled down into standard javascript.
  • Code clone analysis is done with the IL which is nice.
  • Unit tests can be created from an action recording.
  • Built in Nuget integration

I didn’t like:

  • They moved Undo... under source control, rather than directly in the right click menu. This is something I use everyday. Why did they do this?
  • The monochromatic toolbars, but this can be fixed. Even so, they could have done a better job with the defaults.
  • Removed the Create Unit Tests option that set up a skeleton(test assembly, class, and method). This is reportedly due to the fact that they got rid of private accessors, but I think they still could have saved me some typing.
  • Microsoft Fakes is only available for VS 2012 Ultimate! I have no idea why they are trying to incentivize creating .NET code without unit tests.
  • DataDrivenUnit Tests make it easy to tie unit tests to the database. I don’t like this, because it allows your tests to fail without any bugs in the code.

These set the wrong precedent:

  • Shelve changeset/suspend work looks great at first glance, but really encourages context switching. The cost of context switching has absolutely nothing to do with the ide.
  • Request a code review. This feature shouldn’t be necessary. A developer should turn to their colleague and ask them to review their code. This seems to facilitate (read encourage) working in silos.
  • TFS and VS 2012 seem bent on facilitating remote development, communication, and work.
  • I like that you can associate a code review with a changeset, but it seems like this may contribute to finger pointing. X reviewed Y’s code and neither of them caught the error, so they are at fault.
  • Code metrics seemed like a very useful thing, but they have a very high tolerance for what I would consider bad code.
  • Layer diagrams enforce architecture. Seems like they are trying to achieve productivity through massive parallelism like an ant hill does.

They heard and didn’t hear their user base but sided with the check writers(non-developers/users in most cases). The look and feel appears to be the side effect of mobile fervor without anyone else being quite as excited. All of the features to encourage cheaper developers and a heavy organizational structure certainly cater to thosee assigned with cutting development costs. In the end, it is a continuance of what the ide has always been.


Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )


Connecting to %s