Introduction to Visual Studio 2015

Abstract

Visual Studio 2015 is a major release of Visual Studio. It incorporated some major advancements that Microsoft has been working on, from Project Rosyln to .NET Core. It not only is the latest version of Visual Studio, but it also introduces some major new features, technologies, and abilities. Let’s take a brief look at what’s new in Visual Studio 2015.

Visual Studio 2015 is a major release of Visual Studio. It incorporated some major advancements that Microsoft has been working on, from Project Rosyln to .NET Core. It not only is the latest version of Visual Studio, but it also introduces some major new features, technologies, and abilities. Let’s take a brief look at what’s new in Visual Studio 2015.

Intro to IDEs

First, let’s briefly go over what an Integrated Development Environment (IDE) means. IDEs provide a one-stop environment to do most of your development/testing tasks within one user experience. IDEs typically provide an environment to edit, refactor, and compile code; edit user interfaces; diagram logic; build applications; and perform some level of code analysis, testing, and source code control integration.

IDEs started when there were only console terminals, so they originally started as console-based applications. Early IDEs only performed editing, file management, compilation, and debugging/execution. These environments worked with console-based applications only and did not need to visually edit the user interface. Later, as graphical user interfaces became available, IDEs started to support editing user interfaces. Although every user interface is based on a specification that is textual in nature, it’s rare that user interfaces are edited textually.

It wasn’t until much later that features like code analysis, refactoring, testing, and diagramming were added to IDEs. Obviously refactoring wouldn’t be added until after Martin Fowler’s book, Refactoring: Improving the Design of Existing Code in 1999, and even then IDEs like Eclipse didn’t get inherent refactoring until 2002 or 2003. (Visual Studio got it in Visual Studio 2005.)

Now we can’t imagine an environment without refactoring, code analysis, UI editing, and debugging. Despite all these features inherent in Visual Studio, many prefer to use add-ons like ReSharper or CodeRush. With Visual Studio’s rich plugin ecosystem, there’s almost always some third-party extension to do what you need.

Visual Studio 2015 has several technologies related specifically to integrated development environments. For example, IntelliSense is the Visual Studio 2015 “autocomplete” component. It has several features such as Complete Word, Parameter Info, Quick Info, and List Members, that intelligently allow developers to complete what they are typing based on context. Complete Word provides options to complete the word you are typing, which could be the name of variable or command. Parameter Info provides information about the parameters you are typing, such as the parameters of a method call. It shows the documentation and name of each parameter. Quick Info is similar to Parameter Info, but provides the documentation information for any identifier in your code. List Members is autocomplete for member invocation while typing (after entering the .); it allows you to see the members that can be invoked for the given identifier and some quick documentation about each one.

Visual Studio 2015 has substantial debugging capabilities with features like IntelliTrace . IntelliTrace is a historical debugger for managed code that records events during execution within the debugger such as method calls, method parameters, exceptions, timings, memory usage, etc. This allows you to rewind code in the debugger should more information need be analyzed when a particular breakpoint is hit.

This book isn’t specifically about working with an IDE. This information is provided to inform readers about the features of an IDE so that we can compare Visual Studio 2015 features.

Visual Studio 2015 Editions

Visual Studio 2015 continues the Editions idea of Visual Studio, providing multiple editions geared toward different segments of the market or toward different roles within organizations.

Difference from Version 2013

If you’re familiar with Visual Studio 2013 , it will be useful to look at what has changed in the Editions landscape. One of the biggest differences in 2015 from 2013 is the new Community Edition and the sunsetting of the Express Editions.

Prior to Visual Studio 2015 (Visual Studio 2013 ), Visual Studio had Express Editions. This wasn’t merely one edition, it was really four—Visual Studio Express for Desktop, Visual Studio Express for Web, and Visual Studio Express for Windows. There was also a Team Foundation Server 2015 Express Edition.

Visual Studio Express for Desktop is an edition of Visual Studio 2013 that uses the familiar Visual Studio 2013 IDE that focuses on and facilitates development of desktop applications for Windows. This edition supports all the typical “native” platforms for windows: Windows Presentation Framework (WPF), Windows Forms, and Win32. Each platform generally has its own supported programming languages, but the Visual Studio Express for Desktop Edition supports C#, Visual Basic, and C++. While this edition allows you to create applications for Windows 7 and beyond, it isn’t supported under Windows 10.

Visual Studio Express for Web is an edition of Visual Studio 2013 that uses the familiar Visual Studio 2013 IDE that facilitates development of web sites, web APIs, or ASP.NET. Visual Studio Express for Desktop edition supports C# and Visual Basic for ASP.NET and web APIs, and the typical web stack for web sites: JavaScript, HTML, CSS, etc. This edition also isn’t supported under Windows 10.

Visual Studio Express for Windows is an edition of Visual Studio 2013 that uses the familiar Visual Studio 2013 IDE that facilitates development of Windows Store applications for Windows Phone and Windows 8.1+. Windows Store applications can be written in C#, Visual Basic, HTML5/JavaScript, and C++. While this edition allows you to create applications for Windows 8.1 and beyond, it isn’t supported under Windows 10.

Express editions typically didn’t support extensions (some versions supported Microsoft-only extensions). This changed with the 2013 Community Edition that allowed extensions. Using the Community Edition meant the ability to create application/web sites/etc. with Visual Studio for free but still use extensions (like TestDriven.NET, NUnit, etc.)

Visual Studio Team Foundation Server 2015 Express is an edition of Visual Studio for non-programmers and non-testers. These are team members who need to work with work items, bugs, tasks, etc. (Otherwise, for team members who need to work with developers and testers but didn’t need to use any of the IDE features of Visual Studio, but just access TFS.) This edition became less and less important, as a web-based UI to TFS was created and has feature parity with Visual Studio Team Foundation Server 2015 Express (and in some cases, it’s much more feature-rich).

In Visual Studio 2013 all the Express Editions and the Community Edition are replaced by the one Community Edition. Users download the plugins, extensions, packs, packages, etc. and then can develop for the platform or platforms of their choice.

The Visual Studio 2013 Ultimate and Premium Editions have not been carried forward to Visual Studio 2015. Instead there is an Enterprise Edition, which effectively has the features of the Visual Studio 2013 Premium and Visual Studio 2013 Ultimate Editions.

Community

As detailed, Microsoft has historically had Express Editions of Visual Studio that allow developers to create applications/web sites with Microsoft technologies at no cost. The Express Editions were criticized for not including all the basic tools that good software deployment needs. Things like unit testing and code analysis were lacking in some Express Editions, leaving the moniker “integrated” somewhat of a misnomer. There are literally thousands of extensions for Visual Studio and, while Express Editions might not have included all the tools for good software development, an extension could have been found to compensate. Alas, Express Editions did not support extensions .

After the Visual Studio 2013 Editions were released, Microsoft (or Microsoft Developer Division, DevDiv) started to move to a more componentized model with Visual Studio. Quickly Visual Studio proper was just a shell and the various things that made it an IDE were extensions, packs, add-ons, plugins, etc. The features could then be updated out-of-band (e.g., once a quarter as Microsoft also moved to a more iterative development cycle). It was clear with this extensible model that the lack of extensions would hurt more than it benefited. The Community Edition was introduced and it allowed developers to use Visual Studio for various platforms at no cost but still use extensions. This allowed the four Express Editions (and the costly management of different SKUs that went along with it) to be sunsetted while making the community as a whole happier.

For the most part, the Community Edition of Visual Studio 2015 is a slightly scaled back version of the Professional Edition. The Community Edition, like the Express Editions, does not support “enterprise” development (which means an organization with >250 PCs or >US$1 million annual revenue or more than five Visual Studio users writing software). The Community Edition provides no support over and above the support someone could get in the community: StackOverflow, MSDN Forums, etc.

The Community Edition provides features for debugging, unit testing, code editing and refactoring, UI design, viewing dependency graphs and code maps, code analysis, and team collaboration.

Professional

The Visual Studio 2015 Professional Edition is very similar to the Visual Studio 2015 Community Edition. Probably the most obvious difference is cost. The cost varies depending on the licensing/subscription model, quantity, and whether it includes MSDN. There are courses and much material on licensing with Microsoft, so we won’t attempt to get into pricing here.

The important part of Visual Studio 2015 Professional is that the minimum requirement for use is “Enterprise Development” (five or more developers or an organization with >250 PCs, or an organization with >US$ 1 million in annual revenue).

Professional also includes CodeLens. CodeLens was introduced in Visual Studio 2013 (although only available in Ultimate) and allows developers to see what code references methods, how many unit tests there are, and how many are passing for a method, who was the last to edit the method, past and future edits to a method, and any work items associated with the method. Developers can see all this information without having to go out to the respective tools (TFS or GIT), therefore improving productivity.

In addition, Visual Studio 2015 Professional includes Team Foundation Server (TFS) features. It might seem a little strange that Visual Studio 2015 Professional is the lowest edition to support TFS since there is an Express (no-cost) edition of TFS, but this is mostly due to the fact that Visual Studio 2015 Professional includes a license for TFS, whereas Community does not. The Team Foundation Server “features” with Visual Studio 2015 Professional simply seem to be the Team Foundation Server features .

Enterprise

Visual Studio 2015 Enterprise Edition is the next level up from Visual Studio 2015 Professional. It’s the first edition to include creation and editing of architectural and design diagrams (although lower editions can view them). Unfortunately it’s also the lowest edition that supports architectural validation. Architectural validations perform validations based on design in diagrams. Diagrams like UML, Layer, etc. can be used to validate that the solution is abiding by the constraints of the diagrams. For the most part, this requires a lot of up-front design and isn’t part of non-Enterprise users running of unit tests. In fact, it has to be run manually and separately from unit tests. Presumably someone would occasionally validate the architecture in this way, but this doesn’t keep feedback close to when it was worked on, so this is problematic. It can, however, be set up on build in Team Foundation Server and be validated reasonably close to the work if gated check-ins are used. If you’re using Git, however, this is a completely manual process.

Testing is greatly expanded in the Enterprise Edition. The Visual Studio 2015 Enterprise Edition includes lab management that manages the VMs you might want to use for your automated testing. This allows for load and performance testing, verifying code coverage, and performing coded UI tests, integration with manual and exploratory testing and managing test cases. Visual Studio 2015 Enterprise also includes IntelliTest and Fakes. If you’re familiar with Pex/Moles, you know what IntelliTest and Fakes are. IntelliTest is the next evolution of Pex that gives you the ability to automatically generate unit tests for code—effectively automated white box testing. And Fakes (which has been around since Visual Studio 2012) is mole integration and it allows mocking out methods with a “fake” delegate for more thorough unit testing.

Code Clone is also included in the Enterprise Edition. Code Clone allows you to find the same or similar code in your solution and then employ the DRY principle and refactor your code so it’s not duplicated. See Figure 1-1 for an example.

Figure 1-1.

Code Clone

Test Professional

The “next” edition is Visual Studio 2015 Test Professional. Visual Studio 2015 Enterprise is really the top edition, so Visual Studio 2015 Test Professional isn’t one up from Visual Studio 2015 Enterprise, it’s really just off to the side. Visual Studio 2015 Test Professional is a scaled-down version of Visual Studio for testing professionals. It contains no IDE features like Code Lens, nor any debugging and diagnostic features, nor any architectural features. It just contains testing features.

Test Professional provides testing professional features like lab management, TFS features, manual and exploratory testing, as well as test case management. It also includes collaboration tools that are not related to code, like Storyboarding and Team Explorer.

This edition is intended solely for testing professionals to do testing and collaborate with the team.

What’s New in Version 2015

Installer

The first new thing users will see is the installer. The look and feel of the installer has completely changed. It has taken on the “modern” look and feel. (Since Visual Studio was the first product released for Windows 8/10, it is assumed that the team had a mandate to promote the “modern” UI.) Figure 1-2 shows the installer as soon as it’s executed.

Figure 1-2.

The Visual Studio installer

From the point of view of getting Visual Studio installed, not much has changed, obviously, but the process of installing has been streamlined from the typical Windows installer. The options are much more componentized so you can install “components” rather than selecting individual products. The installer figures out what “products” (if applicable) need to be installed, as shown in Figure 1-3.

Figure 1-3.

Choosing components for installation

Live Code Analysis

One of the biggest projects coming out of DevDiv in the last few years is Roslyn. Also called “compiler as a service,” Roslyn decouples many of the things involved with compiling code into “services” that are available to developers (including Visual Studio IDE developers within Microsoft). One of the new features in Visual Studio 2015 takes advantage of compiler as a service to provide Live Code Analysis. Now, out of the box, Visual Studio 2015 includes a set of code analysis rules (very similar to FxCop or Static Code Analysis rules). What is exciting is the fact that this is extensible, which means any developer can add code analysis rules that can be checked as you type.

One of the more exciting features of Live Code analysis is that many of the rules include fixes. This means that not only will the analyzer warn you about issues in your code, but it will also provide a fix for the issue that you can optionally apply. An example is shown in Figure 1-4.

Figure 1-4.

Live Code Analysis with suggested fixes

In fact, there are already a plethora of analyzers available, many aggregated in the .NET Analyzers project on GitHub ( http://lynk.at/dotNETa ).

Debugging

Many of the debugging features of past versions have been consolidated into one window, called the Diagnostics Tools Debugger window. This window allows you to see the diagnostic status of your application in one place, as shown in Figure 1-5.

Figure 1-5.

Diagnostics Tools Debugger window

Apache Cordova

Support for the Apache Cordova platform (formerly PhoneGap) was added to Visual Studio and included out of the box with Visual Studio 2015.

Apache Cordova enables application developers to develop applications for mobile devices with JavaScript, HTML5, and CSS3. Similar to HTML apps in Windows 8/10. Apache Cordova generally allows complete reuse of code across the supported platforms (iOS, Android, and Windows Phone).

New Platforms

Technically all the platforms listed here could be developed for in Visual Studio prior to Visual Studio 2015, but you had to track down the extensions/plugins/SDKs/packages/etc. to actually do it. Visual Studio 2015 now, out of the box, supports iOS, Android, and Universal Windows (over and above typical Windows applications).

iOS

Visual Studio 2015 enables using C# to develop applications for iOS. These applications are XAML-based and built with the Xamarin tools, extensions, and frameworks.

The Apache Cordova support also means that application developers can develop applications for iOS using HTML, JavaScript, and CSS.

Android

Visual Studio 2015 enables using C# to develop applications for Android. These applications are XAML-based and built with the Xamarin tools, extensions, and frameworks.

The Apache Cordova support also means that application developers can develop applications for Android using HTML, JavaScript, and CSS.

Universal Windows

Visual Studio 2015 is the first release of Visual Studio after the Universal Windows application frameworks were released. So, Visual Studio 2015 has support for Universal Windows applications out of the box. Writing a Universal Windows application means potentially supporting any Windows 10 device. This means supporting Windows Phone (or other phones supporting Windows 10), PCs, Xbox, Surface Hub, HoloLens, and Internet of Things (IoT) devices.

It’s unlikely that you’d write one universal application to deploy on all these devices, but with class libraries and portable libraries, much of the code could be shared among the applications in cases where specialized universal application user experiences for a subset of Windows platforms is necessary.

New Bundled Third-Party Tools

Xamarin

One of the most exciting third-party tools that comes prepackaged with Visual Studio 2015 is the Xamarin suite of tools.

Xamarin allows you to build native apps for Windows Phone, Android, and IOS from a single shared code base. Each UI is 100% native to the platform and customized to each platform. This allows you to write one app and deploy it to multiple mobile platforms.

Git

Support for Git in Visual Studio started in one of the Visual Studio 2013 updates as a Git source code control provider. In Visual Studio 2015, Git support comes out of the box.

Visual Studio typically views source code control differently than Git. Git has the concept of your working directory, a staging area, and then the Git repository. Git assumes any modifications are in the working directory and are not automatically included during commit to the Git repo. The user must manually add modified files from the working directory to the staging area (and it’s easy to add all modified files at once). Then the staging area can be committed to the Git repo. This is sort of an “opt-in” philosophy. This is different from the way Visual Studio works. Visual Studio assumes all modified files are, or need to be, “checked out” and will be included in a “check-in” unless otherwise excluded (Git works a bit that way too with .gitignore files, but that’s for another time). So, in Git if you didn’t want all your files committed, you wouldn’t add them to the staging area before commit. With Visual Studio, you’d add those files to the excluded list before checking in. Visual Studio uses more of an opt-out philosophy.

Visual Studio is smart enough to know what type of source code control repository it is dealing with and use the appropriate terminology. So, if you have a Git repo you’re working with, it does say “commit” in Team Explorer. You just have to use the opt-out-type workflow, click Commit to commit any modified files. It will add them to the staging area then commit them, as shown in Figure 1-6.

Figure 1-6.

Source code control in Team Explorer

Visual Studio 2015 Solution Explorer also treats Git repositories as source code control repositories so it shows the current Git status of files. Modified files have a red checkmark and unmodified files have a padlock, as illustrated in Figure 1-7. This comes from the Visual Studio concept of checking-out files to modify them, which are otherwise locked until being checked out.

Figure 1-7.

Git status shown in Solution Explorer, with modified files marked with a red checkmark

GitHub

The third-party GitHub add-on is much like the Git extensions, but is specific to GitHub . The GitHub extension, shown in Figure 1-8, allows you to connect to github.com or GitHub Enterprise and support two-factor authentication. You can clone GitHub repositories by mouse click as well as create GitHub repositories from Visual Studio 2015 Team Explorer.

Figure 1-8.

The GitHub extension in Team Explorer

It also provides all the Git-like integration that you’d expect in Visual Studio, including showing modified files (via a checkmark) and unmodified files (with a padlock), synchronizing (pushing and pulling) from a remote repo. Figure 1-9 illustrates this idea.

Figure 1-9.

Git-like integration in Solution Explorer

Unity

The widely used platform for creating 2D and 3D games, Unity (not to be confused with Microsoft Unity, the dependency injection container included with Microsoft Enterprise Library) is still supported in Visual Studio 2015 via Unity Tools for Visual Studio 2.0. You can write games in C# to run natively on Android, iOS, Windows Phone, and many other platforms.

Unity support integrates with Unity to provide seamless game development in Visual Studio 2015, using Visual Studio 2015 features. Unity integration also includes support for the productivity features designed for Unity developers.

CodeLens

CodeLens is now available in Visual Studio Professional and it provides the ability to easily explore code changes, code history, and tests while you work in code. This includes C++, JavaScript, and SQL. CodeLens adds indicators above methods to detail things like the number of references, history, test and pass/fail, coding activity, and commits, as shown in Figure 1-10.

Figure 1-10.

Code changes and history detailed in CodeLens

CodeLens shows you to view the code that references the member and provides links to jump to that code, as seen in Figure 1-11.

Figure 1-11.

CodeLens displaying the code that references the member and providing links to jump to that code

CodeLens shows the tests run on this method in one way or another and provides a link to go to the tests, shown in Figure 1-12.

Figure 1-12.

CodeLens displaying the tests on a method and a link to go to that test

Figure 1-13 illustrates how CodeLens lists the commits performed on a given method and provides links to view more details.

Figure 1-13.

CodeLens displaying the commits performed on a given method and a link to view more details

CodeLens shows the team activity with the method, showing the quantity of changes over time. Figure 1-14 illustrates the team activity.

Figure 1-14.

Team activity displayed in CodeLens

.NET 4.6

.NET 4.6 is the latest version of .NET. In fact, at the time of writing there was already a .NET 4.6.1 update. From one standpoint, it’s just the next version of .NET. But there are some new exciting features. For one, there is a new 64-bit JIT compiler (the compiler that creates machine code from your assembly at runtime). This compiler has significant improvements over the old compiler, which was based on the 32-bit JIT compiler. This compiler will be used if your platform target is x64 or AnyCPU and is running on a 64-bit operating system. This is part of the runtime and you don’t need to do anything special (other than use the correct target) for it to be used.

There are also a lot of new interesting APIs added to 4.6. Close to 150, so we won’t detail them all here, but things like more IReadOnlyCollection<T> implementations like Queue<T> and Stack<T>, new TryStartNoGCRegion and EndNoGCRegion in the GC class to specify no garbage collection during critical code, and new SIMD-enabled types allowing operations on blocks of data instead of on individual values.

On a related note, by the time you read this, .NET 4.5.1 will no longer be supported. What does this mean? Well, it certainly doesn’t mean your software will stop working (assuming it worked before). This means that standard support is ending, so if you have a problem related to .NET you will have to look into paid support options to get it fixed. This also means that security updates will no longer be issued, unless a fix is requested via paid support (and would be provided only to you as a hotfix). If you’re working with Visual Studio 2013 (which supports up to 4.5.1 out of the box), does this mean you’re forced to upgrade to Visual Studio 2015? No, it doesn’t. In a prior version of Visual Studio they added the ability to work with future versions of .NET. There is a Developer Pack ( http://lynk.at/452DevPack ) that installs the necessary bits to be able to target .NET 4.5.2 in Visual Studio 2013.

.NET Core

.NET Core was created to be a subset of the .NET Framework. It was built to have parity with the .NET Framework (at least the applicable subset of it) while providing a core that was not coupled to a particular operating system. While it is technically an independent framework, the API it implements will be mirrored in the other .NET Frameworks, moving more away from a set of vertical frameworks to frameworks with a common core.

.NET Core is open source and will version quicker than .NET Framework (.NET Framework is typically once a year, whereas .NET Core is expected to version once a quarter. The .NET Core takes a different stance to delivery and will be delivered as NuGet packages. This means that the .NET Core is deployed locally per application. This facilitates XCOPY deployment because your application does not need “.NET Framework” installed to run, the “framework” is in the application directory. Another benefit of this is that your application is isolated from breaking changes. If a breaking change in the .NET Framework is introduced, it affects all applications using it because it’s deployed on a machine-wide basis and not part of an application deployment. Applications may have no chance to see the breaking change or do anything about it until after the fact (when customers complain that your application stopped working). With .NET Core, you must accept updates via NuGet update and deploy them. Your customers won’t see a new version of .NET Core until you’ve fully vetted it.

.NET Core is currently an option for ASP.NET 5 applications and console applications. In the future, it will likely be an option for Windows Store and Windows Phone. It’s likely that .NET Framework will always be required for desktop applications like Windows Forms and WPF.

ASP.NET

ASP.NET 5 (which was preview, or CTP, or RC, or whatever when Visual Studio 2015 was released—that whole out-of-band, component-based delivery…) is a complete rewrite, for the most part. ASP.NET 5 supports writing web applications for Mac and Linux (as well as continuing to support Windows). This is a huge advance that brings the industry closer to a write-once-run-many paradigm than it’s ever been.

One of the concepts that makes ASP.NET write-once-run-many is the reorganization of the .NET Framework. (I’d say “core,” but that would only confuse things; as you’ll see later.)

Other

In the first few iterations of Visual Studio in the “Metro” era followed the “modern” user experience by using ALL CAPS for menu items. There was, to say the least, a little feedback on that change. Many will be happy to know that Visual Studio 2015 now defaults to Title Case once again for menus (with an option to go back to ALL CAPS if you want to), as shown in Figure 1-15.

Figure 1-15.

Menu items in default title case

One of the largest complaints about Windows was the poor support for high-resolution screens. Once you got past a dimension over 2000 pixels, font sizes were hard to read. It was easy to tell Windows to use a larger font, but in Windows, control layout was obviously dependent on those sizes. A change in font size often meant that dialogs and form layouts were screwed up. The other problem was that the font size was only related to text-based items (text boxes, buttons with text, etc.). Graphics on dialogs and forms would not be scaled and they would remain the same dimensions and appear smaller. Windows offers the ability to provide larger icons for applications and whatnot so that application icons are “scaled” up in Windows Explorer and the Desktop but did nothing inherently for graphics within applications (like toolbars, etc). So, while text was generally more readable, toolbar buttons were still tiny and unrecognizable or scaled up to the point where they were also unrecognizable. Fortunately, Visual Studio includes higher-resolution images to combat this problem. Figure 1-16 shows an example of Visual Studio on a 3200x1800 screen.

Figure 1-16.

Visual Studio on a 3200x1800 screen

It’s pretty clear that we are well into the touch-enabled technology era. This is a major initiative for Microsoft, supporting touch across almost all of the product groups. Visual Studio 2015 is no different. It now supports touch much better than before. While touching the screen all day while programming seems like a recipe for sore arms, it supports a few touch gestures that I try do on many products despite spending most of my day on the keyboard. Things like touch scrolling and pinch to zoom seem to be better metaphors despite being in a largely textual environment.

Comparing Community, Professional, and Enterprise Editions

Table 1-1 compares the features offered by the Community, Professional, and Enterprise Editions of Visual Studio 2015.

Table 1-1. Comparison of Community, Professional, and Enterprise Editions

Choosing Editions

Despite the number of editions decreasing, choosing which edition to use for your team and your team members can be daunting. Fortunately, using the process of elimination can help you determine your best choice.

Community Edition

It’s easy to decide whether you can use Community or not. If you’re looking for a no-cost option and have fewer than five developers and fewer than 250 PCs in your organization and your organization has less than US$1 million in annual revenue, you can pick Community. If you’re looking for more features or simply cannot use Community, Professional is the next option to consider.

Professional Edition

Visual Studio 2015 Community and Visual Studio 2015 Professional are very similar. Usually you need to choose Visual Studio 2015 Professional if your organization has more than five developers and has more than 250 PCs or has more than US$ 1 million in annual revenue. Visual Studio 2015 Professional does support TFS features and CodeLens, so if you’re looking for your team members to collaborate via TFS and Visual Studio 2015, Community is an option, although you might want to choose Visual Studio 2015 Professional instead. If Visual Studio 2015 Community isn’t an option and you’re looking for a more features than Visual Studio 2015 Professional, Visual Studio 2015 Enterprise is the next option to consider.

Enterprise Edition

One of the biggest features only available in Visual Studio 2015 Enterprise has to do with debugging. Visual Studio 2015 Enterprise has IntelliTrace and .NET Memory Dump Analysis. What this means is that you can more easily dig deeper into production issues. With .NET Memory Dump Analysis, you can get a memory dump of a problem or a crash and dig deeper into what was happening at the time of the problem from your development computer. If that doesn’t find your problem, you can install IntelliTrace agents in production to debug the application in real-time and use IntelliTrace Historical Debugging to be able to go backward and forward in your debugging session to home in on the problem. If you’ve ever had to debug production problems, you’ll find that this makes life much easier.

Visual Studio 2015 Enterprise also makes a big leap in the support for testing environments. It is the first edition to include Lab Management. Lab Management is a set of features that manage virtual machines to perform a variety of testing, from UI testing, to load testing, to manual and exploratory testing. Along with Team Foundation Server, you can also perform many of these tests automatically during build processes. Along with this are facilities to manage test cases and managing releases.

If “test environment,” “production environment,” and “development environment” are terms that you frequently use in your organization, the Visual Studio 2015 Enterprise Edition is likely the one for you.

Although there’s nothing stopping you from choosing the Visual Studio 2015 Test Professional Edition along with Visual Studio 2015 Community or Visual Studio 2015 Professional (assuming Visual Studio 2015 Community is an option at all), it likely doesn’t make sense unless Visual Studio 2015 Enterprise is an option for at least some of your team members. If no other team members need or will be using Visual Studio 2015 Enterprise, Visual Studio 2015 Test Professional will probably not be used to its fullest potential. Visual Studio 2015 Test Professional is typically used for the testing team members on teams whose developers or architects are using Visual Studio 2015 Enterprise.

Useful Migration Paths

Small Startup

A small startup is likely an organization that has fewer than five developers, has much fewer than 250 PCs, and less than US$ 1 million in annual revenue. This type of organization can easily start out with Visual Studio 2015 Community. This assumes that they are not planning on using any of the Team Foundation Server features and are using hosted source code control providers like GitHub or even Visual Studio Team Services (both are not no cost for private repositories).

As teams ramp up in skill and ability, they may find that upgrading to Visual Studio 2015 Professional is necessary.

If the organization requires testing environments, an MSDN subscription is likely an important product as it contains testing licenses for many Microsoft products, like Windows, Windows Server, SQL Server, etc. that would cost tens of thousands of dollars otherwise if done legally.

Startup

Presumably a startup that is not considered “small” would have at least five developers. In this case, they will likely need to start out with purchasing Visual Studio 2015 Professional for their teams. If the organization has individual roles for testers and architects, the organization can purchase a small number of licenses of Visual Studio 2015 Test Professional and Visual Studio 2015 Enterprise. These editions are typically more expensive than Visual Studio 2015 Professional so they should be purchased only when needed.

Enterprise

It is expected that Enterprise-level application development is very complex and involves many engineers. So, these organizations may purchase Visual Studio 2015 Enterprise by default. To save some money, they could purchase Visual Studio 2015 Professional for junior developers.

Organizations performing enterprise-level development typically have testing and architecture roles so they would purchase Visual Studio 2015 Testing Professionals for their testing roles and use Visual Studio 2015 Enterprise for engineers.

Other Options

Visual Studio Code

Visual Studio Code (currently in Beta) is a cross-platform IDE (Windows, Mac, and Linux) that supports creating ASP.NET 5/DNX, Node.js, Office, and Unity applications.

Visual Studio Code is a much more lightweight IDE that breaks away from the solution/project file structure that Visual Studio uses in favor of JSON files and implied directory structure.

It is currently free and open source and allows users on Windows, Mac, and Linux to work on code. The typical scenario is for ASP.NET 5/DNX projects that support Windows, Mac, and Linux.

If your team works on an ASP.NET 5/DNX application supporting more than Windows, you might want to look at Visual Studio Code.

Figure 1-17 is an example of the UI.

Figure 1-17.

The Visual Studio Code IDE

Visual Studio Team Services

What used to be Visual Studio Online (which is what used to be called Team Foundation Service) is now called Visual Studio Team Services. (Yes, the acronym is “VSTS” and there was another product with that same acronym from Microsoft called Visual Studio Team System.) I mention it here as an “other option” because Microsoft describes it so: “it’s not an IDE, it’s everything else”. VSTS provides collaboration features for teams to work on various types of applications for various platforms. This is supported by Visual Studio 2015, but it’s not required.

VSTS provides features like version control (or source code control) via Git or TFVC (aka TFS), work item tracking, and Kanban boards, continuous integration, and performance testing. It also integrates into Visual Studio and other IDEs and tools (e.g. Eclipse, XCode, etc.). While you can deploy all of these types of features on-premise, VSTS provides a cloud-based alternative with a specific SLA.

OmniSharp

OmniSharp is a toolset that enables editing and editing integrations in the editor of your choice on the operating system of your choice. This allows you to have features like refactoring and IntelliSense in the editor of your choice (assuming there is a plugin for it). Currently Atom, Brackets, Emacs, Sublime, and Vim have supported plugins.

To be clear, this is not a Windows-specific toolset. For example, in the Mac with Sublime and OmniSharp, you can get IDE features like IntelliSense, as shown in Figure 1-18.

Figure 1-18.

The OmniSharp toolset on a Mac

Compilation and build tasks are typically relegated to the command-line, but with crafty extensions in each editor, that could easily be integrated.

Summary

In this chapter, we introduced the various editions of Visual Studio 2015 (Community, Professional, and Enterprise) and the different features of each. We also looked into most of what is different in Visual Studio 2015 from Visual Studio 2013. Along with some advice on choosing editions, this should provide ample information for you to decide whether to switch from Visual Studio 2013 to Visual Studio 2015, as well as which edition to choose.

Additionally, we looked at the functions of an IDE and some alternatives, such as Visual Studio Code and OmniSharp.

In the next chapter we'll look at working in teams. Chapter 2 will get into some principles and practices of organizing a software project and some software development methodologies like Agile and Scrum and finish off with how Visual Studio can help manage your work.