What do you do when you have a market-dominating product built from more than 50 million lines of code with a loyal customer base of subscribers who use it all day, every day, and you want to keep them happy? You upgrade it for free at incremental releases to address the pain points, and at a nominal charge at a full release to address new technologies and to make major enhancements. That's exactly what Microsoft has done with service packs to Visual Studio 2012 and now with the release of Visual Studio 2013.
Visual Studio users can fall into a range of categories (developers, testers, architects, and so on) and use a range of technologies (desktop, Web, cloud, Windows store, services, databases, and more). While there are competitors for almost every area where Visual Studio provides a solution, no single product competes with Visual Studio in all fields. The closest I can think of would be Embarcadero All-Access XE, which is more of a suite than a unified product.
In short, Visual Studio 2013 brings not only a number of big improvements tailored to development teams, but also many smaller ones that will actually matter to working developers.
Team Foundation Service
One thing I don't like about Team Foundation Server is setting it up for a geographically distributed group. Performance can be a big issue, especially when the group spans the globe, as outsourced projects often do. There's an all-Microsoft solution for that: Team Foundation Service. As you might expect, it runs in the Azure cloud. As you might not expect, it's free for teams of five or fewer, and larger installations are included in the higher-end Visual Studio with MSDN subscriptions at no additional charge.
By the way, Microsoft maintains a release archive for Team Foundation Service that shows when certain updates appeared in the Service and the Server. From here on, when I refer to TFS, I mean both Team Foundation Server and Team Foundation Service. The capabilities are available in both the product and the service.
Build and test in the cloud
You can set up TFS to automatically build and test periodically or after every check-in. This is a big convenience and productivity enhancement, even compared to other commercial code-quality services, which usually make you check in separately after the acceptance criteria have been met and all tests are green. In addition, you can deploy successful builds to Windows Azure automatically using the InRelease component discussed below.
Speaking of Windows Azure, you can now create Azure sites and databases directly from Visual Studio once you've installed the current Azure SDK. It couldn't be much easier. When you create an Azure site from Visual Studio 2013, you get a placeholder site even before you deploy what you're building. Visual Studio remembers the Azure connection you create to make later deployment simple.
One hugely useful integration between the Visual Studio editor and TFS (including Git) is Codelens, which shows you version history comments in your code. Codelens also lets you know if you're working with code for which there has been a check-in since you last pulled from the repository. That eliminates a whole class of problems and duplications of effort that commonly crop up in areas of active development. I can't tell you how many times I've gone to check in a bug fix only to find that someone else has taken care of it.
Team Explorer, the client interface to TFS, is much more useful than it was before. Admittedly, that wasn't a high mark to beat, but Team Explorer now shows you what you need to know fairly quickly.
Using Team Room, an integrated chat capability in Team Explorer, can help keep your desktop clutter down, although many development teams will undoubtedly continue to use Skype, Google Hangouts, or their favorite chat program, despite any advantages of Team Room. Never underestimate the power of habits.
Microsoft acquired InRelease, a release management product built specifically for Team Foundation Server by InCycle Software, last July. InRelease, now integrated with Visual Studio 2013, Team Foundation Service, Microsoft Test Manager, and Team Build, enables a number of common release scenarios, including releasing on demand to a local or hosted VM, daily release for smoke testing, and continuous deployment. If you don't already have this kind of capability set up for your products with other tools, you might want to consider using the new release management features in Visual Studio 2013.
Next page: Smarter code editing
Smarter code editing
Codelens shows you version history comments in your code. It will also tell you if there's been a check-in for the code since you last pulled it from the repository.
The ability to add Python support to Visual Studio 2013 with a simple install from within the IDE is also nice. While the Python support doesn't seem to be as good as, say, the C# support, it works -- both for IronPython and CPython, although not JPython. Django is supported as well, and a Django project is one of the New Project options for Python.
My real Visual Studio workspaces (unlike the toy projects I used for screenshots in this article) tend to be enormous, multipronged extravaganzas set up so that I can build and edit everything I care about from one solution. With Visual Studio 2010, my morning routine was to log in, start Visual Studio, boil a quart of water, brew tea, let the tea steep, pour the tea, add honey, and return to my machine around the time all the projects became usable -- a multiminute delay despite the fact I had an automatic task set to update from source control and rebuild all my projects very early every morning. I would typically try to keep Visual Studio 2010 open all day rather than incur the startup overhead again, but sometimes my application bug would hose the IDE.
In Visual Studio 2012, asynchronous startup of the IDE improved the situation noticeably. In Visual Studio 2013 it's not going to be a problem if I forget to start the IDE before preparing the tea. As long as the tabs I opened the night before are the ones I now want, I should be up and running in less than a minute.
One ASP.Net project
Web development tooling has taken a giant leap forward in Visual Studio 2013. Visual Studio 2012 had seven different ASP.Net project types, and if you started with what turned out to be the wrong one you were in for painful editing chores. Visual Studio 2013 has one ASP.Net project to rule them all, and it's a huge improvement over its predecessors, letting you mix and match Web technologies using a wizard.
If you forget to add everything you need to an ASP.Net project when you create it, you can now easily add it later via scaffolding. Scaffolds include generators of controllers with all combinations of available Web technologies, generators of views, and generators of areas. Areas are a way of partitioning MVC applications, added in MVC 2, that solves the problem of having an unwieldy number of models, views, and controllers in a large website.
MVC Web projects strongly remind me of Ruby on Rails, with the same strengths, weaknesses, and pitfalls. If you put the model-related code in the model, the view-related code in the view, and the controller-related code in the controller, then avoid crossing the lines, you can build a robust website that automatically implements RESTful actions and cleanly separates and decouples the database, UI, and event-handling functionality. If you forget the divisions and, for example, interrogate the database directly from the view, you'll wind up with a buggy application that needs to be refactored to become maintainable, just as you would in Rails.
Browser Link fixes that by creating a real-time, two-way connection using SignalR between Visual Studio 2013 and all the browsers you connect to your locally hosted debug-mode site. Again, this isn't your father's Microsoft: It works with any browser you wish to use, not just the latest version of IE, and it works with browsers running in device emulators/simulators. (You can download emulators from Microsoft's ASP.net site.)
Visual Studio 2013 makes it easy to add a new controller, view, or model to an MVC Web project.
With Browser Link set up, you can see all the browser windows reflect every edit or style update. You control the refresh from Visual Studio 2013 and it pushes the refresh to the browsers, so you don't have to touch all the browser windows manually. This can be a real timesaver. It's also a good case for having at least two monitors on your development computer.
Another new way to view Web pages from within Visual Studio 2013 is to use the Page Inspector, an internal browser that integrates with IntelliTrace, the debugger, and the code editor to help you understand the connection between your code and what is displayed.
Next page: True Web app monitoring
True Web app monitoring
Unfortunately, no matter how well you set up your tests and your debugging environment, some bugs will only show up on a production system. That's true of desktop programs in the field to some extent, but it's even more common to have this problem on multi-user Web applications that use many services.
We've had IntelliTrace logs for desktop applications for years. When an error occurs, the application generates the log and typically asks the user to send it to the developers. The developers then match up the log with the symbols from the correct build and open the IntelliTrace log in Visual Studio to identify the problem.
In the past, production ASP.Net applications didn't do this, for scalability and performance reasons. Finding a bug that only occurred in production meant taking a performance hit for as long as it took to reproduce the problem, then reverting to release code once the bug was thought to be fixed.
Microsoft Monitoring Agents (MMA) changed that. Now you can run MMA on production websites full time, at least according to Microsoft. (If your site runs above 80 percent of memory or CPU utilization, I'd say all bets are off.) When an error event happens, the application will generate an IntelliTrace log file. These let you go to the code that caused the problem when you open them in Visual Studio 2013, just like they would for desktop applications.
Performance and diagnostics
Visual Studio 2013 simplifies the creation of ASP.Net projects with a single wizard that lets you mix and match Web technologies.
Energy consumption is a new consideration for desktop and server application developers, although it has been a driving concern for mobile application developers for years. If just one desktop developer learns to replace his busy-wait loops with async code while profiling Windows Store apps, the world will be a better place.
Next page: Test-driven development
The improvements I discuss in this section were actually introduced in Visual Studio 2012 Ultimate, but I think they are important enough to include here.
Test-driven development (TDD) is near and dear to my heart, but I didn't used to be able to practice it on Microsoft code the way I could on Ruby code, though I was an early adopter of NUnit. What made TDD untenable for me was that IntelliSense would blindly autocomplete the names of stubs I hadn't yet written to some random but similar label.
Improvements to IntelliSense over the years alleviated this problem somewhat, and Visual Studio 2010 brought unit testing into the tent in a way that was only moderately incompatible with NUnit. The Test Explorer in Visual Studio 2012 unified NUnit and MSTest, as well as unified .Net and unmanaged C++ unit testing. Another set of essential features for TDD was introduced at that time: Microsoft Fakes.
The Fakes framework generates mocks for classes and APIs that you want to exclude from a unit test. For example, you don't want to unit test from live data; it changes from run to run, and the test will fail even though it's working correctly. Instead, you want to unit test from fixed data and with APIs that always return the same results. Indeed, for a unit test, you want to use a stopped clock, not DateTime.Now.
There are two categories of Fakes: stubs and shims. Stubs are mocked classes generated by the Fakes framework. You use them to isolate the classes under test from other classes in your application that return variable results. Shims are runtime modifications of your calls to external applications, services, and system APIs. Ideally, you would always use stubs when they were applicable, and you would only use shims when forced. On the other hand, if you're lazy, shims will always work, albeit slowly.
If you've installed the current Windows Azure SDK, you can create Azure sites and databases directly from Visual Studio 2013.
Sign in to Visual Studio 2013
In previous versions of Visual Studio, you either installed a pre-registered version of the product from MSDN or you activated a demo version of the product with a code. Visual Studio 2013 gives you another option: Sign in with your Microsoft ID.
This is good for Microsoft -- it can phone home and make sure you have a current MSDN subscription for the product you're using. On the other hand, if you want to avoid that, you can enter an activation code.
Nevertheless, I sign in because it lets me synchronize multiple installations of Visual Studio 2013 on different computers using a roaming profile. What does it synchronize? Most important, it synchronizes your Team Foundation Services account credentials. But it also synchronizes your color scheme and font choices, your language preference, and your keyboard settings. If you move among many shared development computers and have a highly customized keyboard map, synchronization is a huge convenience.
As you've probably gathered by now, Visual Studio 2013 presents a huge learning curve to new users. Visual Studio 2012 is composed of about 50 million lines of code, and Visual Studio 2013 is bigger. There are so many actions in Visual Studio and TFS, so many documents in MSDN, so many samples to go through, and so many videos to view, that the learning curve for a new developer can appear overwhelming. While you can learn Visual Studio and TFS from the product and MSDN, it might not be the best way to use your time unless you actually enjoy solving giant puzzles.
In the past, I advised new Visual Studio developers to buy a book or take a course to get themselves up to speed. Now, unless you have a mentor or your company has budget for live teaching, I suggest you sign up for Wintellect Now and take those courses online. In particular, if you want to learn about developing Windows Store apps, go through Jeff Prosise's course, starting with the introduction to Windows RT. Similarly, if you want to learn about Windows Azure, go through Jeffrey Richter's course.
Let me point out that the Visual Studio Ultimate product I've reviewed is not appropriate for everyone. If you're new to Visual Studio, start with the free and stripped-down Visual Studio Express product that best suits your needs, be it for Web, Windows (that is, Windows Store), Windows Desktop (C#, Visual Basic, and C++), or Windows Phone. Unless you need more than one of these, stripped-down is good. Frankly, even the Express products have learning curves.
If you're a student, you can start (and perhaps end) with a free copy of Visual Studio Professional 2013, which will get you all the basic single-user development tools, at the possible cost of being a little overwhelmed.
Once you're sure you can use Visual Studio, then you can download the document that describes all the Visual Studio purchase options. It's 33 pages long -- I kid you not. Did the young Bill Gates who slept in the computer lab at his high school ever imagine his company would emulate the most obnoxious features of IBM? Somehow I doubt it. What's worse is that the 33-page document doesn't contain any prices.
I'll give you the short pricing summary. If you buy from the Microsoft Store you'll see prices ranging from £303 for an upgrade to Visual Studio 2013 Professional to £13,482 for a new full copy of Visual Studio Ultimate 2013 with MSDN, the product I reviewed here.
Professional is for independent developers. Premium is for developers and architects in teams. Test Professional is for testers in teams. Ultimate is the kitchen sink. If you want one of the high-end SKUs with MSDN, see the comparison on the MSDN site. Visual Studio Professional is the only Visual Studio product available without an MSDN subscription.
In summary, Visual Studio 2013 improves a developer's productivity in many ways, as compared to its predecessor: in the editors, in the debuggers, in the frameworks, in the wizards, and in the performance and diagnostics tools. Visual Studio 2013 Ultimate goes beyond development to unit testing, smoke testing, load testing, and all the way to continuous builds and release management.
Visual Studio 2013 installs side by side with Visual Studio 2012, and the projects and solutions are largely interchangeable. Upgrading from Visual Studio 2012 Professional to Visual Studio 2013 Professional costs a mere $99 until the end of January, and upgrading any other edition is just a matter of renewing your MSDN subscription. I'd suggest that, unless you discover incompatibilities between compiler versions that affect your code, upgrading is a no-brainer.
- Big improvements to the application lifecycle management portion of the product, including the introduction of a hosted Team Foundation Service that allows you to build, test, and even deploy in the cloud
- Incorporation of InRelease, a release management product, into TFS
- Vastly improved tooling for Web development, including a single ASP.Net project wizard that allows you to combine the different Microsoft Web technologies easily
- Improved code editing and browsing, including a Peek Definition action that allows you to look up code definitions without disturbing your underlying edit window
- Monitoring agents have become lightweight enough for continuous monitoring of production ASP.Net sites, and IntelliTrace lets you go to the code that caused a fault in production using the dump file
- With so many actions in Visual Studio and TFS, so many documents in MSDN, so many samples, and so many videos to view, the learning curve for a new developer can appear to be overwhelming
- Visual Studio 2013 has three color schemes, all of which are ugly and have top-level menu items ALL IN CAPS