TrustArc Webinar - Stay Ahead of US State Data Privacy Law Developments
Visual Studio Application Lifecycle Managment end-to-end
1. Regional Technology Solution Professional
Microsoft Visual Studio ALM Ranger
Microsoft Middle East & Africa
@HosamKamel
http://blogs.msdn.com/HKamel
2.
3.
4.
5. Business needs are not met
Solution is not able to change based on business needs
Processes cannot keep up with the pace of change
Poor customer satisfaction
* Source: Standish Group, 2006 Third Quarter Research Report, CHAOS Research Results
6. Custom development is expensive
Tooling and Licensing to support the process is expensive
Poor or confusing processes leads to inefficiency
Lack of project status visibility leads to waste
12. Business case Project Portfolio Application Portfolio Application removed
development Management (PPM) Management (APM) from service
Project
approved
Governance
Development
Operations
13. Aspects of ALM: Development
SDLC, v1 SDLC, v2
Maintenance
Governance
Development
Operations
14. Iteration 1 Iteration 2 Iteration N
...
SDLC
ALM
15. Deploy the Monitor the application
application
Deploy application
updates
Governance
Development
Operations
16. People Process
Clear process guidance
Familiar, flexible and Compliance and risk management
productive tools Supports structured and
Project and Process Management semi-structured processes
Technology
Flexible Secure
Scalable Manageable
Interoperable
17.
18. 1970s-1980s 1980s-1990s 1990s-2000s
Editors
Integrated
development
environments (IDEs)
Compilers
Team development
tools
Build tools
Version control tools
Testing tools
Reporting and tracking tools
19. Development
Tools
Architecture Testing
Tools Tools
Design
Documents
Version Test Cases
Control/
Build Mgmt
Requirements Project
Statistics
Reporting and
Requirements Shared Server Tracking Tools
Tools Microsoft Team Foundation Server
20. Requirement X
Development
Task Test Case
Architecture Testing Task Test Case
Bug
Shared Server Task Test Case
Bug
Test Case
Requirements Project Tracking
21.
22. Are we making progress How are our builds
on running test plans? doing over time?
What’s the quality
Are we fixing
of our bug fixes?
bugs?
Microsoft Confidential
23. Eclipse IDE
Visual Studio Visual Studio
Visual Studio Team Explorer Team Explorer
2010 IDE 2010 Everywhere 2010
Expression
Studio
Visual Studio Microsoft Test
Web Browser Team Foundation Manager 2010
SharePoint Server 2010
Microsoft
Excel Visual Studio Lab
Management
Microsoft 2010
Project Visual Studio 2010
Other Microsoft
Other Vendors
and Open Source
24. Visual Studio Microsoft Test Test & Lab System Center System Center
Microsoft EPM Operations Configuration
2010 IDE Manager Management
Manager Manager
Microsoft
Project System Center
Service Manager
Microsoft Excel Visual Studio Team
Foundation Server
(TFS) Configuration
SharePoint Management
Database (CMDB)
25. Visual Studio
Team Foundation Server 2010
Work Item Version Test Case
Tracking Control Management
• Requirements/
User stories
• Tasks
TT TT
• Bugs TT TT
• Test cases
•…
Reports and Build Lab
Dashboards Management Management
Process VM
Templates
26. Development Roles and Responsibilities
Project Managers Business Analysts
Project Planning Requirements Management
Task Assignment QoS Management
Bug Tracking Requirements Analysis
Development Execs
Portfolio Management
Project Organization Architects
Stakeholder Communication
Architecture Modeling
Analysis and Design
Design for Deployment
Operations
Customer Support
Infrastructure Architecture Designers
Infrastructure Deployment UI Design
UI Prototyping
UI Flow Modeling
Testers
Test Case Management Developers DBAs
Manual Testing Code Analysis Database Design
Load Testing Unit Testing Database Source Control
Automated Testing Version Control Database Test Data Gen
27.
28. Plan and Process
Work Item
Manage Your Tracking
Guidance &
Project Automation
Understand
Version Branch Build
Parallel Control Visualization Management
Development
No More “No Microsoft
Test Case Lab
IntelliTrace Test Manager
Repro” Bugs Management Management
(MTM)
Report on
Dashboards Reports
Your Portfolio
32. MSF for Agile Software Development v5.0
• Product planning based on user stories and story points
• Team progresses most work by moving from active to resolved to closed
• Team is not usually required to support rigorous audits
MSF for CMMI Process Improvement v5.0
• Product planning based on requirements and change requests
• Team progresses most work by moving from proposed to active to resolved to closed
• Team is required to maintain rigorous audit trails
• Team is working toward CMMI appraisal
Visual Studio Scrum v1.0
• Development lifecycle follows Scrum framework (based on Agile principles)
MSF = Microsoft Solutions Framework
CMMI = Capability Maturity Model Integration
33. Change your process to fit the business needs
• Baseline • Develop with
Process the process
Configuration
and integrate it
Plan Do
Act Check
• Update the • Run reports and
process compare
improvements
to the baseline
70. Client side
copy of source Owned by one
checked out user on one
from machine
repository
Changes in Workspace
workspace Mapping =
create Repository
“pending folder mapped
changes” to Local Folder
71. Branch
• A branch relationship is created in TFS to avoid duplication of history and
metadata
• Path-space branching
• Intelligent copies
Merge
• Sync a branch into another
• Cherry Picking changesets (include or omit)
• Ability to show changes that have not been merged
72. 1.0 1.1 1.2 2.0 3.0 3.1
Release Minor bug Bug release Larger new Production
release version release
73. Branch
• A branch relationship is created in TFS to avoid duplication of history and
metadata
• Path-space branching
• Intelligent copies
Merge
• Sync a branch into another
• Cherry Picking changesets (include or omit)
• Ability to show changes that have not been merged
77. Extension of MS Build • Integrated Windows Workflow
• Continuous Integration
Several scenarios • Scheduled
supported • Gated / Shelveset
• Ad-hoc
Provides build reporting • Pass / Fail
back to TFS • Trend data
Integrated testing • Any automated test
81. Challenges with multiple ALM solutions
Redundant process definitions
Collaboration barriers between teams
Administration of multiple systems
Incompatible reporting to management
82.
83. Business Analyst Eclipse developer Visual Studio
developer
Tech writer on Mac
OS X
Test team user
Build Server
C++ developer on
Linux
Team Foundation Server
94. Quality Starts with Design
Good Design is Important
Being able to share that design is
Essential
Integrated Architectural diagrams
keep everyone on the same page –
Now and in the futures
95.
96.
97.
98.
99.
100.
101. generalist specialist
coded ui test
test runner web performance test unit testing
load test
test case management
virtual lab management
data diagnostic adapters (video, action log, event log etc)
team foundation server with reporting
(bugs, requirements, user stories, source control, build)
104. • Challenge: Bug “Ping-Pong” causes animosity between testers and developers
“It crashes the application!”
“No! It works on my machine.”
105.
106. - what O/S ?
- what version ?
- what configuration?
- any log files ?
- error message ?
-…
Tester
System under Test
Developer
107.
108.
109.
110. Visual Studio Application
1) Run Test T
2010 IDE test Test Under Test
Controller R
Agent
Microsoft Test 2) Return test
Tester results and Diagnostic Data
Manager diagnostic data Adapters (DDAs)
111.
112. Requirement X
Task Test Case
Task Test Case
Bug
Task Test Case
Bug
Test Case
113.
114. Coded Web
UI Performance
Unit Tests
Tests Tests
Database
T T T
T T T Unit Tests
T T T T T T T T T T T T
User Business Database
Interface Logic
115.
116.
117. Web
Performance
Tests
Test T T
Agent T T
Test T T
Test Agent T T
Controller
Test T T
Agent T T
Test T T
Agent T T
127. Build
Application
Deploy
Run Tests Application
128. Build
Application
Restore
Run Tests
Environment
Take
Deploy
Environment
Application
Snapshot
129. Team Foundation Server
(TFS)
System Center Virtual Machine Manager
Lab Management (SCVMM)
Test Case management
Hyper-V Hosts Library Shares
Build management
Virtual
Machine1 Library Share1
Work Item Tracking
Virtual
Machine2 Library Share2
Source Control Virtual
Machinen Library Sharen
130. System Center
Lab Manager Lab Management Virtual Machine
Manager 2008
Microsoft Test Team Foundation
Manager Server
VM
131.
132.
133.
134.
135. Dev clicks on lvr link & selects
connect to snapshot of the
environment
136. Dev is able to access the
snapshot’ed environment via LE
viewer
13
6
This is an opportunity to address customers specific issues – in other words, this is not a generic presentation but designed to talk to their specific pain points and show how TFS and the Microsoft platform can help solve their problems.From an executives perspective this will typically be the following: Can’t track status on projects (no visibility) Maintenance costs a lot of money and they can’t invest in new technologies Defects are expensive Difficulty keeping up with the speed of business Aligning with business (i.e. providing business value) is difficult Lots of money wasted in failed projects (project doesn’t deliver at all, customers are unsatisfied because it doesn’t meet needs or is of poor quality) The following costs (mostly associated with CC/CQ): Maintaining the development infrastructure is expensive Lots of administrators needed Large learning curve which decreases efficiency and is expensive Tools don’t deliver on their promise
Agile discussion: Not all shops are interested in agile. Balance the discussion with the feedback from attendees on slide 2.
Clearquest does enact a “process” but there is no documentation that goes with it and it is typically used to enact the Rational Unified Process which is a very heavyweight process.CC/CQ/BF and the entire rest of the suite of rational tools is hugely expensive and confusing to navigate. There are over 50 different products that fall under the “Rational” tools category and they are very subdivided. As an example, in order to collect metrics (you get some right out of the box, but not many) you basically need to purchase Rational Dashboard which is used for dashboarding only. Compare this to TFS which includes dashboard technology (Windows SharePoint Services) or a more powerful collaboration tool such as Microsoft Office SharePoint Server which provides many more benefits than just a dashboard – and MOSS isn’t required to get dashboards – you can build them in anything, but not with Rational.Without being able to keep track of a project, knowing when to terminate a project is difficult. In addition, knowing that a project is in trouble early allows you to shift the appropriate resources to help save the project before it is too late. You also can’t make strategic decisions around critical projects without understanding the status of the project.
The main point is to tie these goals to the following slides such that everything on the following slides satisfies one or more of these goals. These goals resonate with an executive.Reduce CostThrough shorter learning curvesLicensingInfrastructureImprove traceabilityMake it simpler to link items togetherEasy to use and easy to customize reportsImprove tool adoptionThrough integrated tools which work togetherEasy to use, yet powerful toolsImprove Quality
ALM Solution from Microsoft helps organizations to focus on the key areas of software development activities: People, Process, Technology.People: increases individual and team productivity, helps drive traceability and accountability by providing the necessary metrics, KPIs, and scorecards.Process: provides clear and proven process guidance for successful project delivery – “process in a box”. Process guidance can be custom tailored to your organization’s needs and management style.Technology: provide secure and scalable platform for development activities, enabling customization and extensibility. Microsoft’s solution enables you to gain efficiency in each individual area (source control, debugging, deployment, bug tracking, etc.) as well as optimizing the way all these processes work together.
A responsive process is one which responds to the needs of the users. This falls into two categories – providing a process which yields data that is useful to the users in making decisions AND being able to change the process over time to suit the needs of the users (discussed more on the next slide). This slide talks more about the reporting and integration of users into the process.Users are typically kept in the dark because IT doesn’t want to tell them there are problems so they find out about things after the fact when it is too late to make changes and their distrust of IT goes up. This becomes a vicious cycle. By being transparent and airing problems early, the users can be involved in helping to adjust course. This increases customer satisfaction and trust of IT – especially if you can easily describe why problems are occurring. On the other hand, if things are going well then IT deserves the credit for doing it right! Either way, it is critical that users are part of the process – this is one of the key tenants of agile development but it works for formal development to TFS provides timely reports to users (either On Demand or via e-mail notifications or subscriptions) with comprehensive information presented in an easy to understand way. The reports are almost all actionable – that is, problems and successes can be seen in the reports and steps taken to correct any perceived issues.Too often IT tells the users what things mean like they just couldn’t understand. One of the benefits of the 2010 reports is they contain explanations about what the report contains. And if you can teach a user to interpret the report correctly they can an understanding looking at the data. So, instead of IT having to “tell” the users what’s going on, they can show them the report and teach them why things show up on the report the way they do and how to detect problems. This gives the users comfort and increases the trust level because they don’t have to rely on someone else to do the interpretation for them.
Many tools make you work the way the tool does, or (as in the case with CQ) it is so time consuming to make changes to the process that it isn’t efficient and changing processes is difficult (in fact, in CQ they don’t discuss it as changing the process, they call it “changing the schema”).TFS is designed to change with you from a baseline + incremental changes as needed. And you aren’t stuck with one process for every project – each project can start with a different base or the same base and delta from it as needed. Also, all of the changes to the process template can be version controlled. No additional tools are needed to update the process (CQ requires that you use the Rational Method Composer to change the schema), although you can use the power tools for a relatively easy to use GUI to help you make the changes.The reports allow you to baseline and determine deltas to show the effects of changes. And it only takes a few minutes to make a change and upload it (and yes, there is security around this – only authorized individuals can upload process template changes to the server).The PDCA cycle is called the Deming Cycle and is used in ITIL.
Gathering complete customer requirements is difficult, no matter what tool you use, because much of this problem is rooted in often unpredictable customer interactions. But stability can be established and the needs of the customer can be monitored and quantitatively reported on as long as you have robust traceability from requirements to test cases to code to bugs and test results. A complete traceability story allows teams to determine which requirements are the highest priority, how much progress has been made on the requirements (work completed and remaining) and the quality of those requirements. Finishing a requirement is unimportant if the requirement has numerous defects associated with it because then it does not meet the needs of the customer using the general definition of quality. TFS provides just that degree of traceability and the data is easily discoverable through the fully customizable out-of-the-box reporting.
This type of traceability is virtually impossible with every other tool barring some serious integration work. Through the integration of work items, version control, team test, the data warehouse, automated builds and the build reports this is built in to Team System.This type of traceability is critical from a regulatory compliance perspective (SOX, HIPAA, etc.)
Ability to add linked work items as sub tasks.Super easy way to manage your work item hierarchy.
Most enterprise organizations utilize a mix of tools and platformsUsing multiple ALM solutions can lead to challenges includingRedundant process definitionsCollaboration barriers between teamsAdministration of multiple systemsIncompatible reporting to management
Team Explorer Everywhere allows your development teams to connect to Team Foundation Server, regardless of whether they develop in Java or .NET. Using Team Foundation Server your Java and .NET teams will be able to Better collaboration Use the same methodologiesBe tracked against consistent reports that will allow for better visibility across teams
Java and cross-platform teams can connect to Team Foundation ServerPlug-in for Eclipse-based IDEsCross-platform command-line client
You can develop using the most common Operating Systems including Windows, Mac OS X, Linux, and other UNIX-based operating systems.
Support virtually all Eclipse 3.0 –based IDEs including:Eclipse 3.0IBM Rational Application Developer for WebSphere Software (RAD)Adobe Flex BuilderBEA WorkshopJbossJBuilder
Developers don’t ever have to leave the Eclipse IDE.TEE follows Eclipse-based IDEs behavior so you don’t have to change your habits.Key items to highlight:Check-in code associate WIT from within the Eclipse IDEAccess Source Code Control and project artifacts from within the Eclipse IDE
Create, configure and manage Java builds from within TEE/EclipseIntegrate code early and often your Java build the same way you do for your .NET builds using the Team Buildcontinuous integration with gated check-ins.TEE manage your builds through Ant and Maven, executes your unit tests through JUnit and brings the build reporting back to TFS so you can track progresses and quality against requirements
Today, many architecture tools are separate from the development, requirements and testing tools. This makes it extremely difficult to architect systems so that the architecture is not discarded or ignored once coding begins. Developers have to constantly refer to other documents or other tools and eventually they just don’t. The side effect of this is that the design becomes out of sync with the actual code and traceability is lost at the technical level. This has an impact on the maintenance of existing systems as well. If you can’t understand the system, then maintaining it is difficult. Visual Studio 2010 Ultimate incorporates a new set of architecture tools built around UML which allow teams to not only architect solutions in their development environment, but link those designs to requirements in a way that they can be easily referred to and kept up-to-date.
Quality is everyone's responsibility. Visual Studio 2010 includes many of the tools developers need to ensure they are meeting the needs of the customer. Find Problems before you make themFeatures such as static code analysis provide insight into where there may be potential issues before they become a problem. Code metrics allow developers to determine where their code is most complexComprehensive performance testing tools help ensure the application performs as requiredDon’t let bugs out of your sightDevelopers also have a responsibility to execute some tests before handing the code off to testers or even checking it into version control. Unit tests allow developers to discover if the code does not behave the way that it should at a granular levelTest Impact Analysis feature can reduce the number of tests which have to be executed and still give a high degree of confidence that the necessary tests have been executed. Developers can use Coded User Interface Tests to automate the testing of UI elements in their applications. This CodedUI test can be executed manually or incorporated as part of your build process to automate UI regression testingOr Into your BuildsGated Check-In executes the build and any required tests before the code is checked in. This way, if the build breaks or the tests fail the code is never checked in. This allows the rest of the development team to keep working and the developer who wrote the code can fix it. Gated
Find and Fix Bugs quickly with IntelliTrace™Ensuring that defects do not make it to the final product requires that developers can find and fix bugs quickly during a debugging session. IntelliTrace is a new capability in Visual Studio 2010 Ultimate that enables developers and testers to collaborate by sharing a historical perspective. When a test case is executed using Test Manager 2010, you have the option of collecting an IntelliTrace file using one of the DDAs. The IntelliTrace DDA collects information about the events that executed during the test run. The level of event data collection is adjustable via DDA configuration, and may be fairly coarse grain collection, or much more fine grain collection. When a tester files a new bug, the IntelliTrace file is automatically attached and available to the developer when they open the bug in Visual Studio. This enables the developer to see the exact code execution that occurred during the test run.Visual Studio Lab Management provides a virtualized testing environment which developers can use to run their code on clean systems which more accurately match supported release environments. This can help developers achieve their testing and experimentation goals in safe, easily replicated environments.
Testers have traditionally not been part of the development team. Testing was an activity that happened after development was finished. The realization that testers are an integral part of the development team is just now dawning on organizations because of the very numbers mentioned at the beginning of this paper. Visual Studio 2010 fully incorporates testers into the heart of any project by including Test Case Management and a professional test management and execution tool – Microsoft Test Manager At the outset of a project, the QA team can associate test cases directly with requirements. This allows developers to see the test cases that will be executed. Later, testers can execute tests against the code to determine if it meets the customer needs.There are many test types that you can choose. These test types range from standard unit tests and performance tests to load tests and automated tests as well as manual tests
Manual or general testing makes up about 70 percent of all the testing carried out by organizations today. As part of this, testers can collect detailed diagnostic information and videos of their testing session so that when a bug is filed it is actionable – that is, developers can actually fix the discovered defects.
Visual Studio 2010 and TFS 2010 promote quality from the ground up – but management wants to know about the project status. Management has to report to customers on the progress and quality of the software and discovering at the last minute that there are problems can make it difficult to alter course. TFS includes detailed reporting based on SQL Server Analysis Services. When combined with Microsoft Office SharePoint Server and Excel Services, information – not just data – is always available, up-to-date and accurateThis information allows management to make course corrections early on. If a high number of bugs are being filed, actions can be taken to reduce the bug count. If tests are not being executed then more testers can be brought on. This provides the ability to better ensure a quality product is delivered on time and to the customers’ satisfaction.
Every development team approaches each project with one goal in mind – to produce a quality application. But that goal can be difficult to reach without the right supporting tools. From application architecture through development, test and maintenance, Visual Studio 2010 provides the right supporting tools to help ensure that applications are of the highest quality. No matter what role you play in the development process, these tools are built with you in mind to help you meet the needs of your customers.
The first step in resolving a bug is reproducing it reliably. Once the bug is reproduced, a developer can use tools like the Visual Studio debugger to step through the code execution, watching variable states and execution flow to identify the cause of the bug. Unfortunately, all too often bugs are difficult to reproduce. If you cannot reproduce a bug, how can you be expected to fix the root cause? The reasons for not being able to reproduce the bug could be varied. Some bugs are triggered by inputs that are difficult to recreate, or poorly documented in the bug report; often a tester will perform actions or steps that weren’t explicit in the test case. Without knowing what the tester did it becomes very difficult to reproduce the bug. In some cases, bugs are the result of the speed at which the tester performed the actions—a reproduction that is often very hard to identify until you see the tester in action. In some cases the bug is the result of environmental differences between the development environment and the test environment—which could include different operating systems, service packs, different versions of required runtimes, and even the version of the software being tested.
The reality today is that testers and developers play ping pong with bugs. That essentially end up in production causing serious business impact. As you animate follow along commentary:A tester logs a bugThe developer turns it around saying not enough information, Tester repro’s and adds more informationDeveloper turns it around saying –can’t repro on his machine?
Poor communication is also the ultimate culprit for creating animosity between testers and developers.“No repro” or “works on my machine” are terms all testers hate to hear. But yet, our challenge is to resolve more bugs more quickly without increasing additional resources.It’s not that developers are being purposely antagonistic – it’s just that they often do not have enough information about an issue to reproduce the issue effectively.This is very frustrating for testers because it means that their bugs don’t get fixed. A lot of ‘no repro’ bugs usually gives a tester a bad reputation.Using today’s tools, testers have to spend an inordinate amount of time gathering information about a bug to maximize the chances that a developer will be able to reproduce the problem. A lot of this information is very basic – things like operating system version, amount of memory usage, processor speed, service pack level, build number, etc. Gathering all of this information manually gets very tedious and is certainly not very efficient.What tends to happen is that a lot of animosity builds between testers and developers. This builds up a “downward spiral”.Wouldn’t it be nice if there was a way to provide developers with all the necessary information, using the same resources you have today?
All of these things lead to a lot of wasted effort on your team, and create a divide—a chasm—between the developers and the testers. The reality is that you share a common goal. Both developers and testers want to ship high-quality software that meets the expectations of the customers and stakeholders. How can you reduce the waste of bug Ping-Pong, and increase the level of collaboration between developers and testers. Sure you can engage in some crazy team building outing where you have the developers have to fall backwards and the testers have to catch them…but is that really going to help?
Now let’s look at ineffectiveness. A common challenge is the poor communicationbetween testers and developers which results in inefficiencies, but more importantly compromises quality and costs more money. Poor communication is the ultimate culprit for ineffective testing.Defects descriptions often lack the necessary information for developers to understand what went wrong. What O/S was used? What service pack level? What error message was observed? etc. This problem is often caused by the different skillset Developers & Testers have. For example, a UAT testers couldn’t care less about your code – its the outcome that matters. His/her business knowledge are far more important than technical skills.
Looping and branchingRecorder plug-in for custom correlation extensibilityNew dialog for editing think times, goals and reporting strings across all requestsFind in playbackView recording log in playbackJump to request from playbackAdd extraction rule from playbackExtensibility in playback for adding tabs and menu items
On the server side, lab management is fully integrated with TFS. It uses SCVMM underneath to manage virtual machines. SCVMM provides a virtualization platform agnostic layer as it supports both HyperV and Vmware. Lab Management will support only HyperV for 2010 release.
Deliver unique business impact through custom solutions. By bending software to meet the needs of the business, instead of the contrary, organizations can experience technological advantages that deliver incremental business benefit.Enable management of solutions from business value identified to business value realized. ALM’s ability to trace solutions to business requirements helps ensure the delivered solution meets the needs of the business.Help IT respond to the needs of the business. By making IT projects more visible to the business, businesses align IT with business goals and establish IT as a strategic business asset. Increase confidence in custom solutions. By decreasing the risk of failure and increasing the viability of custom solutions, the business can innovate to deliver differentiated solutions that improve the operational efficiency of the business and customer experience. Protect business interests by ensuring compliance with regulations and accepted practices. By providing transparency to custom development projects and the ability to track software changes, IT can ensure compliance and governance needs are addressed.
Improve team communication and collaboration. A centralized server provides a single place for all team members and project stakeholders to collaborate, including developers, architects, testers, business analysts, designers, IT ops, and more.Use interoperable tools to reduce project friction. Using interoperable tools helps reduce the friction caused when teams move project assets between isolated tools.Automate project metrics. An instrumented and interoperable tools suite helps businesses automatically gather project metrics, increasing reporting efficiency and accuracy and improving project analytics while providing project transparency to stakeholders. Follow a tool-enacted process. Tools with built-in processes save teams time by reducing their dependency on manual processes.Optimizing the entire flow of value results in maximum efficiency. Instead of optimizing individual functions that merely improve existing processes, optimize the entire flow of project value through built-in integration that enables the most effective process for delivering business value.
Use a platform with room to grow. An evolving business both respects application boundaries and demands a trustworthy platform. This platform helps ensure applications that are more dynamic and extensible to adapt to changing business needs.Foster transferrable skills. Developers skilled in Microsoft development can apply these skills across various Microsoft platforms (Windows, the Office system, the Web, devices), reducing the need for specialists and increasing team flexibility.Tap a healthy partner ecosystem. The Microsoft partner ecosystem provides an expansive set of skills and knowledge you can draw on for even the most complex projects. Leverage world-class customer service and support. Microsoft offers dedicated, accessible, expert support to help answer customer questions.MSDN & Expression Professional Subscriptions provide SA and a wealth of resources & benefits. The MSDN and Expression Professional Subscriptions provide Visual Studio and Expressionuserswith a complementary set of products, services, and support options to help with development, testing, and demonstration of software.