Regional Technology Solution ProfessionalMicrosoft Visual Studio ALM RangerMicrosoft Middle East & Africa@HosamKamelhttp:/...
Business needs are not met      Solution is not able to change based on business needs      Processes cannot keep up with ...
Custom development is expensive  Tooling and Licensing to support the process is expensive  Poor or   confusing processes ...
Improve QualityImprove TraceabilityImprove Tool Adoption     Reduce Cost
GovernanceDevelopmentOperations              Idea   Deployment   End of Life
Business case        Project Portfolio   Application Portfolio   Application removeddevelopment         Management (PPM)  ...
Aspects of ALM: Development         SDLC, v1              SDLC, v2                         Maintenance     Governance    D...
Iteration 1   Iteration 2         Iteration N                            ...                  SDLC                ALM
Deploy the      Monitor the application              application                            Deploy application            ...
People              Process                                                                                   Clear proce...
1970s-1980s                     1980s-1990s        1990s-2000s Editors                                Integrated          ...
Development                                   ToolsArchitecture                                                           ...
Requirement X               Development                                             Task       Test CaseArchitecture      ...
Are we making progress   How are our builds      on running test plans?   doing over time?                               W...
Eclipse IDE                                Visual Studio       Visual Studio              Visual Studio    Team Explorer  ...
Visual Studio     Microsoft Test      Test & Lab   System Center      System CenterMicrosoft EPM                          ...
Visual Studio                          Team Foundation Server 2010              Work Item             Version          Tes...
Development Roles and Responsibilities                                          Project Managers                          ...
Plan and                       Process                  Work ItemManage Your        Tracking                              ...
PROCESS GUIDANCE (CMMI, AGILE, SCRUM ANDCUSTOM)
MSF for Agile Software Development v5.0• Product planning based on user stories and story points• Team progresses most wor...
Change your process to fit the business needs                   • Baseline                          • Develop with        ...
REQUIREMENT MANAGEMENT WITH VISUAL STUDIO2010
Gather       Decompose                      Test        Release                              Write CodeRequirements   Requ...
Requirement X                    Requirement Y      Bug  Task        Test Case               Task     Test Case      Bug T...
SOLUTION ARCHITECTURE WITH VISUAL STUDIO 2010
ADVANCED CODING CAPABILITIES WITH VISUAL STUDIO                    2010
log       JohnRobbins
PLAN & MANAGE YOUR PROJECT
UNDERSTAND PARALLEL DEVELOPMENT
Client sidecopy of source   Owned by one checked out      user on one     from          machine  repository Changes in    ...
Branch• A branch relationship is created in TFS to avoid duplication of history and  metadata• Path-space branching• Intel...
1.0             1.1               1.2                 2.0                3.0                3.1      Release         Minor...
Branch• A branch relationship is created in TFS to avoid duplication of history and  metadata• Path-space branching• Intel...
WhereHowHas
CompareHistoryAnnotateAutoMerge
Task switching  Peer reviews  Backup WIPSharing
Extension of MS Build    • Integrated Windows Workflow                           • Continuous Integration      Several sce...
TEAM EXPLORER EVERYWHEREUnite your teams across platforms
Challenges with multiple ALM solutions     Redundant process definitions     Collaboration barriers between teams     Admi...
Business Analyst     Eclipse developer      Visual Studio                                                     developer   ...
85   Microsoft Confidential
89
Rich & Actionable Bugs                         NO MORE “NO REPRO” BUGS
Quality Starts with Design  Good Design is Important  Being able to share that design is  Essential  Integrated Architectu...
generalist                                                                             specialist                         ...
DeveloperTester
• Challenge: Bug “Ping-Pong” causes animosity between testers and developers “It crashes the application!”        “No! It ...
- what O/S ?                                - what version ?                             - what configuration?            ...
Visual Studio                                             Application                          1) Run       Test          ...
Requirement X  Task        Test Case Task           Test Case                               BugTask             Test Case ...
Coded     Web  UI  Performance                      Unit TestsTests    Tests                                             D...
Web                     Performance                        Tests              Test      T   T             Agent      T   T...
REPORT ON YOUR PORTFOLIO
Choose your Warehouse • Cube • RelationalBuilt-in Reporting • SQL Server Reporting Services • ExcelTrending, aggregate, “r...
VISUAL STUDIO LAB MANAGEMENT TOOLS
Build            Application                            DeployRun Tests                 Application
Build                    Application                                           RestoreRun Tests                           ...
Team Foundation Server        (TFS)                            System Center Virtual Machine Manager       Lab Management ...
System CenterLab Manager      Lab Management    Virtual Machine                                    Manager 2008Microsoft T...
Dev clicks on lvr link & selects connect to snapshot of the         environment
Dev is able to access the     snapshot’ed environment via LE                 viewer136
CONCULSION
Effective Solutions for Business Impact
Efficient Application Implementation
Comprehensive and Trusted Platform
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
End-To-End Visual Studio Application Lifecycle Management
Upcoming SlideShare
Loading in...5
×

End-To-End Visual Studio Application Lifecycle Management

3,778

Published on

An end-to-end presentation demonstrating the full capabilities of Visual Studio 2010 application lifecycle Management

Published in: Technology
0 Comments
5 Likes
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total Views
3,778
On Slideshare
0
From Embeds
0
Number of Embeds
10
Actions
Shares
0
Downloads
0
Comments
0
Likes
5
Embeds 0
No embeds

No notes for slide
  • 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.)
  • Activity, Case, Sequence, Component, Class
  • Activity, Case, Sequence, Component, Class
  • Activity, Case, Sequence, Component, Class
  • http://blogs.msdn.com/b/jasonz/archive/2010/06/05/announcing-vs2010-productivity-power-tools-and-modeling-feature-packs.aspxhttp://blogs.msdn.com/b/camerons/archive/2010/03/19/announcing-the-first-feature-pack-for-vs2010-visualization-and-modeling-tools.aspxDownload from: http://msdn.microsoft.com/en-us/vstudio/ff655021.aspx
  • http://www.wintellect.com/CS/blogs/jrobbins/archive/2009/06/16/how-does-vs2010-historical-debugging-work.aspxhttp://blogs.msdn.com/habibh/default.aspx
  • http://blogs.msdn.com/profiler/http://blogs.msdn.com/profiler/archive/2009/06/10/write-faster-code-with-vs-2010-profiler.aspxhttp://www.wintellect.com/CS/blogs/jrobbins/archive/2009/10/23/vs-2010-beta-2-concurrency-visualizer-profiling-in-depth-first-look.aspxhttp://www.wintellect.com/CS/blogs/jrobbins/archive/2009/10/19/vs-2010-beta-2-sampling-and-instrumentation-profiling-in-depth-first-look.aspx
  • 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.
  • Source: http://www.microsoft.com/casestudies/casestudy.aspx?casestudyid=4000001816
  • End-To-End Visual Studio Application Lifecycle Management

    1. 1. Regional Technology Solution ProfessionalMicrosoft Visual Studio ALM RangerMicrosoft Middle East & Africa@HosamKamelhttp://blogs.msdn.com/HKamel
    2. 2. 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
    3. 3. 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
    4. 4. Improve QualityImprove TraceabilityImprove Tool Adoption Reduce Cost
    5. 5. GovernanceDevelopmentOperations Idea Deployment End of Life
    6. 6. Business case Project Portfolio Application Portfolio Application removeddevelopment Management (PPM) Management (APM) from service Project approved Governance Development Operations
    7. 7. Aspects of ALM: Development SDLC, v1 SDLC, v2 Maintenance Governance Development Operations
    8. 8. Iteration 1 Iteration 2 Iteration N ... SDLC ALM
    9. 9. Deploy the Monitor the application application Deploy application updates GovernanceDevelopment Operations
    10. 10. 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
    11. 11. 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
    12. 12. Development ToolsArchitecture Testing Tools Tools Design Documents Version Test Cases Control/ Build Mgmt Requirements Project Statistics Reporting andRequirements Shared Server Tracking Tools Tools Microsoft Team Foundation Server
    13. 13. Requirement X Development Task Test CaseArchitecture Testing Task Test Case Bug Shared Server Task Test Case Bug Test CaseRequirements Project Tracking
    14. 14. 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
    15. 15. Eclipse IDE Visual Studio Visual Studio Visual Studio Team Explorer Team Explorer 2010 IDE 2010 Everywhere 2010 Expression Studio Visual Studio Microsoft TestWeb 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
    16. 16. Visual Studio Microsoft Test Test & Lab System Center System CenterMicrosoft EPM Operations Configuration 2010 IDE Manager Management Manager Manager Microsoft Project System Center Service ManagerMicrosoft Excel Visual Studio Team Foundation Server (TFS) Configuration SharePoint Management Database (CMDB)
    17. 17. 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 VMTemplates
    18. 18. 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
    19. 19. Plan and Process Work ItemManage Your Tracking Guidance & Project Automation Understand Version Branch Build Parallel Control Visualization ManagementDevelopmentNo More “No Microsoft Test Case Lab IntelliTrace Test ManagerRepro” Bugs Management Management (MTM) Report on Dashboards ReportsYour Portfolio
    20. 20. PROCESS GUIDANCE (CMMI, AGILE, SCRUM ANDCUSTOM)
    21. 21. 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 auditsMSF 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 appraisalVisual Studio Scrum v1.0• Development lifecycle follows Scrum framework (based on Agile principles) MSF = Microsoft Solutions Framework CMMI = Capability Maturity Model Integration
    22. 22. 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
    23. 23. REQUIREMENT MANAGEMENT WITH VISUAL STUDIO2010
    24. 24. Gather Decompose Test Release Write CodeRequirements Requirements Requirement Requirement
    25. 25. Requirement X Requirement Y Bug Task Test Case Task Test Case Bug Task Test Case Task Test Case Bug BugTask Test Case Test Case Bug Bug Test Case
    26. 26. SOLUTION ARCHITECTURE WITH VISUAL STUDIO 2010
    27. 27. ADVANCED CODING CAPABILITIES WITH VISUAL STUDIO 2010
    28. 28. log JohnRobbins
    29. 29. PLAN & MANAGE YOUR PROJECT
    30. 30. UNDERSTAND PARALLEL DEVELOPMENT
    31. 31. Client sidecopy 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
    32. 32. Branch• A branch relationship is created in TFS to avoid duplication of history and metadata• Path-space branching• Intelligent copiesMerge• Sync a branch into another• Cherry Picking changesets (include or omit)• Ability to show changes that have not been merged
    33. 33. 1.0 1.1 1.2 2.0 3.0 3.1 Release Minor bug Bug release Larger new Production release version release
    34. 34. Branch• A branch relationship is created in TFS to avoid duplication of history and metadata• Path-space branching• Intelligent copiesMerge• Sync a branch into another• Cherry Picking changesets (include or omit)• Ability to show changes that have not been merged
    35. 35. WhereHowHas
    36. 36. CompareHistoryAnnotateAutoMerge
    37. 37. Task switching Peer reviews Backup WIPSharing
    38. 38. Extension of MS Build • Integrated Windows Workflow • Continuous Integration Several scenarios • Scheduled supported • Gated / Shelveset • Ad-hocProvides build reporting • Pass / Fail back to TFS • Trend data Integrated testing • Any automated test
    39. 39. TEAM EXPLORER EVERYWHEREUnite your teams across platforms
    40. 40. Challenges with multiple ALM solutions Redundant process definitions Collaboration barriers between teams Administration of multiple systems Incompatible reporting to management
    41. 41. Business Analyst Eclipse developer Visual Studio developer Tech writer on Mac OS XTest team user Build ServerC++ developer on Linux Team Foundation Server
    42. 42. 85 Microsoft Confidential
    43. 43. 89
    44. 44. Rich & Actionable Bugs NO MORE “NO REPRO” BUGS
    45. 45. 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
    46. 46. 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)
    47. 47. DeveloperTester
    48. 48. • Challenge: Bug “Ping-Pong” causes animosity between testers and developers “It crashes the application!” “No! It works on my machine.”
    49. 49. - what O/S ? - what version ? - what configuration? - any log files ? - error message ? -…Tester System under Test Developer
    50. 50. Visual Studio Application 1) Run Test T 2010 IDE test Test Under Test Controller R Agent Microsoft Test 2) Return testTester results and Diagnostic Data Manager diagnostic data Adapters (DDAs)
    51. 51. Requirement X Task Test Case Task Test Case BugTask Test Case Bug Test Case
    52. 52. Coded Web UI Performance Unit TestsTests Tests Database T T T T T T Unit Tests T T T T T T T T T T T T User Business DatabaseInterface Logic
    53. 53. Web Performance Tests Test T T Agent T T Test T T Test Agent T TController Test T T Agent T T Test T T Agent T T
    54. 54. REPORT ON YOUR PORTFOLIO
    55. 55. Choose your Warehouse • Cube • RelationalBuilt-in Reporting • SQL Server Reporting Services • ExcelTrending, aggregate, “roll-up” reports • DashboardsAccessible via Portal, Team Explorer, others
    56. 56. VISUAL STUDIO LAB MANAGEMENT TOOLS
    57. 57. Build Application DeployRun Tests Application
    58. 58. Build Application RestoreRun Tests Environment Take Deploy Environment Application Snapshot
    59. 59. 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
    60. 60. System CenterLab Manager Lab Management Virtual Machine Manager 2008Microsoft Test Team Foundation Manager Server VM
    61. 61. Dev clicks on lvr link & selects connect to snapshot of the environment
    62. 62. Dev is able to access the snapshot’ed environment via LE viewer136
    63. 63. CONCULSION
    64. 64. Effective Solutions for Business Impact
    65. 65. Efficient Application Implementation
    66. 66. Comprehensive and Trusted Platform

    ×