JSON Schemas in BizTalk Server 2013 R2

This is the third in a series of posts exploring What’s New in BizTalk Server 2013 R2. It is also the first in a series of three posts covering the enhancements to BizTalk Server’s support for RESTful services in the 2003 R2 release.

In my blog post series covering the last release of BizTalk Server 2013, I ran a 5 post series covering the support for RESTful services, with one of those 5 discussing how one might deal with JSON data. That effort yielded three separate executable components:

  1. JSON to XML Converter for use with the WFX Schema Generation tool
  2. JSON Decoder Pipeline Component (JSON –> XML)
  3. JSON Encoder Pipeline Component (XML –> JSON)

It also yielded some good discussion of the same over on the connectedcircuits blog, wherein some glitches in my sample code were addressed – many thanks for that!

All of that having been said, similar components in one form or another are now available out of the box with BizTalk Server 2013 R2 – and I must say the integrated VS 2013 tooling blows away a 5 minute WinForms app. In this post we will begin an in-depth examination of this improved JSON support by first exploring the support for JSON Schemas within a BizTalk Server 2013 R2 project.

How Does BizTalk Server Understand My Messages?

All BizTalk Server message translation occurs at the intersection between 2 components: (1) A declarative XSD file that defines the model of a given message, with optional inline parsing/processing annotations, and (2) an executable pipeline component (usually within the disassemble stage of a receive pipeline or assemble stage of the send pipeline) that reads the XSD file and uses any inline annotations necessary to parse the source document.

This is the case for XML documents, X12, EDIFACT, Flat-file, etc… It only logically follows then that this model could be extended for JSON. In fact, that’s exactly what the BizTalk Server team has done.

JSON is an interesting beast however, as there already exists a schema format for specifying the shape of JSON data. BizTalk Server prefers working with XSD, and makes no exception for JSON. Surprisingly this XSD looks no different than any other XSD, and contains no special annotations to reflect the message being typically represented as JSON content.

What Does a JSON Schema Look Like?

Let’s consider this JSON snippet, which represents the output of the Yahoo! Finance API performing a stock quote for MSFT:

image

This is a pretty simple instance, and it is also an interesting case because it has a null property Ask, as well as a repeating record quote that does not actually repeat in this instance. I went ahead and saved this snippet to the worst place possible – my Desktop – as quote.json and then created a new Empty BizTalk Server Project in Microsoft Visual Studio 2003 (with the recently released Update 3).

From there I can generate a schema for this document by using the Add New Items… context-menu item for the project within Solution Explorer. From there, I can choose JSON Schema Wizard in the Add New Item dialog:

image

The wizard looks surprisingly like the Flat-file schema wizard, and it looks like quite a bit of that work might have been lifted and re-purposed for the JSON schema wizard. What’s nice about this wizard though, is that this is really the only page requiring input (the previous page is the obligatory Welcome screen) – so you won’t be walking through the input document while also recursively walking through the wizard.

image

Instead the wizard makes some core assumptions about what the schema should look like (much like the WFX schema generator). In the case of this instance, it’s not looking so great. Besides from essentially every single element being optional in the schema, the quote record was not set as having a maxOccurs of unbounded – though this should really be expected given that our input instance gave no indication of this. However, maybe you’re of the opinion that the wizard may have been written to infer that upon noticing it was a child of a record with a plural name – which might be an interesting option to see.

image

Next the Ask record included was typed as anyType instead of decimal – which again should be expected given that it was simply null in the input instance. However, maybe this could be an opportunity to add pages to the wizard asking for the proper type of any null items in the input instance.

Essentially, it may take some initial massaging to get everything in place and happy. After tweaking the minOccurs and maxOccurs, as well as types assigned to each node, I decided it would be a good time to ensure that my modifications would still yield a schema that would properly validate the input instance I provided to the wizard.

How do We Test These Schemas Or Validate Our JSON Instances?

Quite simply, you don’t. At least not using the typical Validate Instance option available in the Solution Explorer context-menu for the .xsd file. Instead this will require a little bit of work in custom-code.

Where am I writing that custom code? Well right now I’m on-site in Enterprise, Alabama teaching a class that involves a lot of automated testing. As a result, I’m in the mood for writing some unit tests for the schema – which also means updating the project properties so that the class generated for the schema derives from TestableSchemaBase and adds a method we can use to quickly validate an instance against the schema.

image

It also means adding a new test project to the solution with a reference to the following assemblies:

  • System.Xml
  • C:\Program Files (x86)\Microsoft Visual Studio 12.0\Common7\IDE\PublicAssemblies\Microsoft.BizTalk.TOM.dll
  • C:\Program Files (x86)\Microsoft Visual Studio 12.0\Common7\IDE\PublicAssemblies\Microsoft.BizTalk.TestTools.dll
  • C:\Program Files (x86)\Microsoft Visual Studio 12.0\Common7\IDE\PublicAssemblies\Microsoft.XLANGs.BaseTypes.dll
  • Newtonsoft.Json (via Nuget Package)

That’s not all the setup required unfortunately. I still have to add a new TestSettings file to the solution, ensure that deployment is enabled, that it is deploying the bolded Microsoft.BizTalk.TOM.dll assembly above, and that it is configured to run tests in a 32-bit hosts. From there I need to click TEST > Test Settings > Select Test Settings File, to select the added TestSettings file.

image

image

image

image

With all the references in place and the solution all setup, I’ll want to bring in the message instance(s) to validate. In order to ensure that the test has access to these items at runtime, I will add the applicable DeploymentItem attribute to each test case that requires one.

using Microsoft.VisualStudio.TestTools.UnitTesting;
using Newtonsoft.Json;
using System.IO;
using System.Xml;

namespace QuickLearn.Finance.Messaging.Test
{
    [TestClass]
    public class ServiceResponseTests
    {

        [TestMethod]
        [DeploymentItem(@"Messages\sample.json")]
        public void ServiceResponse_ValidInstanceSingleResultNullAsk_ValidationSucceeds()
        {

            // Arrange
            ServiceResponse target = new ServiceResponse();
            string rootNode = "ServiceResponse";
            string namespaceUri = "http://schemas.finance.yahoo.com/API/2014/08/";
            string sourceDoc = Path.Combine(TestContext.DeploymentDirectory, "sample.json");
            string sourceDocAsXml = Path.Combine(TestContext.DeploymentDirectory, "sample.json.xml");

            ConvertJsonToXml(sourceDoc, sourceDocAsXml, rootNode, namespaceUri);

            // Act
            bool validationResult = target.ValidateInstance(sourceDocAsXml, Microsoft.BizTalk.TestTools.Schema.OutputInstanceType.XML);

            // Assert
            Assert.IsTrue(validationResult, "Instance {0} failed validation against the schema.", sourceDoc);

        }

        public void ConvertJsonToXml(string inputFilePath, string outputFilePath,
            string rootNode = "Root", string namespaceUri = "http://tempuri.org", string namespacePrefix = "ns0")
        {
            var jsonString = File.ReadAllText(inputFilePath);
            var rawDoc = JsonConvert.DeserializeXmlNode(jsonString, rootNode, true);

            // Here we are ensuring that the custom namespace shows up on the root node
            // so that we have a nice clean message type on the request messages
            var xmlDoc = new XmlDocument();
            xmlDoc.AppendChild(xmlDoc.CreateElement(namespacePrefix, rawDoc.DocumentElement.LocalName, namespaceUri));
            xmlDoc.DocumentElement.InnerXml = rawDoc.DocumentElement.InnerXml;

            xmlDoc.Save(outputFilePath);
        }

        public TestContext TestContext { get; set; }
    }
}

What Exactly Am I Looking At Here?

Here in the code we’re converting our JSON instance first to XML using the Newtonsoft.Json library. Once it is in an XML format, it should (in theory at least) conform to the schema definition generated by the BizTalk JSON Schema Wizard. So from there, we take output XML, and feed it into the ValidateInstance method of the schema to perform validation.

The nice thing about doing it this way, is that you will not only get a copy of the file to use within the automated test itself, but you can also use the file generated within the test in concert with the Validate Input Instance option of the schema for performing quick manual verifications as well.

After updating the schema, it looks like it’s going to be in a usable state for consuming the service:

Screenshot of final code

Coming Up Next Week

Next week will be part 2 of the JSON series in which we will test and then use this schema in concert with the tools that BizTalk Server 2013 R2 provides for consuming JSON content.

If you would like to access sample code for this blog post, you can find it on github.

Getting Started with BizTalk Server 2013 R2’s Built-in Health Monitoring

This is the second in a series of posts exploring What’s New in BizTalk Server 2013 R2.

With the BizTalk Server 2013 R2 release, Microsoft has finally implemented a common request to have some level of built-in monitoring tool for a BizTalk Server installation. While this built-in option won’t replace things like the BizTalk Server 2013 Monitoring Management Pack for System Center Operations Manager, or come remotely close to the feature set of third party options like BizTalk360 or AIMS for BizTalk, but it does provide an out-of-the-box solution for performance monitoring, environment validation and notifications.

Ultimately, this tool was built by the same project team that created the MsgBoxViewer tool (MBV), and represents an effort to more tightly integrate this stand-alone tool with the BizTalk Server Administration Console.

The first release supports the following features, with updates promised in the future:

  • Ability to monitor multiple BizTalk Server environments
  • MBV report generation and viewing
  • Dashboard view for overall BizTalk Server environments health
  • Scheduled report collection
  • Email notifications
  • Performance monitor integration with pre-loaded scenario-based performance counters
  • Report management

I Have BizTalk Server 2013 R2, But Where Is This Health Monitor?

Unfortunately, the Health Monitor is not registered for use by default, and doesn’t show up anywhere by default. Before making use of it, you’ll have to do some dirty work to get it prepared for use. The core files live under the BizTalk Server installation directory at \SDK\Utilities\Support Tools\BizTalkHealthMonitor.

BizTalk Server 2013 R2 Health Monitor Files

So what do we do here? We need to run InstallUtil.exe against the MBVSnapin.dll. In order to accomplish this, we can either drop to the command line, or drag and drop MBVSnapin.dll on InstallUtil.exe.

Register BizTalk Server 2013 R2 Health Monitor

Once it is registered, you can add it to a Management Console alongside the BizTalk Server Administration Console for an all-up management experience.

In order to do that, run mmc /32

Running MMC /32

After a nice clean and empty management console appears, press CTRL+M, and then add both the BizTalk Health Monitor and the Microsoft BizTalk Server Administration snap-ins to the console.

Adding BizTalk Server 2013 R2 Health Monitor to the Console

You end up with an Administration Console window containing the items shown in the screenshot below. This might be a good opportunity to add the Event Viewer snap-in for each of your runtime servers as well. At this point, you may want to save the console setup for later use.

BizTalk Server 2013 R2 Administration Console with Health Monitor

What Can I Do with This Thing?

If you expand the Performance node, and click Current Activity, you will be able to examine select performance counters across your BizTalk Server installations through an embedded perfmon display.

image

If you right-click each BizTalk Group within the Health Monitor, you have the ability to execute a set of rules that validate your installation while highlighting problem areas.

Running Analysis

Once you run the analysis, a node is added to the navigation pane labeled with the date and time of the analysis. This report contains the result of executing validation rules at a fixed point in time. This report can be sent via email, or opened in the browser for additional details.

Results of Analysis

Right now, it’s looking like my installation is throwing a pretty critical warning when it comes to the Jobs category. Let’s see what that might be.

Jobs Warning

It looks like the Backup BizTalk Server job hasn’t been enabled, and there isn’t any history indicating that this job has ever executed. That’s fairly concerning and problematic. It would be nice if we could have been notified about that in a more proactive manner.

Enabling Automatic Scans / Notifications

If I go back to the BizTalk Group within the Health Monitor, and click Settings, I will find myself at a screen that enables me to configure automatic analysis of my BizTalk Server Group as well as notifications of scan results.

BizTalk Health Monitor Settings Menu

Additionally, I can even configure the queries executed, rules evaluated, and the views on top of that information I want to include in each analysis.

Configuring Reporting Settings

If I want to enable notifications, I have a few different options. I can either configure email notifications, or if I want to essentially pipe these notifications into another tool that can consume event log entries, I can direct notifications to the event log instead.

Notification Settings

More to Come

As mentioned earlier, it sounds like the team is already well underway with an update to this tool, and it’s safe to say that there will likely be more to come. I would venture to guess that this will mean either more features and deeper console integration (since there are still quite a few times where clicking an option launches the browser to show full details). We’ll keep this space updated.

In the meantime, if you’re just now moving to either BizTalk Server 2013, or BizTalk Server 2013 R2, and you want to keep your skills up to date, check out one of our BizTalk 2013 Developer Immersion classes or BizTalk 2013 Administrator Immersion classes. Just this last week, students in the developer class that I taught were able to see this functionality demonstrated live.

If you’re already a QuickLearn student, keep following the blog to get the latest bleeding edge information as it becomes available. The series will continue next week!

What’s New In BizTalk Server 2013 R2

This is the first in a series of posts exploring What’s New in BizTalk Server 2013 R2. It will also serve as the index of the series, and contain links to all of the posts to come.


This is a listing of all of the posts within the series:

  1. What’s New In BizTalk Server 2013 R2
    Shows Shared Access Signature (SAS) Authentication for Service Bus
  2. Getting Started with BizTalk Server 2013 R2’s Built-in Health Monitoring
    Demonstrates the installation and use of the BizTalk Health Monitor
  3. JSON Schemas in BizTalk Server 2013 R2 [Code Sample]
    Shows how to generate a JSON schema and write unit tests to validate instances 


We’ve been pretty busy over here at QuickLearn over the past few months, as many of you may have noticed. We’ve released our BizTalk Server 2013 Administrator Deep Dive class, and have been hard at work on our Azure BizTalk Services Fundamentals class (coming as soon as September 2014). Meanwhile, Microsoft has released BizTalk Server 2013 R2.

As a result, I am starting a series in a similar vein as my What’s New in BizTalk Server 2013 series, to uncover those new features in 2013 R2 that will make your life just a little bit easier. However, this time around it will be a weekly series that will occasionally take breaks to share time with posts about Azure BizTalk Services.

All of that having been said, I’m going to get upgraded, and then jump right in to check out one of the things I’m most excited about.

image

I Love Microsoft Azure Service Bus

I’ve got to admit that I’m a huge fan of Microsoft Azure Service Bus. Not only that, but I’m a big fan of the .NET API which really feels oh-so-right and makes allowances for multiple patterns for synchronous vs. asynchronous code.

That being said, a big pain point with Service Bus has been using the Access Control Service for fine-grained security – which really can be the opposite of intuitive – especially when the concept of an identified user isn’t really needed or important to your integration scenario.

Thankfully, ACS isn’t the only security model that Service Bus supports. We actually can also use Shared Access Signatures for authentication. SAS authentication allows you to generate a key for a specific fine-grained entity within Service Bus for which you want to authorize access (e.g., Listen access for a given Queue), and then from that key you can generate a signed token that expires after a period of time. This token need not be borne by a specific user, it need only be presented to be accepted.

While all of that could be filed under mildly interesting, the important thing to note is that unless you have BizTalk Server 2013 R2 installed, you will be limited to using the ACS model for Service Bus authentication and authorization.

SAS-SY SB-Messaging Adapter

Thankfully, after upgrading to BizTalk Server 2013 R2, if you visit the Authentication tab of the SB-Messaging Transport Properties dialog, you will find the following option available:

image

Knowing that you can use Shared Access Signatures is one thing, being able to put that into practice is another. If you haven’t used SAS authentication/authorization before, you’re in for a treat.

Configuring SAS Authentication for Service Bus Entities

If you head over to the Microsoft Azure Management Portal, create some Service Bus entities, and then head to the Configure tab for the same, you will find a section titled Shared Access Policies

image

This section allows you to define access policies (e.g., read-only access, or Listen permission for the queue shown in the screenshot), and then generate signing keys that can be used to generate access tokens granting that level of permission.

image

It’s nice to know that this can all be done through the web UI if needed, but nothing here seems to relate back to the first property that you may have noticed when examining the settings for the SB-Messaging adapter (i.e., the Shared Access Key Name property). In reality, it’s asking for what the UI calls the Policy Name.

So what would the adapter configuration look like for this Shared Access Policy?

image

Putting it to the Test

So let’s put the updated adapter to the test and see what we get out the other end. First, let’s whip up a quick console app that will give us a message that is simply the string “Hello World”

image

Yes, the purists will note that I did not use a MesagingFactory. Why? Because this is not going to be a long-lived client, and it felt nicer to type. However, given a real world example, MessagingFactory will usually be the correct choice.

So let’s run down what I have while that message sits in the queue. I have a one-way Receive Port with a single Receive Location. This Receive Location uses the SB-Messaging adapter pointed at myqueue and using SAS for authentication (per the settings in the screenshot above). I have a Send Port subscribing to all messages from this Receive Port. This Send Port is using the FILE adapter, because I’m writing this late at night and am running out of creativity.

With everything in place, you will see this glorious sight…

image

And opening the file reveals…

image

Am I impressed that this traveled through a Service Bus Queue to arrive on my file system? No. I’m just happy that it authenticated using SAS token along the way, and I didn’t have to touch ACS at all during the process.

One hope that I have for this new functionality, is that it will see people moving beyond using owner for everything. Even though it’s something that I would find myself doing for demonstration purposes, it is also something that made me cringe to see in real life. It’s a lazy and even dangerous thing to do in some cases.

Just a Taste

This is really just a small flavor of what’s to come. There are some pretty big changes that aren’t getting a lot of fanfare at the moment, but I hope that will change as more and more people upgrade and discover what is waiting for them under the covers.

Until next week, take care!

BizTalk Server 2013 R2 Available!

If you have been waiting for BizTalk Server 2013 R2, the wait is over. Although this is not a huge new release, if the new features are of interest to you then it is available for download from MSDN as of today. It has a huge long ugly url which I shortened to help you all out. We haven’t seen the specific numbers but the buzz is that performance is greatly enhanced especially for EDI specifically HL7 scenarios.

http://tinyurl.com/BTS2013R2Download to download the bits, (with an MSDN license of course).

http://tinyurl.com/BTS2013Features for a comparative list of features between BTS 2013 and BTS 2013 R2.

Happy BizTalking!

Guest presenter during Build, Release and Monitor course

During the first run of our new Build, Release and Monitor software with Visual Studio 2013 course this week we had a special guest presenter for the topics of Application Insights and Cloud Load Testing.

A big thanks to Chuck Sterling for providing not only an informative session but an entertaining one as well. I expected nothing else  :)

Charles Sterling

The course was a huge success and will be a regular part of our TFS 2013 schedule. Check when this course is running next.

Here’s a couple of comments from students on this course.

“Excellent instructor. I’m appreciative of the real world stories and helpful tips on additional reading material on MS-Build.” ~ Reza

“Very knowledgeable, very willing to answer questions and explain. Very patient. In many of these online courses, I fight to stay focused but Anthony kept my full attention throughout the course. ” ~ Lana

Student feedback and the 70-496 Exam

As the TFS courseware author and lead ALM trainer for QuickLearn, I work hard to try to make sure our eight TFS 2013 courses are best of breed. Students who attend our training are often doing so not only for the skills and knowledge to help them do their job more efficiently, but quite a few are also attending the course as preparation for the Microsoft ALM Certification.

This morning I opened my inbox to find the following email from a student I had on one of our courses two weeks ago.

To Anthony Borton and the QuickLearn Team

I took exam 70-496 today and passed.  This was due to your excellent coverage of the myriad of detail required for TFS Administration and use.  I recommend your courses to all who wish to be successful with TFS.

Thank you!

Tom Williams

While I am in this profession because of my passion for helping people succeed, getting this feedback is also very rewarding.

Thanks for letting us know how you got on with the exam Tom and congratulations on passing the exam. I hope to see you again when you’re studying for the next exam.

Cheers

Anthony

New Class for BizTalk Administrators Goes Even Deeper than Ever Before

I think I can speak for everyone here at QuickLearn Training when I say that I am proud to announce the upcoming release of our BizTalk Server Administrator Deep Dive course! It has been a long labor of love in which I’ve invested an incredible amount of time including many late nights.

We are coming down the home stretch of development of this course, and I’m so excited that I wanted to share the three things about the course of which I am most proud.

A TRUE TECHNICAL DEEP DIVE

This class is a true deep dive into BizTalk Server technologies. Our primary goal for this class is to teach people how to be the best BizTalk Server administrators by teaching them more than how to do their job; we wanted to teach them how BizTalk Server does its job. I don’t want to reveal too much here but we have many detailed discussions about the internal mechanisms of BizTalk Server which provide greater understanding of why we do the things we do on Planet BizTalk.

This is the thing that makes me most excited for this class; I cannot wait to have these conversations with other experienced and interested BizTalk professionals.

PERFORMANCE TESTING AND TUNING

Everyone knows that performance testing and tuning is important in order to ensure that your BizTalk Server implementation is successful, but sadly there is very little practical guidance showing you how to do it. We spend about three days of the course focusing on running performance tests, identifying performance bottlenecks, and eliminating those bottlenecks. We look at how you can improve performance by changing hardware, reconfiguring network infrastructure, optimizing the underlying Windows Operating System, and other ancillary services. We also walk you through a variety of advanced configuration options for BizTalk Server databases and hosts.

This is where we’ve spent the most amount of time designing the course. I’ve personally spent weeks running performance tests so I can better understand how these changes affect performance and so I can prove to you the impact that a particular optimization might have.

Performance Monitor

ANALYZING THE IMPACT OF THROTTLING

I have one word for you: Throttling. Other than the MessageBox database I cannot think of single component in BizTalk that can have greater impact on performance than throttling. I know it is so clichéd now, but Stan “the man” Lee once said “With great power comes great responsibility”. The sad reality however is that there are so many people who’ve shirked all their responsibility when it comes to throttling.

I have enough faith in my fellow BizTalk professionals to believe that this is not because of carelessness or a general disregard for efficiency but instead stems from a lack of understanding; which isn’t surprising considering the amount of documentation and guidance coming out of Microsoft. We’ve worked hard to create the most comprehensive explanation of throttling including practical information that will finally demystify it forever.

Rate-Based Throttling

CLOSING THOUGHTS

I hope that this small insight into the upcoming BizTalk Server Administrator Deep Dive course has sparked your interest in the course. We are currently in the process of testing labs and editing slides and expect to have the course ready later this summer.

You can expect to see it on our calendar starting in July 2014. It will be offered publicly allowing anyone from anywhere in the world to attend remotely or if you prefer you can attend in-person at our state-of-the-art training facility based in Kirkland, WA.

two new tfs 2013 courses now available

Two exciting new courses added to our TFS 2013 curriculum

QuickLearn Training is expanding its TFS Curriculum with two new courses being added to our range. With both the most up-to-date and comprehensive TFS curriculum, you know you’re in good hands when you book on one of our courses.

Build, Release, and Monitor Software Using Visual Studio 2013

This new 3 day introductory level course is focuses on the following components of Visual Studio 2013;

  • Team Build
  • Release Management for Visual Studio 2013
  • Application Insights

As the title says, if you want to improve the way you build, release and monitor your applications, this is the course for you. Like all of our courses, you can attend this training on our public schedule or we can run it onsite for you.

Download full outline (PDF) | View TFS 2013 course dates

Applied Scrum Using Visual Studio 2013

Achieving success in your software development projects requires understanding of both your development tools and processes. This 3 day course aims to help address both of these by teaching you the Scrum Framework and how to apply it using the Visual Studio 2013 product at the same time. This course is ideal for getting your entire team pointing in the same direction and using Visual Studio as effectively as possible. Bring us onsite now to deliver this exciting new course.

Download full outline (PDF) | View TFS 2013 course dates

See us and win at the ALM Forum Seattle 2014

QuickLearn is committed to the ALM community and have signed up as Gold Sponsors for the upcoming ALM Forum Seattle 2014.

ALMForum

BEFORE THE EVENT – WIN A FREE TICKET

You can win a free ticket (valued at $ 1,895) to the ALM Forum Seattle on 1st-3rd April 2014. We have two free tickets to give away to lucky readers of our newsletter. We’ll be announcing details on how to enter the draw in our newsletter. If you’re not a subscriber, you can sign up from our community page.

AT THE EVENT

Come and see us at our booth and learn about the world’s most comprehensive TFS training curriculum. We’ll have two of our TFS trainers available to discuss your training requirements. You can also go into the draw from some great prizes including the Lenovo 64Gb Thinkpad 8 Tablet. This amazing device was a true standout at the CES conference in Las Vegas earlier this year!

WinLenovo8Tablet

Our new TFS 2013 training curriculum kicks off on Jan 27th

Since the official release of Visual Studio Team Foundation Server 2013 in November we’ve been testing our newest course updates and we’re pleased to be launching our new 2013 courses at the end of this month.

If you either working with, or thinking of working with Microsoft’s latest release then you should take a look at the following courses.

  • Jan 27-29  TFS 2013 Configuration and Administration
  • Jan 30-31  TFS 2013 Developer Fundamentals
  • Feb 3-7  ALM Solutions using Visual Studio TFS 2013
  • Feb 10-11  Managing Projects with Visual Studio TFS 2013
  • Feb 12-14  Software Testing with Visual Studio 2013

You can find out more and register for these course on our dedicated TFS 2013 page.

We’re also planning on releasing an additional three TFS 2013 related courses in the coming months.