Visual Studio 2015 Product Lineup available with Versions and changes

The Marketing Team of VS has announcing the editions of Visual Studio 2015 that will be available when we release the final product this summer.

Focus is to improve upon the power and productivity of Visual Studio, making it easier to use, no matter what platform you’re on, no matter what app you’re building and make it easier for you to choose which edition of Visual Studio is the right one for you.

More value will deliver bringing Visual Studio Premium and Visual Studio Ultimate into one single offering called Visual Studio Enterprise with MSDN. It includes all the high value features you’re already familiar with in Visual Studio Ultimate, along with new innovation that’s coming with the 2015 release. So, in addition to Visual Studio Community and Visual Studio Professional with MSDN, our new Visual Studio Enterprise with MSDN rounds out the three primary Visual Studio 2015 offerings.

Visual Studio 2015 Product Offerings

The Visual Studio Professional, Team Foundation Server, Team Foundation Server Express, Visual Studio Express and MSDN Platforms will be continued to offer as a part of the complete Visual Studio 2015 and MSDN portfolio.

Getting Visual Studio 2015

Customers who have an active subscription for Visual Studio Premium with MSDN or Visual Studio Ultimate with MSDN will automatically get upgraded to Visual Studio Enterprise with MSDN. And the pricing of Visual Studio Enterprise with MSDN will be significantly less than the current price of Visual Studio Ultimate with MSDN. Check out the Visual Studio 2015 Product Editions for detailed feature and pricing information, including the current promotions ,so you can get the most value out of Visual Studio today.

Also if you haven’t tried it yet, download Visual Studio 2015 CTP 6 to test out the new features and send feedback through the usual channels (UserVoice, Send-a-Smile, or Connect).

Here is an Feature comparison between the VS 2013 Versions

https://www.visualstudio.com/en-us/products/compare-visual-studio-products-vs.aspx

Advertisements

New Features in Visual Studio 2015

Few weeks ago The product Team has presented What’s new in VS2015 CTP6 , so here are big part of the changes

Other changes:

Related releases:

Other changes:

CTP 6

UI debugging tools for XAML

Are  added two new tools—the Live Visual Tree and the Live Property Explorer—that you can use to inspect the visual tree of your running WPF application, as well as the properties on any element in the tree. In short, these tools will allow you to select any element in your running app and show the final, computed and rendered properties. Here’s more:

  • Live Visual Tree. Now, you can view the full visual tree of a running application during a debug session. The Live Visual Tree is available when you press F5 in Visual Studio or attach to a running application. You can use the Live Visual Tree to select elements in a running application for inspection in the Live Property Explorer. Descendant count is displayed, and if the source information is available, you can instantly find the file and location of the element’s definition.
  • Live Property Explorer. Use this new tool to inspect the properties set on any element in a running application, grouped by the scope in which they are set. You can modify these properties during a debugging session and immediately see their changes in the running application.

Picking apart how properties override each other and figuring out winning behavior can prove difficult at design time. Now, by using our new UI debugging tools for XAML, you can perform these inspections at runtime, when you can take everything into account.

(Support for Windows Store apps will be released in a future update.)

UI Debugging Tools for XAML, full screen

Single sign-in

You, like many other developers today, take advantage of multiple cloud services when developing your applications. For example, you’ve probably added a cloud backend to your applications to store data, stored your source code in the cloud, or published an application to a store.

In the past, each of these services required a separate sign-in process, and each service managed the signed-in user state separately.

With this release, we are reducing the authentication prompts required to access many integrated cloud services in Visual Studio. Now, when you authenticate to the first cloud service in Visual Studio, we will automatically sign you in, or reduce the authentication prompts for other integrated cloud services.

CodeLens

With CodeLens, you can find out more about your code while staying focused on your work in the editor. In CTP 6, you can now see the history of your C++, SQL, or JavaScript files versioned in Git repositories by using CodeLens file-level indicators. When working with source control in Git and work items in TFS, you can also can get information about the work items associated with C++, SQL, or JavaScript files by using CodeLens file-level work items indicators.

CodeLens file level team indicators
Learn more about Code Lens.

Code Maps

When you want to understand specific dependencies in your code, visualize them by creating Code Maps. You can then navigate these relationships by using the map, which appears next to your code. This helps you track your place in the code while you work.

  • Performance improvements. With this release, now you can get reactive Code Maps more quickly: drag and drop operations produce an immediate result, and the links between nodes are created much more quickly, without affecting subsequent user-initiated operations such as expanding a node or requesting more nodes. When you create Code Maps without building the solution, all the corner cases—such as when assemblies are not built—are now processed.
  • Code Map filtering. Now you can quickly unclutter your Code Maps by filtering for nodes and groups. You can show or hide code elements on a map based on their category, as well as group code elements by solution folders, assemblies, namespaces, project folders, and types.
  • Dependency links. Dependency links no longer represent the inheritance from System.Object, System.ValueType, System.Enum, and System.Delegate, which makes it easier to see external dependencies in your code map.
  • Improved top-down diagrams. For a medium to large Visual Studio solutions, you can now use a simplified Architecture menu to get a more useful Code Map for your solution. The assemblies of your solution are grouped alongside the solution folders, so you can see them in context and leverage the effort you’ve put in structuring the solution. you’ll immediately see project and assembly references, and then the link types appear. Also, the assemblies external to your solution are grouped in a more compact way.
  • Improved link filtering. Link filtering now applies to cross group links, which makes working with the filter window less intrusive than it was in previous releases.

Learn more about Code Maps.

Diagnostics Tools

In CTP 6, the Diagnostic Tools debugger window has the following improvements:

  • Supports 64-bit Windows Store apps
  • The timeline zooms as necessary so the most recent break event is always visible
Exception Settings

You can configure debugger exception settings by using the Exception Settings tool window. The new window is non-modal and includes improved performance, search, and filter capabilities.

Exceptions Settings - Break when Thrown window

JavaScript Editor
  • Task List support. You can use the Task List feature to review task comments, such as // TODO, in your JavaScript code. Learn more about the Task List in Visual Studio.
  • Object literal IntelliSense. The JavaScript editor now provides you with IntelliSense suggestions when passing an object literal to functions documented using JSDoc.
Unit Tests

In Visual Studio 2015 preview, we introduced Smart Unit Tests, which explores your .NET code to generate test data and a suite of unit tests. In CTP 6,are added the following functionality:

  • Parameterized Unit Tests. Smart Unit Tests enables support for an API that you can use to guide test data generation, specify correctness properties of the code under test, and direct the exploration of the code under test. This API is available in the Microsoft.Pex.Framework namespace and can be used in the test methods (parameterized unit tests, factory methods) generated by Smart Unit Tests. Consequently, the “Smart Unit Tests” context menu command is now available from the generated test methods as well.
  • Test stubs creation. “Create Unit Tests” is now available on the context menu as a command that provides the ability to create and configure a test project, a test class, and a test stub.

Learn more about Smart Unit Tests.

Visual Studio Emulator for Android

In CTP 6, the Visual Studio Emulator for Android now supports the following:

  • OpenGL ES
  • Android Version 5.0 (Lollipop, API Level 21)
  • Camera interaction using image files or your webcam
  • Multi-touch input
Visual Studio Tools for Apache Cordova

Over the last few releases, we listened to your feedback and broadened the number of devices you can debug to, as follows:

  • Android 4.4, Android 4.3 and earlier with jsHybugger
  • iOS 6, 7, and 8
  • Windows Store 8.1

With CTP6, we are broadening our debugging support further. You can now debug your Apache Cordova apps that target Windows Phone 8.1

You can set breakpoints, inspect variables, use the console, and perform other debugging tasks on your Windows Phone 8.1 emulator or attached device.
Debugging with Visual Studio Tools for Apache Cordova
Learn more about the Visual Studio Tools for Apache Cordova.

Visual Studio C++ for Cross-Platform Mobile Development

You can use Visual Studio to share, reuse, build, deploy, and debug your cross-platform mobile code, all within a single solution. And in CTP 6, also added or updated the following:

  • Support for Android API Level 21 (Lollipop).
  • Improvements to Android Logcat. (Logcat is a diagnostic tool and essential for a good edit->build->debug experience.)
    Use Logcat to do the following:
    • Search for specific log messages by using search bar.
    • Use Toggle Autoscroll to view upcoming log messages easily.
    • Clear previous log output messages.
    • Choose between various log levels.
  • A new template that is based on make file support for Android, which allows using an external build system (including NDK-BUILD).
  • Precompiled headers in all templates (including Dynamic Shared Library, Static Library, and Cross-platform mobile templates).
ASP.NET

In this CTP 6 release, are added the following new features and performance improvements:

  • Run and debug settings are now stored in debugSetting.json, which can be customized to configure how the project is started.
  • Add reference to a system assembly.
  • Improved IntelliSense while editing project.json.
  • New Web API template.
  • Improvements to call out ASP.NET 4.6/ASP.NET 5 on the New ASP.NET Project (One ASP.NET) dialog.
  • Ability to use a Windows PowerShell script which can be customized for the web publish experience for ASP.NET 5.
  • You can use Lambda expressions in the debugger watch windows for ASP.NET 5 applications when running on the Desktop CLR.

Learn more about ASP.NET 5 updates in Visual Studio 2015 CTP 6.

Visual C++

Are added the following new features to Visual C++ in CTP 6:

  • Control Flow Guard (CFG). With this new security feature, simply add a new option to your project, and the Visual C++ compiler will now inject extra security checks into your binaries to help detect attempts to hijack your code. When the check fires, it will stop execution of your code before a hijacker can do damage to your data or PC. Learn more about Control Flow Guard.
    Note: We have updated the command options. Instead of using the /d2guard4 switch as you did in CTP 5, you should now use /guard:cf in CTP 6.
  • Typename keyword. Users can now write typename instead of class in a template template parameter. Learn more about  typename.
Related releases

For additional features of Visual Studio 2015, see our Preview release notes.

CTP 5

XAML Language Service

The XAML language service is rebuild on top of .NET Compiler Platform (“Roslyn”) so that we can provide you with a fast, reliable, and modern XAML editing experience that includes IntelliSense.

This makes the XAML authoring experience equal to other first-class languages in Visual Studio. We’ll also be able to deliver powerful feature sets around cross-language refactoring to you at a much faster cadence.

Timeline Tool

Our new Timeline tool in CTP 5 provides you with a scenario-centric view of the resources that your applications consume, which you can use to inspect, diagnose, and improve the performance of your WPF and Windows Store 8.1 applications.

The Timeline tool, which is in the Performance and Diagnostics hub, shows you how much time your application spends in preparing UI frames and in servicing networks and disk requests, and it does so in the context of scenarios such as Application Load and Page Load.

The new Timeline tool
Learn more about the new Timeline Tool in Visual Studio 2015.  (The new Timeline tool replaces the XAML UI Responsiveness tool.)

Diagnostics Tools

Are added a new Diagnostic Tools window in CTP 5 that appears when you start debugging (press F5). The Diagnostics Tools window contains the following features:

  • Debugger Events (with IntelliTrace)
    Debugger Events (with IntelliTrace) gives you access to all Break, Output, and IntelliTrace events collected during your debugging session. The data is presented both as a timeline and as a tabular view. The two views are synchronized and can interact with each other.
    Learn more about IntelliTrace in Visual Studio 2015.
  • Memory Usage
    The Memory Usage tool allows you to monitor the memory usage of your app while you are debugging. You can also take and compare detailed snapshots of native and managed memory to analyze the cause of memory growth and memory leaks.
  • CPU Usage
    The CPU Usage tool allows you to monitor the CPU usage of your application while you are debugging.
    (This tool replaces the CPU time PerfTip that was available in the Preview release of Visual Studio 2015.)

The Diagnostics Tools window supports the following project types and debugging configurations:

  • Managed WPF, WinForms, and Console projects
  • Native Win32, Console, and MFC projects
  • ASP.NET 4 using IIS express only
    (ASP.NET 5 and IIS are not supported at this time)
  • Managed or Native 32-bit Windows Store projects running locally
    (Windows Store projects that are 64-bit, using JavaScript, running on a remote device, or running on a phone are not supported at this time)

Learn more about the Diagnostics Tools window in Visual Studio 2015.

ASP.NET

In this CTP 5 release, we’ve added some new features to the ASP.NET 5 experience, as well as improved its performance.

  • Now, you can add a reference to a standard C# project.
    (In previous releases, the Add Reference dialog only supported referencing other ASP.NET 5 projects.)
  • We’ve added IntelliSense and validation to our HTML, CSS, and JavaScript editors.
  • We’ve improved our support of client-side task runners (such as Grunt and Gulp) that run alongside the Task Runner Explorer.
  • For ASP.NET 5 projects, you can select the browser you want while running or debugging a project.
    Select the browser you want
  • You can define custom commands in project.json file, which you can launch by using the ASP.NET 5 command-line tools. And now, you can also run and debug your custom commands directly in Visual Studio 2015.
  • Are updated our ASP.NET 5 templates to include a project.json file that uses the latest packages, and  fixed some bugs in the template content.

Learn more about ASP.NET updates in Visual Studio 2015.

Visual C++

In CTP 5,  added the following new features to Visual C++ to bring the compiler closer to conformance with the standards set in Visual Studio 2012 and Visual Studio 2013.

  • Digit separators: Now, you can intersperse numerical literals with single quotes to make them more readable. For example,int x = 1’000’000;
  • Universal character names in literals: You can now write basic characters, like ‘A’ and the line feed character, as code points in literals. For example, const char *s = “\u0041\u000A”;

Microsoft IOT – Internet of Thing has an Dev. Program

 

image
About the Windows Developer Program for IoT

Designed for developers

This is the first in a series of Internet of Things (IoT) programs for the creation of connected devices.  This program is tailor-made for both makers and Windows developers entering into the IoT space.

Rapid hardware development

The accessibility of Arduino combined with the connectivity of Windows.  Quickly iterate and expand on hardware and software designs using existing shields and sketches.

Windows platform with Visual Studio

Leverage the Windows platform and its diverse hardware ecosystem. Utilize familiar Win32 programming using best in-class development and debugging tools.

Open community

Connect with your fellow developers and share code contributions through GIT. Participate and influence subsequent releases of the SDK.

Start building

LearnMakeExploreConnect

Learn

Learn how you can make great connected things and contribute back to the community.

Make

Set up your Galileo board and get your project rolling.

Explore

Find a sensor, look at samples, or check out the project the community is building.

Connect

If you’re not already a part of the program, sign up here.

Community resources
Wiring for Windows

Visit the Github repository for our open source implementation of the Arduino API set on Windows.

Stack Overflow: Q&A

Post questions and see responses about this Developer Program on Stack Overflow.

Wiring API

Visit Wiring.org to find a description of the elements that constitute the Wiring framework.

Follow us on Twitter

Follow the #winbuilder hashtag on Twitter.

MSDN: forum

Post questions and see responses about the Developer Program on the MSDN forums.

IRC channel

Listen in or contribute to the live community chat.

Report bugs

Review or submit bugs for Microsoft and the community at our Microsoft Connect site.

YouTube channel

WPF Prism Composition Library goes Open Source

For seven years since the Prism project started, led by the patterns & practices team, was originally known as the Composite Application Library. Last year was the 5th official release of Prism. The two major focuses of that release were: compos ability and ease of community contribution.

From the beginning, Prism has had a strong community focus. This hasn’t simply been a matter of surveys and user studies, but frequent discussions and regular code reviews with community members and industry experts. Now it’s time to take Prism to the next level.

Ownership of Prism projects is transferred to community members.

  • Brian Lagunas. Brian is a Microsoft MVP whose involvement in the project started with Prism 2. .
  • Ariel Ben Horesh. Ariel has been involved with Prism since its first release.
  • Brian Noyes. Brian is also a Microsoft MVP and has also been involved with Prism since its inception.

There is a strong continuity for the project since the new owners have been significant contributors since the beginning. As part of this hand-off, the projects will be consolidated in the PrismLibrary org on GitHub. Likewise, discussions are underway about bringing Prism into the .NET Foundation. This change of ownership means that future releases of Prism will be developed by the new team, not by Microsoft.

The Prism team’s plans on their Roadmap

The idea is to improve an already mature product with new features and to support new platforms (can you say Windows 10?).  Already have a number of items that we will be addressing in the next version of Prism.  Here is a highlight of some of them.

  • Remove the dependency of Prism.PubSubEvents from Prism.Composition
  • Remove all deprecated classes and properties
  • Fix that annoying namespace bug with Prism.Mvvm
  • Fix that annoying bug with the ViewModelLocator design time exception. (We will remove the need of IView altogether)
  • Add CallermemberName attribute to BindableBase.OnPropertyChanged

Besides these small feature improvements, we will also be looking at restructuring the Prism solution to make a more cohesive product, reduce dependencies, and to better support cross platform development; such as iOS and Android using Xamarin.Forms.  You can expect a number of breaking changes in the Prism 6 release as we take Prism in this new direction.

. We’re excited about Prism’s future.

Software Development Practices vs Rugby

You may ask, what’s the link between such an terms in one or another discipline, here is short description.

And another example that Abstract Processes can be used in any industry /discipline is Brian Harry, that is managing his Farm in free time using Team Foundation Server and Scrum.

                                         Rugby                                    Agile Software Development

 

 

 

Spectators

As a rugby spectator, sometimes it’s hard to see the ball. You may also not be entirely sure what’s going on and it looks like complete chaos. You watch the rucks and mauls to determine where the ball is going, but you know by looking at the scoreboard if the team is scoring try’s or not.

Those who are watching Agile teams without being involved may not understand exactly how it’s happening, but observers will see Agile teams score points by delivering business value in a short amount of time.

What’s going on?

Yeah, Rugby looks like chaos to the newcomer, but there are many laws. Players are making split second decisions and well-played games move very quickly.

Agile critics say there is a lack of structure or documentation. The structure exists and the process is defined, but it Agile doesn’t need the rigidity of Waterfall because by its nature, it is allowed to be flexible and respond to the changing needs of the business.

What is a Scrum?

Scrum: 5 or 8 players who act as a tightly cohesive unit that pushes together in same direction in order to put the ball into play.

The Scrum team: a collaborative, intimate team that is delivering business value in a tightly coordinated fashion.

The Scrum Half or the Scrum Master

The Scrum Half (#9) directs traffic between the forwards in the scrum, rucks, or mauls, and back line.

The Scrum Master coaches and coordinates between the team members to foster communication and collaboration.

The Referee

The Referee is meant to be an impartial witness of the match and blows the whistle for the infractions made by the teams. As Billy Tilson puts it: “If a referee called every infringement then the game would be a painfully slow and static. Good referees try to lead the participants to a good balance for optimumvelocity.” I’ve also witnessed referees stop the match to provide a bit of coaching and guidance to new players.

In addition to the above analogy, a Scrum Master will let the team know when they’ve stepped out of bounds from the methodology and tell them what consequences may follow. An excellent Scrum Master will not be involved in the work and serves to “referee” by asking the team about what they can and can’t do. Scrum Masters will guide a team towards what works for them so that the team can become more efficient. A Scrum Master also has to allow a team to fail, so that they can learn from the experience.

The Team Member

As a rugby player, you fulfill certain duties according to what’s being called for at a specific point in time, based on your current location on the pitch. You do whatever is needed. It’s never about one person being the star; It’s about the whole team. In certain plays, anywhere from two to five people will cooperate to make advancements down the field.

Agile Teams thrive when they are cross-functional, with a variety of skills and expertise. In a team of about seven people, the commitment to seeing the whole team do well is driven by the fact that team members get the job done according to what is needed at a given moment regardless of what job title any one person has.

Owners and Managers

Owners and Managers of any sports team provide the tools, resources, sponsorship, funding coaching, and cheerleading needed by teams. Owners set the goals (to win), and Managers help them get there.

The Product Owner and Agile Manager are two roles supporting Agile Teams. The Product Owner helps sets priorities and is the voice of the organization to the team. The Agile Manager supports those team members and embraces the methodology and supports the efforts within the organization.

Self-Organizing Teamwork

As a player, you don’t carry the ball the whole time, and you can’t be a play maker all the time. There’s a place and time for demonstrating leadership and a time to be in support, or pass the ball.

Rugby players on the pitch will read the play happening before them and will act appropriately, be it to go into the ruck or fall into the backline.

Agile team members never carry the workload alone. The Scrum Master isn’t the leader of the team, but should strive to be an aide to the team. The work involved in building software is estimated, built, and tested as a team and no one team member will be the hero for a givenstory.

Empowered agile teams are not told how to do their work. They are self-organizing and determine what needs to be done, when, and how.

Speed – Faster Results

The better a team is, the faster they play.

The better a team is, the faster they begin to deliver business value; team velocity will increase over time.

Sprints and Iterations

Offensive open rugby play repeats itself through phase after phase of play. The ruck or maul is created, the ball is retained, and the ball is carried forward for the next phase. The ruck or maul is set, again. Some phases are longer than others. The end goal is to make a try.

Within a fixed amount of time, the team will plan, work, and review on a regular basis. The cyclical nature of the development is best captured in this diagram.

Commitment, Respect, Focus, Openness, and Courage

Watch some inspiring movieabout a sports team and you’ll see the values that tend to exist are those of commitment to one another, respect for the work that goes into being a player, focus on the sport and while playing, openness to grow, and courage to overcome obstacles as a team or individual.

These are the values present in high performing Agile teams. Commitment to deliver as a team, respect of everyone’s capabilities, focus on the highest priority stories, openness to discuss approaches and techniques, and the courage to push back when necessary.

Growth for the individual and for the team

I earnestly believe that joining James River Women’s rugby helped me grow as an individual and develop my leadership skills for the team on and off the pitch. As an inaugural member of the team, I have watched that team grow and change. All rugby teams go through growth to learn and improve, be it within a match or over the course of a season.

In my path to being a Certified Scrum Master, I found that I had to challenge my ways of thinking about software development that have helped me grow as an IT professional. It’s not just another certification, but a transformed way of thinking about building teams, and even life in general. Just ask Lyssa Adkins.

The Fans

They are avid fanatics who will paint their faces, adorn themselves in team colors and probably used to play at one point in their lives.

They are avid fanatics who passionately believe in different ways to deliver value to a business and empowering software teams, not just building software on time, on budget, and within scope.

Free Visual Studio 2013 Community Edition and difference with Express Editions

First of all, both are free!  Visual Studio Community Edition is newly released today.

Are two main differences between Visual Studio 2013 Community Edition and the Express Editions

1) Visual Studio Express Editions are targeting specific platforms:  Express for Web allows you to develop Web apps;  Express for Windows allows you to develop Windows apps; Express for Windows Desktop allows you to develop desktop apps.  But with Visual Studio Community Edition, you can develop projects targeting cross-platforms.

2) Visual Studio Express Editions do not allow users to use extensions (aka. plugins).  There are over 5000 great plugins for Visual Studio in Visual Studio Gallery.  Plugins such as Developer Assistant can boost developers’ productivity.  Unfortunately, they are not available to Visual Studio Express users.   With Visual Studio Community Edition, you can access and use All !

Visual Studio Community Edition may retire Visual Studio Express Editions in future, but this is not decided yet.

How to Use TFS with Scaled Agile Framework

Using Team Foundation Server , Visual Studio,  to increase productivity and transparency into your application as well as increase the rate at which you can ship high quality software throughout the application lifecycle.

In the Following whitepaper is described How-TO: Using TFS to support epics, release trains, and multiple backlogs.

The Scaled Agile Framework, or SAFe, is  popular among organizations looking to scale Agile practices to the enterprise level. SAFe is a comprehensive framework, covering practices from portfolio level planning to release planning to coding practices.

While TFS does not provide full support for all SAFe practices, TFS can be used to implement many of the planning practices. This whitepaper also provides practical guidance on how to implement SAFe practices using TFS. It covers the following topics:

ALM_SAF_Overview1-4_Opt

The first two sections are conceptual and provide a quick overview of how TFS supports SAFe.The last two sections are guidance and provide detailed steps for the TFS Administrator to configure and customize TFS to support SAFe.

Mapping SAFe concepts to TFS concepts

  SAFe supports a portfolio view of multiple agile teams. SAFe illustrates how a portfolio vision is met by a hierarchy of teams, all of whom have their own specific objectives. This framework breaks down Epics into Features and Stories, which teams work on in Sprints and deliver through Program Increments (PIs) and Release Trains. Also, the portfolio backlog can track how deliverables map to Strategic Themes and associated budgets.

SAFe architectural overview © D. Leffing..

Image courtesy of Leffingwell, LLC.

The examples in this paper illustrate how to add the Epic WIT and backlog, configure a three-level team hierarchy, and map teams to their respective area and iteration paths. The examples build from the TFS Agile process template. However, the changes can be applied to any TFS process template.

TFS structure to support SAFe

SAFe Portfolios, Programs, and Teams map to TFS team projects and teams

Because TFS supports a hierarchical team structure, each team has its own view of their work which rolls up to the next level within the team hierarchy.

SAFe roles to TFS teams

image

In the section, “Customize TFS process to support SAFe”, details the changes to our Scrum, Agile, and CMMI process templates which enable SAFe support. The goal is not to create a SAFe Process Template, but modify existing process templates to enable SAFe practices. This changes are minimal and don’t encumber teams who choose not to use SAFe.

Now, you have the following options to update the templates to include these changes :

  1. You can download the standard Scrum, Agile, CMMI process templates with changes for SAFe here.
  2. If you have customized process templates, you can follow the instructions in the guidance. Additionally, in this blog post shows how to automate the process with PowerShell.

This whitepaper assumes a familiarity with the Scaled Agile Framework. If you’re familiar with Scrum but not familiar with SAFe, Inbar Oren has published these great videos which explain the basic SAFe concepts quickly.

Have fun with the process!

Building Multi Device applications with C++ and Visual Studio

Here are some trough’s about consuming a C++ library project from a Windows Phone Store app using a separate intermediary WinRT component. All this steps can equally be applied to a Windows Store app and therefore a solution that utilizes the Universal App template. 

Building a Windows Phone Store app, are occasions when you wish to consume logic within a library that you have previously written in C++. In order to consume this logic in a Windows Phone Store app you need to wrap that C++ logic using a WinRT component. 

WinRT component acts as a wrapper around the C++ code and is a means of projecting the correct types across the Abstract Binary Interface (such that it may be consumed in languages other than C++). There is documentation and sample code demonstrating how to achieve this, but they tend to show the C++ logic inside of the WinRT component. In the real-world, you will likely have the C++ code in a separate project and therefore you need to reference this from the WinRT component. This scenario is not well documented and so it is the objective of this article to walk through how you can go about setting this up.

Before getting started, the diagram in Figure 1 shows the projects that are, or will be involved.

Figure 1

First on the left you have the “DemoApp.WindowsPhone” project, which contains the application’s user interface. On the right you have the “DemoWin32Project”, which contains the C++ logic that you wish to call. In this example, the project is assumed to be a Win32 DLL project type. The grey box in the middle of the diagram represents the C++ WinRT component that wraps the calls to the Win32 DLL project. Assumes that you already have the components in blue already at your disposal, whilst the component in grey needs to be created.

First step is going to be to create the C++ WinRT component. You can do this by adding a new project to the solution and selecting the appropriate project type as demonstrated in following  Figure . For the purposes of this example, the project type will be “Windows Runtime Component (Windows Phone) – Visual C++” (highlighted in green) as the application calling it is a Windows Phone Store app. If this was a Windows Store app or a Universal app, then you would instead need to select the appropriate project type shown in amber.

Figure 2

When you have created the component, you can add a project reference to it from the application project (in this case “DemoApp.WindowsPhone”). This is shown in following Figure .

Figure 3

As the application project is going to be referencing C++ code, it is also important to add a reference to the Visual C++ runtime as shown in above Figure.

Figure 4

Add reference to Visual C++ runtime

The actual code logic that sits inside of these projects will not be discussed here as they are largely irrelevant.

At this point, you will want to add a reference from the Windows Runtime Component to the Win32 DLL project. It is this step that is not so well documented. Unfortunately there is a little bit of extra work to do here to get this working, although it is extremely straightforward once you know how.

First Figure implies that the C++ component is a Win32 Project type. This is intentional as it is likely the project type your existing code sits inside of – however, in order to be able to reference this logic, the code needs to sit inside of a subtly different project type. The next step is to create that other project type, which in this example will be “DLL (Windows Phone) – Visual C++” – highlighted in green in following Figure . If this was a Windows Store app or a Universal app, then you would instead need to select the appropriate project type shown in amber.

Figure 5

Creating the appropriate DLL project type

When  this is done, you need to either move across the C++ source files from your Win32 DLL project, or add a link to their existing location – either way, this entails just a few manual steps depending on how many source files you have. Finally, you will need to make sure you are referencing the appropriate header files in the DLL project from the Windows Runtime Component project so that you can code against the DLL. Following Figure  shows the configuration that needs to be applied in green.

Figure 6

Add ‘Include Directories’ to point to appropriate .h files

Now that these steps have been completed, you are in good shape for referencing the DLL project from the Windows Runtime Component project. Simply, go to the project properties of the Windows Runtime Component and navigate to “Common Properties” -> “References”. In this dialog you can point to the project created in above Figure  as demonstrated in following Figure .

It is worth pointing out that you can’t simply reference any and every Win32 DLL project as there is only a subset of Win32 APIs that are supported inside of a Windows Runtime project.

Figure 7

Add a reference to the newly created DLL project type

At this point, you have created the chain shown in first Figure – in other words, the application code on the left-hand side of the diagram may now call into the C++ logic held by the DLL project type by means of the Windows Runtime Component.

These steps may be followed for either a Universal App template or a Windows Store app as appropriate. Furthermore, Visual Studio allows you to right-click each the projects represented by the first two boxes in first Figure and select “Add Windows 8.1” to automatically create the Universal App project structure. This can also be performed on the project created in above Figure  which essentially gives the solution structure represented in following Figure .

Figure 8

Universal App calling a C++ library

Just only step that remain is to update the reference to point to the correct platform implementation as illustrated by the arrows in the diagram.