• Mike Taulty demonstrating how to structure and develop your apps for maximum reuse and portability
• Me covering how Visual Studio and Visual Studio Online support app developers
• Xamarin covering how their tools allow you to develop in C#, in Visual Studio, but output Windows, Android and iOS apps.

I really enjoyed the event and Mike’s demo of Portable Class Libraries and Universal Projects/Shared Projects was superb, and the Xamarin guys gave a great overview of how to target multiple platforms with minimal duplication.

A couple of people asked if I could record the demo I did, so I have, and here it is:

Basic flow:

• Create VSO project with Scrum and Git
• Create VS Hub App
• Change UI
• Add code and show debugging async calls
• Create Coded UI automated test
• Show performance analysis tools
• Look at Application Insights streaming data

I thought I’d go for a “one-take” record, so it’s not completely polished, and I also forgot to include something I showed in the actual demo – Storyboards in PowerPoint. I’ve uploaded the actual Storyboard I used as recompense, and you’ll be able to see why I’m no designer :-)

OlympiaApp Storyboard

Cheers,
Giles

In no particular order, and from across versions and editions:

1. Solution Round tripping

Solution Round Tripping was introduced in Visual Studio 2012, and essentially it allows Visual Studio artefacts to be opened up in any of a range of Visual Studio versions from 2010 SP1 to 2013. This means that you can take a solution developed in VS 2010 SP1, open it in either of 2012 or 2013, and then choose to go back to opening it with 2010 again.

It removes the forward migration of assets such that once opened in a later version, they can’t then be reopened in an earlier version. Incredibly useful for a number of scenarios including:

• Evaluating a new version.
• Sharing projects with other people on different versions.
• Working with multiple versions of Visual Studio on a single machine.

Does it work for every Visual Studio asset? No, there are limitations, with details here, but it works for a lot of assets and I think it’s a great feature. For some background this blog post explains the thinking behind the design of Solution Round Tripping.

2. Peek Definition

I seem to have my own work anti-pattern; find a reference to a element that I don’t understand, hit F12, open up a new document in Visual Studio and repeat. End result, I’ve followed a trail of definitions, hopefully have a better idea of what I’m trying to call, but now have to find my way back to the original code and close down the extra files I’ve just opened.

Peek definition, new for Visual Studio 2013, provides another option – hit Alt+F12 and the definition is not shown in a separate document, but in an editor pane inside the original source file:

If I then repeat the process I have a breadcrumb trail to follow (with it’s own keyboard shortcuts Ctrl + Alt + – and Ctrl + Alt + + ), and I can either pop up the definition as document in the document well if I really do want to open it, or hit escape to close the peek down.

Pretty good, and the peek definition view is a fully functional editor as well, so it’s not just a read-only view. In this case I’m in the second definition in my series, and I’m getting IntelliSense as I type:

3. Quick Launch

Can you remember where to find the each specific option, menu and command in Visual Studio? I certainly can’t and I’m not alone. Quick Launch was added in Visual Studio 2012 and it sits up in the top right hand corner:

Click on it or hit Ctrl + Q and start typing to find matching commands and options in Visual Studio. In this case I’ve typed in “debug” and it’s showing me: - Menu commands that contain “debug” - Tools | Options references to “debug” These are commands so you can click on them to start the related activity. So if I click on one of the options it will open the Tools | Options dialog at the relevant point.

You can limit the results you see by choosing a category. To see the categories type “@” into Quick Launch:

So if I type “@opt debug” then I only see the results relevant to Tools | Options:

So, for me, a really handy way of finding stuff with Visual Studio.

4. Exploratory Testing

Exploratory testing is one area of functionality within Microsoft Test Manager (MTM), and it was introduced (in it’s current form) in 2012. MTM comes with Test Professional, Visual Studio Premium and Ultimate. No, it’s not a coding/editor feature but it’s a part of the Visual Studio family that I think is incredibly useful.

So if you want to just do some ad-hoc testing without a test script, exploratory testing tracks what you’ve been doing so that when you come to create a bug, you don’t have to remember what you did. I’ll start an exploratory test using the Windows calculator.

What I’ve done is open up the calculator, taken a screenshot, and then entered 2+2= I’ve decided to create a bug, and what the bug work item is showing are the steps I took during the test, including highlighting where I clicked/touched the calculator UI. I can select which steps to include/exclude, and other data can also be automatically included such as a snapshot of the system information (who’s logged in, memory, resolution, OS versions and more). When I’ve edited the bug I can choose between just saving the bug or saving it and creating a test case:

If I choose to create a test case (and you can do that directly without needing to create a bug) then I get the steps I followed, again, ready for me to tidy up/edit as appropriate:

I love it – this lets you just start using the application under test and then reverse engineer test cases when you want to. It works for desktop apps, web applications and Windows store app, even on a remote machine.

5. CodeLens

Brand new for Visual Studio 2013 Ultimate. A really nice new feature that puts information about your code above the method definition. It’s ornamentation in the editor, so it’s not actually adding to the source code, and it doesn’t “exist” as a line in the source.

So, what’s that showing me? To avoid repetition all of this available elsewhere inside Visual Studio, but you need to find it and typically view it in another Window

	References to this method. Click to open the reference and an option to visualise the references in a Code Map.
	Which unit tests call this method, how long they take to run, and which ones have passed/failed. Run selected or all tests directly from here for a fast fix/re-run cycle
	Who has made what changes to this code, including change set information. Lync integration to allow communication with the author of each change.
	What work items has this method been associated with in a check-in?
	Details of any code reviews that are associated with this method.
	Code maintainability based on code complexity allowing you to decide if this method needs refactoring. Available from the Visual Studio Gallery.

There is a new Code Lens in Update 2 as well: Incoming Changes, and expect to see more over time.

Cheers,
Giles

With this in mind the team has raided our goodies cupboard and for the next 3 weeks (29^th May-18^th June 2014) we will take to twitter to find out more about your favourite features and how you use our Visual Studio tools. Please keep a look out on our twitter account @VisualStudioUK using #myVSUK. We have some awesome Visual Studio coffee cups, Visual Studio tops and a Copy of Visual Studio 2013 with MSDN to give away (competition terms & conditions here).

Anyway to get the ball rolling I thought I’d have a go myself and actually when I reflect on “What is my favourite Visual Studio feature?” I found it was harder to answer than I thought as Visual Studio now spans so far now in terms of development and test tooling it felt similar to being asked what is your favourite piece of music? The choice is so wide and based on any given moment in time your choices may change.

However that said reflecting on this I’ve narrowed it down to 5 and these are my favourites at the moment (in no particular order)…

IntelliSense

OK, we’ve had it for a long time but I simply don’t know where I would be without IntelliSense. The awesome thing about IntelliSense is as Visual Studio has evolved, expanded to new languages and file-types IntelliSense has grown to embrace these too, whether C++ to C#, VB, JavaScript and even the recent JSON additions means that IntelliSense is a key productivity enhancer I simply could no longer imagine developing without.

Test Impact Analysis

One of the lesser known features of Microsoft Test Manager is that it can advise teams of tests that should be re-run (impacted tests) when a new build is delivered. In short when you execute a test for the first time it works out which methods in your managed code you execute through the life of a test run. Then as builds are produced (via TFS Team Build) an IL Diff can be run to tell what methods have changed from build to build. With these two pieces of information when you come to start your testing on a new build Microsoft Test Manager can supply you the tests it recommends you re-run because it knows they are impacted by a code change. An awesome feature that saves that awkward conversation with the test team where they ask for time for a full-regression towards the end of a sprint.

Release Management

OK so this is a big “feature” more of a collective, but at the moment I am spending a lot of time discussing with customers the Release Management tools that are new to Visual Studio 2013. I love the fact that Release Management enables automated application deployments in a consistent way that can be used in development/test environments all the way to going live. I know that it can save time, allow faster delivery cadence, eliminating manual errors but quite frankly I’m just glad I will no longer have to author another word document for the ops team on how to deploy a solution step-by-step.

Auto-format/CTRL K+D

Another one that’s been in the editor for years and I could argue with the formatting as I type my old favourite keyboard shortcut is getting used less and less. However I like my code to look uniform even if I don’t always like what it does :-) so this little feature sorts things out, straightening up things for me. Better still that in C++ in the Visual Studio 2013 release we now have code formatting too, so whilst I don’t write as much C++ as I used to, when I do I’ve get help here just like I get in C#.

IntelliTrace

IntelliTrace for me represents my get out of jail free card, giving detailed debugging information from environments that you are not connected to. This can be a real lifesaver when you have production issues, but also can save masses of time in Dev and Test. If I see an issue occur in production or on a testers machine I simply need to get an IntelliTrace file collected from the environment (and in Test this is baked into Microsoft Test Manager for collection) and then do a post-mortem debugging  session in Visual Studio to find the
offending issue. I love the fact that this technology has been baked into a single Microsoft Monitoring Agent that enables me to connect more seamlessly with our System Center users or from my applications being monitored with Visual Studio Online Application Insights.

1. Code Quality Tools

Building on the extensible unit testing support in Professional, Premium adds in Code Coverage, to help you understand how much of your code is covered by your unit tests, from assembly level to lines of code. Extremely useful in helping you to understand where to focus your effort in unit testing. I’d use this to either set overall targets (we should have 90% unit test coverage) and/or to look at specific parts of the application and see where coverage is poor.

Code Metrics analyses your code using a number of factors, including cyclomatic complexity, inheritance and the number of lines of code to provide a maintainability index indicating, from assembly to method level, where your code is potentially too complicated and/or difficult to maintain. There’s a relationship between code that’s complicated and bugs – if it’s difficult to understand all of the paths through the code, it’s unlikely that those paths will all have been tested, and therefore there are potentially bugs lurking. Use Code Metrics in conjunction with Code Coverage and you can look for code that is potentially too complicated and under tested, and focus your efforts in the most valuable parts of the codebase.

2. Code Clone Analysis

Ever written some code only to find that something similar already exists in your code base? Ever been guilty of copy and paste programming? Not sure if either of these are true in your project? Code Clone Analysis can identify similar code and help you focus on where code can be refactored to remove redundancy and simplify maintenance.

3. Code Review

Premium adds in support for a Code Review work flow, using Team Foundation Server (or Visual Studio Online). Create and submit a code review request to one or more people, and they can see your request with your description and the related files. Respond to that, including adding comments linked to individual code lines as part of the flow.

4. Suspend and Resume

Ever been deep in the middle of coding when the request to “drop everything and fix this other problem/bug/situation” arises? Suspend and Resume allows you hit suspend and save the state of your pending changes and the layout of Visual Studio (which files are open, break points etc.). You can then switch projects/versions/solutions, or whatever is needed to address the higher priority situation, and then once that is done, resume to get back to exactly where you where before the interruption.

It won’t help with the mental context switching but it means you don’t have to worry about whether the code is ready to be checked in or not, or lose “your place” inside Visual Studio while you deal with the other situation. Suspend and Resume uses Team Foundation Server shelve sets to store the data safely in TFS.

5. Microsoft Test Manager

You get a whole other toolset with Visual Studio Premium: Microsoft Test Manager (MTM). MTM provides test case management, manual test case creation and execution, fast forward testing to “semi-automate” manual tests, exploratory testing and rich actionable bugs. Way too much to go into here, but essentially you’ve got an entire range of test tools available to you as part of Premium.

I really like Exploratory testing – you can start testing without any test scripts, and if you find a bug, your steps have been recorded so you don’t need to document how you discovered the bug. You can also reverse engineer a test case from the steps you took so that you can add it to a regression suite for future use.

A lot of that Microsoft Test Manager goodness above is now also available to Premium users in the web access tooling. There’s a new Test hub that allows you to create test plans, test suites and test cases as well as run tests from the browser. It’s not as fully features as the thick client, but it gives you some solid basic test tools with no install necessary. It also provides something that the thick client doesn’t – the ability to paste test cases in directly from Excel and work with tests cases in a grid view.

6. Release Management

Visual Studio 2013 introduced Release Management; how to author a workflow, including human approvals, for releasing builds into multiple environments (e.g. Dev, Test and Production). This lets you eliminate what can be a tedious and error prone manual approach whilst also allowing you to reuse any existing scripts or code that you use to achieve this. Visual Studio 2013 Premium gives you the Release Management client tooling to let you create these workflows.

7. Coded UI Tests

Outside of MTM but part of Visual Studio Premium itself, is Coded UI Tests. This provides automated functional testing including the ability create assertions to validate that a test has passed. Coded UI allows you to create regression tests and suites to automate the testing of new versions of your application.

Coded UI can be created from scratch (watch and record) or by taking a manual test that’s been run with action recording turned on, and works by driving the accessibility API for the application you want to test. It works for any kind of web application (it doesn’t need to be ASP.NET), WinForms, WPF and some other technologies. The test itself is maintained as code, managed within Visual Studio just like any other solution or project.

So; do you want to be able to run 10, 100 or 1000 automated functional tests whenever you’ve got a new build (including if it's been deployed to the test environment automatically with Release Management)? Coded UI can do that for you.

8. Storyboards

I think most people are visual, and being able to present back how you envisage delivering requirements in the form of a story board of screens and flow can really help to confirm and test understanding of how to implement requirements. Premium gives you access to Storyboarding, which is an add-on into PowerPoint, and allows you to easily create screens from library of shapes, and link these back to requirements inside Team Foundation Server.

9. Agile Portfolio Management

When working with the Agile Planning tools in Team Foundation Server, there can be Product Backlog Items that can’t sensibly be delivered within a single Sprint; they’re too big or too high in concept. In order to record and track these higher level requirements, Agile Portfolio Management adds support for levels above the Product Backlog.  Visual Studio Premium allows you to access this functionality.

These are called Features out of the box, but you can rename them (a lot of you might think of these as Epics, for example), and add extra levels above that, perhaps to reflect a structure like that found in Scalable Agile Frameworks (SAFe).

These can be mapped to Product Backlog Items, allowing you to view the relationship between the levels of requirements, and understand which Sprints are going to contribute to addressing them.

10. Team Rooms

Team Foundation Server 2013 introduced Team Rooms, which requires Premium. A team room records selected events (builds, check-ins, work item changes, code reviews) alongside team chat to provide a date organised contextual history of what was happening in a project. Really useful to understand what was going on and who was involved. Even more useful if your team is not co-located (different offices, working from home) or even not in the same time zone.

11. Work Item Charting

An incredibly fast (as in seconds) and easy way to create Work Item Charts (pie, bar, column, stacked bar and pivot table) based on work item queries. So; if you have a query that you find useful (all bugs in Sprint 2, remaining work, all active tasks, etc.) Premium gives you the capability to add visualisations of that data in no time, and pin them to the project home page.

12. £65 per month of MSDN Azure Credits

Last but not least is the Microsoft Azure credit you get with Premium: £65 a month of free credit. So, every month you get £65 of Azure billing for free. No credit card required, and by default once that credit gets used, it simply stops until next month, so you can’t end up with a bill you didn’t expect.

What does £65 a month in Microsoft Azure give you? Well, have a play around with the pricing calculator, but you could have web sites, storage, virtual machines (Windows, Visual Studio, SQL Server, SharePoint, Linux, Oracle and others) or more. If we look at virtual machines that could be:

• 1 Small Windows machine (1.6GHz CPU, 1.75GB RAM, 225GB Storage)  and 2 Extra Small Windows machine (1GHz CPU, 768MB RAM, 20GB Storage) running 24/7 for the entire month (total cost £61.56)
• 6 Extra Small Windows machines running 24/7 (total cost £56.82)

But remember that Microsoft Azure bills by the minute, so if you don’t run these 24/7 you could get a lot more:

• About 20 Extra Small Windows machines for 8 hours a day each month
• An A7 Windows machine (8 x 1.6GHz CPU, 56GB RAM) for about 2 hours a day or solidly for about 2.5 days a month

Interested, but not sure how to get started? Colin covered this in another post.

So, wish you had some more environments for dev, test or even R&D? If you have Premium you already have the credit to expand your environments into the cloud.

I haven’t gone into much detail on each of these in order to keep this at a readable length but hopefully that’s of some use in explaining what I see as the key reasons for looking at Visual Studio 2013 Premium.

Cheers,
Giles

Sometimes in my learning I come across a killer book that will really resonate, and for me one such book was The Lean Start-up by Eric Reis which completely revolutionised the way that I like to approach my development and made me focus on the importance of the Build-Measure-Learn cycle.

For me the Build-Measure-Learn cycle represents a lot of what modern day application development is about. You simply put something out there, look to measure usage and apply learnings to enable you to focus your changes to support your users achieving their goals.

But how do we learn about our applications? How do we support this important Build-Measure-Learn cycle and gain insights into the applications we put out into the wild?

In the Visual Studio family of tools we have for a long time been building tools that help our customers build applications, however the measure and learn stages were an area left unaided, leaving developers to implement their own ways of measurement and instrumentation in which they could learn from. Recently however that has changed with Visual Studio Online Application Insights, which serves to monitor and centrally collate information about production applications and services so that we can gain insights that may have been difficult to obtain in the past.

Application Insights has 3 key areas that help analyse applications:

1. Availability – Measure an applications availability from a series of global locations. This could be a simple ping test of an endpoint, or a more complex test (Web Test) that travels through logical key scenarios of an application end-to-end.
2. Application Performance Monitoring – Monitor an application looking for key events, such as exceptions, performance issues or memory events that can alert us to problems prior to our customers reporting them to us.
3. Usage Telemetry – Gain insight into an applications usage; see how our users engage with our applications, what platforms, browsers or devices they use? How often they revisit and how engaged are they when they are in the application?

Application Insights works with different application types including both Java and .NET server apps, client side JavaScript or deployed clients such as Windows Phone or Store applications. Application Insights is a service currently in public preview provided through Visual Studio Online (sign-up at https://www.visual studio.com and request an Application Insight voucher code).

Front and centre to the service is a customizable dashboard allowing you to select a range of charts and metrics for your application, each of which can be drilled into for further detail or can have email alerts setup against customizable threshold values.

Visual Studio Application Insights - Dashboard

Availability monitoring with Application Insights

The availability monitoring in Application Insights enables applications to be tested from an outside-in perspective to get a view of availability. With this kind of monitoring, an endpoint will be automatically accessed from up to 16 global locations measuring success or failure and the speed of responses.

Visual Studio Application Insights - Availability

The outside-in monitoring has two modes of operation. The most simple of these modes is simple ping test of a single endpoint, or alternatively a more in-depth multi-step test is available that utilises the same HTTP protocol level web tests made available in Visual Studio Web Performance Tests. Completing a multi-step test enables Application Insights to test end-to-end key scenarios in our applications, measuring success or failure and measuring response times of our application from a series of global locations. Should a failure be noted as part of a multi-step test we can see granular detail of the step failing which can be viewed in the browser or opened directly in Visual Studio.

Visual Studio Application Insights – Global Availability with a Web Test

Application Performance Monitoring with Application Insights

The monitoring functions of Application Insights provides Application Performance Monitoring capabilities to your applications via an agent that needs to be deployed and sit alongside your applications. The agent functions to capture key metrics around your application and then centrally collate these metrics back to Visual Studio Online.

The agent that sits behind these capabilities is the Microsoft Monitoring Agent (MMA) that is also used for monitoring applications with Microsoft System Center. The agent can monitor .NET, Native and Java applications providing a mechanism to monitor for application exceptions, performance or memory events.

Visual Studio Application Insights – Server Performance Metrics

As a central hub for all our monitored servers, Application Insights provides consolidated, detailed reporting and analysis of how our applications are performing and the rates of exceptions raised or performance and memory events where thresholds are exceeded.

Where Application Insights and the MMA provides additional insights is in the instance where it notes an exception or performance/memory event it will log additional details such as IntelliTrace logs to pinpoint exception locations or IntelliTrace performance counters that demonstrate the hot path for our slow running requests. Similarly for memory events a base-lined memory dump comparison is logged, each of these scenarios allowing familiar Visual Studio IntelliTrace or Memory Comparison tooling to be used for deep analysis.

Visual Studio Application Insights – Memory Event

Usage Telemetry with Application Insights

Usage telemetry data is one of the key features that enables us to learn about our applications, and it is this feature that most strongly assists my developments with the Build-Measure-Learn cycle. With usage data, Application Insights enables a user to be profiled as they work with my applications and services. This usage data again will be centrally collected into Visual Studio Online giving me access to a host of information about my users that I may not have been aware of in the past.

At a simple level I can get details about my users environments. What operating system do they use? What Browser? What Device? I can even tell what resolution they are viewing at. This information helps me start to learn about my users and their preferences, but also starts to give me information around where I should concentrate my development and test efforts whether that be to support the masses, an emerging group, or an environment that I had not considered in the past. There is much more I can learn too including information such as my users geography or what language they use.

Visual Studio Application Insights – Browser Usage Data

One of the areas I find particularly interesting is the referral site details, helping me see where my users may have found my application from. Is this from direct links? from search engines or maybe another route like a marketing campaign that I wish to gauge the effectiveness of. These referral statistics give me insight I may not previously have had to hand.

Further to these sorts of statistics the usage telemetry goes further into profiling my users, and their engagement level. How long do they spend in my application? How long before they come back? How many of my users are ones I’ve seen before? Once again these sorts of statistics help me understand my users further and to try and make application changes to drive up these interaction numbers to control my engagement level.

Visual Studio Application Insights – User Loyalty Data

The part that I particularly like to support my Build-Measure-Learn cycle is the ability within Application Insight usage telemetry to write custom events information that I can log on a per page or per event basis that can fuel a number of scenarios that help me deliver a solution that best meets the needs of my users. Some examples where this can be useful:

• Measured user journeys – Looking at an end-to-end process that I expect a user to travel through to accomplish a goal I can now measure at which point users get to and where users drop out. This helps me learn areas in my application that I need to improve to get users to the next application stage.
• A/B testing – In areas of my applications I can write a number of variants of an application feature that I can selectively use with my users. I can measure the features usage and understand the preferable long term choice for all my users.
• Early adopters – In my applications I can take a small group of early adopters that I can deliver a new set of features to. I can measure the success and iterate my changes to these features with my trusted group of adopters monitored by Application Insights before I expand to a wider audience of users.

In all of these cases I can now supplement my conversations with users with rich analytical information that I know is based on real usage of my applications and services.

Getting Started with Application Insights

If you’re interested in Application Insights and want to start using it to monitor and learn from you applications usage then the setup steps are very simple. First you’ll need a Visual Studio Online account (https://www.visualstudio.com/) following the link to get signed up to Application Insights on the homepage to your Visual Studio Online account (https://<youraccount>.visualstudio.com/). Once Application Insights is enabled for your account simply select the “Add Application” button that has comprehensive wizards with video examples of how to get setup depending on if your code is client or server based, on a device or in a datacentre or cloud based application. Further tutorial videos can be found online at: https://channel9.msdn.com/Series/Application-Insights-for-Visual-Studio-Online.

In the latest Visual Studio Online release (January 22nd) you can now configure your working week to exclude weekends, or define which days you do you want to be included in the burndown:

Go to the admin site, and for each project team, you can then change the working days setting.

The release also includes support for querying tags from work item queries, another often requested feature.

Good stuff!

Giles

Feel free to sign yourselves up at: https://events.msdn.microsoft.com/en-gb/#fbid=WiyDCpHn1HH

(In preparing a test environment to take screenshots from I made a note of how to install Linux in Hyper-V and installing the Team Explorer Everywhere plug-in for Eclipse, in case those are of interest).

Summary

When using TFS, you don’t need to be using Visual Studio, nor do you need to be on Windows. So, what can you do, using TFS 2013, but accessing it from a non-Windows desktop?

Plan & Track (new features in 2013): Full access to the web based Agile planning tools, team rooms, work items and work item queries.

Develop (updated for 2013): Use the Eclipse integration to use TFS source control, integrate to work items and access TFS from within the IDE for non Microsoft technologies.

Build: Define and run automated builds based on Ant or Maven.

Web Test (new for 2013): Create test plans, organise and author test cases, and execute manual tests. This is a new area for cross platform support in 2013.

Why is this important? Even though a proportion of the team or organisation may not be using Visual Studio and/or Windows, they are still able to work on the same projects, using the same process, contribute and access the same information, use the same source control repository, contribute to testing and automatically provide reporting metrics. Different technologies and teams don’t need different tools and can collaborate more easily, with more transferable skills.

Let’s take a look at each of those areas in more detail.

Plan & Track

TFS 2012 introduced the new Agile Planning Tools in the Web Access. TFS 2013 has extended these tools with Agile Portfolio Management, Team Rooms, Work Item Charting and more. All of these capabilities are available in any modern browser, and are not platform dependent. So on this Linux machine, using Firefox, that means full access to:

Product Backlogs, including Agile Portfolio Management

Sprint Backlogs, burn down and capacity planning:

Task boards

Team Rooms

Work Items and charts

In all of these planning and tracking areas, the tools are no different from using a modern browser on Windows.

Develop

The cross-platform Team Explorer Everywhere plug-in for TFS will install into Eclipse and provide access to TFS:

In particular, source control integration

And access to work items and work item queries without leaving Eclipse

Build

From within Eclipse, you can view build logs, invoke builds and create new build definitions, using the TFS triggers and workflow, but wrapping an Ant or Maven script:

You can also access build logs and invoke builds from within the web access tools:

Web Test

One of the new features of TFS 2013 is the web based test tools. For a cross-platform environment that means that you can create test plans, and organise test cases into the full range of suites (static, work item query and requirements):

You can create and edit test cases, complete with parameters and shared steps:

Including the new grid view:

And run manual tests from within the browser, passing or failing steps, editing steps and raising bugs:

There are a number of areas in test that you can’t access, but these are the same restrictions as accessing the web test tools on Windows – you can’t configure test plans (which data adapters to use, manage configurations etc,.), you can’t collect rich actionable data in bugs, and there’s no exploratory testing. For all of these you need to use Microsoft Test Manager, which is a Windows desktop client.

Overall, there is a good range of TFS capabilities accessible from non-Windows platforms, using a combination of TFS web access and the Eclipse plug-in. It’s not on a parity with the support from a Windows machine in several areas, but it does provide broad support across key areas.

But what about if …

I don’t use Linux, I use Mac/Solaris/other Unix OS:

That’s ok, the web access and Team Explorer Everywhere plug-in work across a range of platforms and Eclipse versions so all of the above will hold true.

I don’t use Eclipse:

There are probably two common reasons why not:

1. You’re a real man/woman and don’t use an IDE :-)

For whatever reason you’re using something else (Vi, Emacs, another IDE). TFS provides cross-platform command line tools so that you can work in another environment and still work with TFS source control. It won’t be integrated into whatever you’re using, but it gives you command line level support across platforms.

2. You’re an iOS developer and are using XCode

You can either take the route above, or more likely, use the existing XCode Git integration, see the next topic…

I use Git:

No problem. TFS 2013 now supports Git, and for each Team project you can decide whether to use the Team Foundation Version Control or Git within TFS. You can then use your existing/favourite Git tools and utilities.

There’s another scenario, perhaps if you’re an iOS developer, using Git within XCode, but the rest of the team are using TFS including Team Foundation Version Control. In that case you can use Git-TF, and synchronise your source code between Git and TFS.

I don’t have Windows servers for TFS to be installed on:

TFS does need to be installed on Windows (server or desktop), so that means if you don’t/can’t have a Windows machine on premise then you might want to take a look at VisualStudio Online, which provides TFS hosted in the cloud (Windows Azure). TFS is then provisioned in the cloud for you, and all of the above if accessed from your desktop. As it happens, that’s what I did for this post – within Linux I pointed my web browser and Eclipse at Visual Studio Online for TFS.

I want to use the new Release Management capabilities in TFS 2013:

You won’t be able to edit/create the workflows, as that requires a Windows client, and there aren’t deployment agents for non-Windows platforms. However, when you check code into TFS (e.g. from Eclipse) that can trigger a build, which is already linked into Release Management, which then does it’s stuff deploying to different dev, test and/or production environments, so it’s possible to be involved in the overall workflow.

If you’ve got here, well done. This post has turned out to be longer than I expected but I hope it’s a useful reminder and update (with the new web test tools) of how TFS can provide a lot of value even if you’re not a member of a Visual Studio or even Windows based team.

Cheers,
Giles

• In Eclipse, select Help | Eclipse Marketplace…
• Enter search terms. I find that anything relevant I can think of doesn’t bring back the TFS plug-in for Eclipse in the first screen. Examples I’ve used include Team Explorer Everywhere, TFS, and Team Foundation Server.
• I suggest entering “TFS Plugin for Eclipse”, and then enter/click Go:

• Then scroll to the bottom of the screen and select the link to Browse for more solutions:

• This will open a browser window in Eclipse, and you should now see the TFS Plug-in at the top of the list.

• That’s the hard part :-) Now just select install and follow the installation wizard:

• Once it’s installed, open up the TFS Perspective

• Connect to your TFS Server (in my case VisualStudio Online, what was called Team Foundation Service):

And then you can start using TFS within Eclipse for source control, builds, and access to work items and queries:

Cheers

Giles

Windows Live Tags: Team Explorer Everywhere,Eclipse,Marketplace,Team Foundation Server,Plugin,installation,wizard,Perspective,VisualStudio Online

Preparing the virtual machine

Installing Linux in Hyper-V is essentially straightforward:

• Get hold of your Linux distro. In my case Fedora 19.
• In Hyper-V Manager create a new  Virtual Machine:

• I assign 2048 MB for RAM, as that’s plenty for general use, but I make it dynamic in case it’s needed:

• Leave Configure Networking as Not Connected and we’ll sort that in the section below:

• I set my hard disk size to be 20GB as that should be plenty for a standard install with Eclipse:

• Then just add the Linux distro iso file as a bootable DVD:

That’s it, the virtual machine is ready to be used. But before starting the machine for the first time see the section below.

Important networking step before starting the installation

Networking. It’s much easier to get the Linux installation to do the configuration, and I think the easiest way to do that is to setup a legacy network adapter in the virtual machine. If you’re using a Linux distro that’s supported in Hyper-V you can use the Linux Integration Services, but here I’m using an “unsupported” distro, as this is more likely for desktop installs.

• With the virtual machine selected in Hyper-V Manager, select the virtual machine settings
• Then select Add Hardware and choose Legacy Network Adapter:

• Click Add and select a virtual switch that gives the connectivity you want. In my case using my network card for external access. If this isn’t available, you need to set it up in Hyper-V Manager as a virtual switch.

• Click Apply
• Next, remove the “non legacy” Network Adapter:

• Click OK
• Now, you can start the virtual machine and follow the installation steps for the distro. Once you’ve installed it, ejected the bootable DVD and restarted you should be in and with a working network connection:

• In my case the network settings were setup for me on my network:

That’s it. You should now have a clean Linux install with networking configured, enabled and working.

Cheers,
Giles

Windows Live Tags: Linux,Hyper-V,Team Foundation Server,installation,Eclipse,Fedora,configuration,setup,legacy,adapter,settings,Hardware,Network