In the book Anna Karenina, Leo Tolstoy states, “All happy families are alike; each unhappy family is unique in its own way.” The same can be said for software development teams. Happy, well-functioning software development teams are all the same—explicit integration of functions, measurement of flow improvements, continuous reduction of waste, common ownership of problems and action on improvements, all traceable to customer and business value. Of course we all aspire to work on, or lead software development teams that can be described this way. Today you are going to learn about ways Visual Studio 2010 can help you and your team can make immediate improvements in how you integrate across functions, reduce waste, identify and communicate problems, plan and take action to mitigate issues to ensure you are solving the business problem and achieving customer expectations.
Imagine a world where your development team performs with incredible efficiency. Where broken builds are a thing of the past, and rework is reduced significantly. Where task estimation is improved with each development iteration. Imaging being able to reproduce any bug, and easily find the root cause quickly, and having the tools to validate the implementation against the design.Ask yourself how much faster you could deliver business value if…You could estimate tasks better?You never had to play bug Ping-Pong?You could quickly find the root cause of bugs?You could quickly understand existing systems and their dependencies?You could ensure that the implementation met the design expectations consistently?You cut in half the number of broken builds?You could quickly provision and share test environments?
With Visual Studio 2010 all of these things become possible. Visual Studio 2010 introduces over 1,000 features and capabilities all of which are designed to improve the productivity of everyone engaged in software development. For teams this means improving development practices to reduce or eliminate rework, and automating repetitive and expensive activities, such as functional testing and regression testing.
There are a wealth of options for .NET developersThere are so many technology trends coming out. Everything from portal applications to mobile to cloud development.At Microsoft, we’re pioneering in a number of these areas. And for non-Microsoft developers, this would represent a massive learning curve. But for Microsoft developers, we’ve enabled building of these applications using the languages and tools that you already know and love. So if you can build a web application with ASP.NET, you’re already prepared for building cloud applications. Windows Server 2008 R2 is just an amazing product. We’ve got a brand new version of IIS, and a new technology called AppFabric that helps you build scalable, high performance applications.SQL Server 2008 R2 data developers a great platform for productively manipulating and syndicating data.Let’s dig into a few of these platforms and show you how we’re working to make your life easier with each one.
Visual Studio is the most productive developer tool on the planet. And today we’re taking that to the next level. Breaking up your flow can really kill your productivity. While we can’t stop your co-workers from interrupting you (yet), we can make it easy to get back into the zone when you lost context. There are literally hundreds of improvements here to talk about.
The Visual Studio 2010 family is made up of a central team server, and a small selection of client-side tools. The team server—Team Foundation Server 2010—is the backbone of your application lifecycle management…<CLICK>…providing capabilities for source control management, (SCM), build automation, work item tracking and reporting. In this release we’ve expanded the capabilities of Team Foundation Server by adding a true test case management system…<CLICK>…and extended it with Lab Management 2010—a set of capabilities designed to better integrate both physical and virtual labs into the development process. We’ve heard your feedback as well, and we have made it to be easier to set-up and maintain Team Foundation Server—in fact it can be installed, configured and ready to use in as little as 20-minutes. <CLICK>On the client-side we have reduces the complexity of or IDE offerings. For developers, you can choose between Visual Studio 2010 Professional, Premium or Ultimate, with each subsequent product containing all of the features of its predecessor. For testers and business analysts we are introducing Test Professional—a new integrated test environment designed with manual testers in mind.<CLICK>For those people who participate in the development efforts, but for whom Visual Studio—the IDE—is not appropriate, including Java developers, project managers and stakeholders the Team Foundation Server extensibility model enables us to provide alternative interfaces. These include both Team Explorer—a standalone tool built with the Visual Studio shell—and Team Web Access. These tools enable anyone to work directly with Team Foundation Server. In October we announced the acquisition of Teamprise, a technology similar to Team Explorer for the Eclipse IDE on Windows, Linux, Mac OS X and other Unix-based operating systems. That technology has been incorporated into the Visual Studio 2010 product line, and we will be announcing how we are productizing it very soon. The most important thing to know is that we will be releasing a Teamprise-based product, and it will also be included as an MSDN benefit for Visual Studio 2010 Ultimate customers.<CLICK>Of course we are continuing our cross-product integration capabilities with Microsoft Office® and Microsoft Expression. We have improved integration between Team Foundation Server and SharePoint Server with new SharePoint dashboards, and we have a new set of capabilities that make SharePoint development much easier than in the past.Across the board the features and capabilities we built into Visual Studio 2010 are a result of the great feedback we have gotten from our customers. This release continues our commitment to enabling you, our customers, to build the right software, in the right way to ensure success for your business.
Throughout the rest of the day you will learn about a variety of capabilities in Visual Studio 2010 that can improve software development across the lifecycle – tools that help you more easily understand existing systems, find and fix bugs quicker, and streamline your development process.
No one comes to work and begins everyday with FILE > NEW PROJECT. The reality is that every day you work with existing projects—in most cases project in which you don’t know the entire project history. Frequently you are working on existing projects that are new to you, or an unfamiliar section within a project that you are familiar with. In either case you are face-to-face with a system you may not fully understand. The challenge with this understanding the system; it is critical to understand things like down-stream dependencies before you make any code changes, to prevent a butterfly effect.
A butterfly effect is based on the premise that is a butterfly flaps its wings on one side of the world, could it cause a hurricane on the opposite side of the world. In this case, could one seemingly innocuous change to one part of the code, break something that you thought was completely unrelated in another part of the system because you weren’t aware of the downstream dependency?Imagine how much faster you could learn about a new system if you could see a diagram of how all of the code and assets are connected. Imagine how much more productive you could be if you could toggle between a diagram of the code and a matrix view showing cross-project dependencies. How would your approach to modifying an existing system change if you could visualize what the project before making any changes.
Visual Studio 2010 Ultimate enables you explore existing architectures and visualize code and assets in a variety of ways. By visualizing the code you can quickly understand how the various pieces are connected. You can easily visualize project assemblies, or top level namespaces, for example, and drill through the solution all the way to the method-level. Along the way you will see all of the upstream and downstream connections enabling you to more easily understand the system without overwhelming you. This powerful visualization capability enables developers to identify risks and potential impacts in a graphical format.This visualization capability enables you to better understand the system dependencies and drill through them to the code-level where a call sequence will be executed. From there you can automatically generate a sequence diagram of the call sequence to learn what happens—what components are used and what methods are called—during the code execution.
Understanding the system is only half the battle. Code has a tendency to "go bad" as time passes, due in a large part to unintended dependencies that are introduced as new code gets added to, or changed in the system. As you make changes to the system—maintaining and extending it—you will need to control its complexity and prevent “code rot.” How can you ensure your changes are in line with the overall design of the system? How can you ensure the changes you are making maintain the architectural integrity of the design?
Visual Studio 2010 Ultimate introduces a new model type—the layer diagram. This tool enables you to create a visual depiction of your logical architecture. For many of you, you probably do this today with tools like Microsoft Visio, or even PowerPoint. All too often people use a whiteboard to diagram the logical architecture and write “Do Not Erase” in the corner. The layer diagram modernizes this activity. It is a versionable resource that can be authored and viewed within Visual Studio ensuring you maintain the history of your design.Of course, having a fancy diagram, with lots of color does nothing to ensure that the implementation of the design matches the intent of the diagram. To solve this problem the layer diagram is an active resource; you can associate assets—classes, namespaces, assemblies, etc.—to objects in the layer diagram and then validate the implementation against it. For example, you could associate a Foo.Web namespace with the Presentation Layer of the diagram, and define the associations of that layer respective to other elements in the diagram, such as a Business Layer and a Data Access Layer. When you validate the implementation against the diagram, any code that calls into an asset that it is not permitted to—explicitly defined by an association of the two elements in the diagram—will generate a Dependency Validation Error. This indicates that the implementation doesn’t adhere to the design intent, and this is how you will maintain architectural integrity.
In their book The Hitchhiker's Guide to Lean: Lessons from the Road, Jamie Flinchbaugh and Andy Carlino describe how every process in every industry has five distinct steps: queue, setup, run, wait and move, and how the focus has been on improving the run part of the process.For decades the focus has been on the run part of the process; running the machine, building the forecast, or unloading the truck. This is where organizations direct most of their energy. While it is important, and offers opportunities for adding value, run is not the most wasteful process. There is plenty of waste in the other four steps, however.The authors go on to describe a common scenario in order to identify the parts of the process and highlight how improving the run part doesn’t achieve the desired result. This same principle can be applied to how you deal with a natural artifact of any software development effort…bugs.
Typically fixing a bug—that is, writing the code—is not the time consuming step in the process. Finding the cause of the bug can be exponentially more challenging and time consuming.Take the five steps defined by Flinchbaugh and Carlino—queue, setup, run, wait and move—as they related to a bug.This type of collaboration is exactly what Visual Studio 2010 has been designed to support. With the combination of new tools and capabilities, testers and developers will be able to collaborate like never before. In fact, they will be able to collaborate without even thinking about it. By simply performing their daily tasks with these new tools they will gain the benefits of collaboration. This is enabled in two ways—with the new Microsoft Test Manager 2010 and IntelliTrace.
Microsoft Test Manager 2010 is to manual testers what Visual Studio is to developers; it is the primary interface that a tester uses to create test cases, organize test plans, track test results, and file bugs when defects are found. Test Manager is integrated with Team Foundation Server, and is designed to improve the productivity of testers. That means that manual testers no longer have to rely on Word or Excel documents to manage and track their test cases in inefficient and time consuming ways. They now have first class support for planning, executing and tracking tests, all integrated with the rest of the team enabling them to be more efficient and accurate.As a tester runs through a test case, Test Manager collects information about what is happening during the test execution—what steps the tester is performing, systems information for the test environment and what is the tester seeing on her screen. This automatic data collection enables the tester to focus on performing accurate, value-add tests, instead of documenting excess information. When a defect is discovered, the tester can file a bug from within Test Manager. When a new bug is created all of the data that was collected during the test run is attached to the bug creating an actionable bug.
An actionable bug is one that is so rich with information that it is nearly impossible for you to take immediate action toward the resolution. Since it includes the data that was automatically collected—steps to reproduce, system information, and screen capture—there is no need to go back to the tester for more information. You no longer need to engage in bug Ping-Pong—where a bug is passed back and forth between a developer and test because there isn’t enough information to even get started fixing the bug. With an actionable bug you can see exactly what the tester did to discover the bug through the steps to reproduce and the automatic video capture of the tester’s screen. You can quickly identify any differences between your environment and the test environment through the system information that was automatically collected.This data is immensely valuable, but still may not be enough. Imagine if you could attach the Visual Studio debugger to the test execution performed by the tester. How much faster could you find the cause of a bug if you could replay the test execution, moving through it like a DVR—forward and backward—examining all of the code execution along the way? That is exactly what IntelliTrace enables you to do.
IntelliTrace is a set of technology in Visual Studio that enables you to effectively go back in time and watch code execution as it occurred in the past. In the case of a bug filed by a tester, IntelliTrace provides a historical record of the code execution during the test run that you can attach the Visual Studio debugger to. By doing this you are able to step through the actual code execution from the test run as if you were actively debugging it at the time. Of course, since it is a historical record, you can’t change anything that occurred, but you can move through the code execution—back and forth—examining the events, the variable states and even exceptions that were thrown along the way. This type of historical record acts as an accelerant to finding the root cause of a bug. You no longer have to attempt to reproduce the bug to see it in action.Of course, sometimes you’d like to debug history even when there isn’t a bug involved. Think about all the times you’ve been writing code, and doing a quick smoke test of your implementation where something unexpected happens and there was no breakpoint set. What happens next? You set a handful of breakpoints, hoping to catch the unexpected event in action, and repeat your smoke test. If you are lucky you hit a breakpoint right before the event and can debug it. Rather than setting a bunch of breakpoints and repeating the smoke test, would you like to just rewind the execution a little so you could see the event happen?Just as IntelliTrace enables you to debug historical events provided in an actionable bug, it enables you to debug your current session history. You can use the Debug History window in Visual Studio to search backward through your current debugging session for events, or to examine what took place during the code execution.
The American businessman, Warren Buffet once said, “Risk comes from not knowing what you’re doing.” How much risk are your projects in right now? How much do you know about “what you’re doing?” Every day activity happens in your projects—new code is written, bugs are fixed, tests are run. But what does that mean to your project? Are you on track to deliver a successful project?
Can you answer the following questions?Are we going to deliver a quality project on time?What do I need to know now to course correct?What ‘fires’ will we have to put out that we don’t know about?What can I do to reduce the risk?Knowing the answers to these questions could make the difference between success and failure for your project.Of course, there are dozens or more reasons why a project fail. These may include late requirements that cause the project to restart, changes in business priority, poor quality implementation that causes rework, ship-stopping bugs discovered late in the cycle, or simply getting to the end of the project’s timeline before you’ve implemented enough code to meet the requirements.
Each of these reasons provides its own unique challenges, but they all share one common trait. Poor visibility means failure. More transparency into the project activities could have surfaced issues, mitigated risk, and helped ensure the project outcome was put into production.How would your project lifecycle change if you could easily see, at any time, how much work was remaining in the current iteration? Or how many high priority bugs were currently active? Would your project risk decrease if you had a dashboard-type view of key performance indicators (KPIs) that communicated the status of remaining work, builds and bugs?With new tools in Visual Studio 2010 you can easily discover this kind of information with out-of-the box reports that support best practices for Agile, and provide early indicators of project health, and surface potential concerns. Standard and customizable reports and dashboards make it easy for you to track KPIs and communicate status, risk and project trending information.
With Visual Studio 2010 the investment in Agile continues. The Agile process template has been improved and now has out-of-the-box tools for Agile teams. This increased level of Agile support means that you can take advantage of best practices including creating and maintaining a Product Backlog, planning iterations with an eye on previous performance—including managing planned interruptions such as holidays and Spikes, and managing status with an Excel based burndown.The new Agile Planning Workbooks enable you to use the most popular tool used by Agile teams and Scrum masters – Microsoft Office Excel. The new Product Backog and Iteration Backlog workbooks enable you to plan your efforts with a light weight easy to use tool that is completely integrated with your team’s repository, Team Foundation Server. As you add user stories to the Product Backlog, they are added as new work items in Team Foundation Server. As you distill stories into tasks, those too are added as new work items in Team Foundation Server. Finally you have light-weight, easy to use Agile planning tools that integrate with Team Foundation Server right out of the box.
As you burndown your iteration backlog, it is important to have visibility into the progress and status to mitigate risk. Team Foundation Server offers two great mechanisms for reporting – SQL Server Reporting Services and Excel workbook queries.The pre-configured reports are designed to give you one-stop access to critical information. Every report was designed with your needs in mind. As you review a report you will find information not previously included—a description of the report and what it is intended to show, a list of questions you could be asking that are answered by the report, and links to other related reports. All of this will help you learn to use the reports more effectively, and get the information you need quickly.If the canned reports don’t provide exactly what you need, you can easily create Excel workbook queries. These reports are based off of queries built in Team Foundation Server, and they provide fast access to a wealth of information.
Discovering information is important, and I could argue that making that information available to the team and stakeholders is equally important. The newly designed SharePoint dashboards enable you to not only discover the information, but also share it with others. Each dashboard is designed to give you a comprehensive view of a [particular topic—including Burndown, Quality, Bugs, and more.Of course, with SharePoint and Excel services you could create custom dashboards to suit any need you may have.These dashboards enable you to provide transparency into your project, with little effort on your part, allowing you to focus on delivering a great piece of software.
By making even small improvements across the lifecycle you can eliminate unhappiness and deliver higher quality software, faster.Visual Studio 2010 will help you reduce, eliminate or automate wasteful activities. During the course of the rest of the day you will learn in more detail how Visual Studio 2010 will…Help you understanding the systems you have, control their complexity and communicate requirements.Improve developer-tester collaboration, and enable you to eliminate bugs faster.Streamline your development practice and put your focus on innovation not process.And implement some advanced capabilities including build automation, and our newest tool, Lab Management 2010.
1. Improving Software DevelopmentAcross the Lifecycle with Microsoft® Visual Studio ® 2010<br />Dave Mendlen<br />Senior Director, Developer<br />
2. All happy families are alike; each unhappy family is unique in its own way.<br />-Leo Tolstoy, Anna Karenina <br />
3. Signs Of Unhappiness<br />Loose development practices <br />Underestimating <br />‘No Repro’ bugs <br />Implementation doesn’t match design <br />And more…<br />
4. How much ‘happier’ would you be if…<br />Quickly understand existing systems?<br />You could ensure implementation matched design?<br />You could eliminate Dev/Test Ping-Pong?<br />You could quickly find the root cause of bugs?<br />Had visibility into your projects?<br />
11. Understanding What You Have<br />Could one change break something unrelated?<br />How much faster you could learn a new system if you could visualize it?<br />
12. Architectural Exploration<br />Visualize code and assets.<br />Identify upstream and downstream dependencies.<br />Generate a Sequence Diagram.<br />
13. Control Complexity<br />Code has a tendency to "go bad" as time passes.<br />How can you ensure architectural integrity?<br />
14. Layer Diagram<br />Define and communicate design intent.<br />Associate assets with layer elements.<br />Validate implementation against diagram.<br />
15. demo<br />Architectural Exploration<br />
16. Eliminate Bugs<br />
17. Five Steps to Any Process<br />
18. Five Steps to Fixing A Bug<br />Queue<br />Setup<br />Run<br />Wait<br />Move<br /><ul><li>Tester files bug.
19. Developer searches for the source of the defect.
20. Developer fixes bug.
21. Bug is assigned to tester.
22. Code is moved to test environment.</li></li></ul><li>Microsoft® Test Manager 2010<br />Create test cases for requirements.<br />Plan & execute test runs.<br />File bugs & track results.<br />
23. Actionable Bug<br />Enables immediate action.<br />Contains:<br />Steps to Reproduce<br />System Information<br />Screenshots & Video Capture<br />IntelliTrace <br />
24. IntelliTrace<br />Historical record of code execution.<br />Like a DVR for debugging.<br />Examine actual code execution.<br />
25. demo<br />IntelliTrace<br />
26. Streamline Process<br />
27. Risk comes from not knowing what you’re doing.”<br /> - Warren Buffet<br />
28. Can You Answer?<br />What do I need to know now to course correct?<br />Are we going to deliver a quality project on time?<br />What can I do to reduce the risk?<br />What ‘fires’ will we have to put out that we don’t know about?<br />
29. Poor Visibility == Failure<br />Visibility reduces risk, identifies issues.<br />What if you could see through the fog?<br />
30. Out-of-the-Box Agile Support<br />Improved Agile process template.<br />Baked-in best practices.<br />Agile Workbooks.<br />Product Backlog<br />Iteration Backlog<br />
31. Simplified Reporting<br />Improved Reports using SQL Server Reporting Services.<br />Detailed and thorough<br />Workbook queries with Microsoft Office Excel.<br />Fast and flexible<br />
32. SharePoint Dashboards<br />Improved SharePoint integration <br />Powerful dashboards<br />Ensures transparency for all stakeholders<br />