Your SlideShare is downloading. ×
What's New in Visual Studio 2010
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×

Introducing the official SlideShare app

Stunning, full-screen experience for iPhone and Android

Text the download link to your phone

Standard text messaging rates apply

What's New in Visual Studio 2010

2,514
views

Published on

Slides from my keynote at the Oklahoma City Community Launch for Visual Studio 2010

Slides from my keynote at the Oklahoma City Community Launch for Visual Studio 2010

Published in: Technology

0 Comments
2 Likes
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total Views
2,514
On Slideshare
0
From Embeds
0
Number of Embeds
1
Actions
Shares
0
Downloads
65
Comments
0
Likes
2
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
No notes for slide
  • 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.
  • 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. Speaker: Pick two or three to mention. Spend no more than 1 minute on this slide.
  • 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.
  • [CLICK]Visual Studio Test Elements 2010 is the essential tool for anyone engaging in test case management or manual test execution in the development lifecycle. This tool is designed for the generalist tester – someone who tests applications, but who is not responsible for writing code. This product includes Microsoft Test and Lab Manager (the Visual Studio IDE is not included). [CLICK]Team Lab Management 2010 enables teams to configure and manage virtual lab environment. Team Lab Management works with System Center Virtual Machine Manage enabling teams to create environment templates, provision ring-fenced environments, and checkpoint those environments. Those checkpoints can be attached to bugs filed using the Test and Lab Manager enabling the person fixing the bug to open the environment right to the appropriate point in the application flow.
  • 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.
  • http://www.istockphoto.com/stock-photo-738564-maze-of-rails-in-prague.phpNo 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.
  • 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.
  • The QA team found a bug - but you can’t reproduce it (2-3 minutes)Show the rich actionable bug work-itemClick into the video of the issueUse IntelliTrace to find the issue Think you fixed the bug but how can you be sure (1-2 minutes)Fast Forward through the testShow the successful result.
  • The QA team found a bug - but you can’t reproduce it (2-3 minutes)Show the rich actionable bug work-itemClick into the video of the issueUse IntelliTrace to find the issue Think you fixed the bug but how can you be sure (1-2 minutes)Fast Forward through the testShow the successful result.
  • http://www.istockphoto.com/stock-photo-5134971-risk-management.php
  • 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. SPEAKER NOTE: You can use any amusement park ride example hereYou visit Walt Disney World to and go to the Pirates of the Caribbean ride. What’s the first thing you do? You wait in line (queue). When you get to the end of the line, you cannot just hop on the boat. The ride operators have to get the other people off (setup). Then you get on and go through the ride (run). When the ride is over you have to wait for the other people to get off the boat (wait). Finally you pack up your family and mosey to the next ride (move).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.[Describe the five steps in the slide]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 QA team found a bug - but you can’t reproduce it (2-3 minutes)Show the rich actionable bug work-itemClick into the video of the issueUse IntelliTrace to find the issue Think you fixed the bug but how can you be sure (1-2 minutes)Fast Forward through the testShow the successful result.
  • 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.
  • Transcript

    • 1. What’s New in Microsoft Visual Studio2010
      Chris Koenig
      Microsoft Corporation
    • 2. 1980s-1990s
      1970s-1980s
      1990s-2000s
      Integrated development environments (IDEs)
      Editors
      Build tools
      Tools for Software Development
      Compilers
      Team development tools
      Version control tools
      Testing tools
      Reporting and tracking tools
    • 3. Introducing Visual Studio 2010
    • 4. Across the Board Innovation
      Highlight References
      Zoom-able Coding Surface
      Multi Monitor Support
      Hide selection
      Visual Studio Extension Manager
      Refined Multi-targeting
      Box Selection
      Partial String IntelliSense
      HTML Snippets
      Breakpoint Labeling
      Navigate-To
      Drag-and-drop Data-binding
      Call Hierarchy
      Generate from usage
      Customizable Start Page
      One Click Deployment
      Breakpoint exporting
      Low impact IntelliSense Mode
      New Help Experience
    • 5. Visual Studio 2010 Ecosystem
      Eclipse IDE
      Visual Studio Team Explorer Everywhere 2010
      Visual Studio Team Explorer 2010
      Visual Studio 2010 IDE
      Expression Studio
      Visual Studio Team Foundation Server 2010
      Microsoft Test Manager 2010
      Visual Studio Lab Management 2010
      Web Browser
      SharePoint
      Microsoft Excel
      Microsoft Project
      Visual Studio 2010
      Other Microsoft
      Other Vendors and Open Source
    • 6.
    • 7. Test and Lab Manager
      UML Modeling
      Manual Testing
      Layer Diagram
      Load Testing
      Web Testing
      Test Case Management
      IntelliTrace™
      Architecture Explorer
      Logical Class Designer
      Cloud Development
      Office Development
      Windows Development
      New WPF Editor
      Customizable IDE
      Multi-core Development
      Silverlight Tools
      Web Development
      SharePoint Development
      Generate from Usage
      Static Code Analysis
      Database Deployment
      Code Metrics
      Database Unit Testing
      Test Data Generation
      Test Impact Analysis
      UI Test Automation
      Code Coverage
      Performance Profiling
      Database Change Mgmt
      Fast Fwd for Manual Test
    • 8. Test and Lab Manager
      Test Case Management
      Fast Fwd for Manual Test
      Manual Testing
      Lab Mgmt Configuration
      Checkpoint Environment
      Environment from Template
      Virtual Env. Setup/Tear Down
      Team Explorer
      Team Agents
      New to the Visual Studio Product Family
    • 9. Understand Existing Systems
      Maximizing Productivity
      Ship Great Software
    • 10. Understand Existing Systems
    • 11. Understanding What You Have
      Could one change break something unrelated?
      How much faster you could learn a new system if you could visualize it?
    • 12. Architectural Exploration
      Visualize code and assets
      Identify upstream and downstream dependencies
      Generate a Sequence Diagram
    • 13. Control Complexity
      Code has a tendency to "go bad" as time passes.
      How can you ensure architectural integrity?
    • 14. Layer Diagram
      Define and communicate design intent
      Associate assets with layer elements
      Validate implementation against diagram
    • 15. Sequence Diagram
      Describe interactions between objects
      Visually identify code coupling that might be impacted by changes
      Link elements of any kind to work Items in TFS
    • 16. demo
      Architectural Tools
    • 17. MaximizeDeveloper Productivity
    • 18. Huge List of New Features
      Breakpoint Labeling
      Breakpoint Searching
      Breakpoint Import/Export
      Dynamic Data Tooling
      WPF Tree Visualizer
      Call Hierarchy
      Improved WPF Tooling
      Historical Debugging
      Mini-Dump Debugging
      Quick Search
      Better Multi-Monitor Support
      Highlight References
      Parallel Stacks Window
      Parallel Tasks Window
      Document Map Margin
      Generate from Usage
      Concurrency Profiler
      Extensible Test Runner
      MVC Tooling
      Web Deploy
      JQuery IntelliSense
      SharePoint Tooling
      HTML Snippets
      Web.configTransformations
      ClickOnceEnhancements
      AND MANY MORE!
    • 19. General Improvements
      Start page
      Rewritten using XAML—easy to customize
      Recent Projects list: right-click, pin
      New projects: Multi-targeting
      New support for Silverlight, MFC, F#, Azure
      Extended support for Office 2010, SharePoint
      Extension manager
      Gallery for Visual Studio extensions
      Simplified Deployment for Web Projects
      Web.config Transformations
    • 20. UI Improvements
      Zoom
      Docking Windows
      Navigate To/Quick Search
      Highlighting References
      Box Selection
      Generate from Usage
      IntelliSense Consume-First Mode
      Search in Add New Item dialog box
    • 21. Docking Windows
      New docking visuals
      Windows can be docked anywhere
      Better use with multiple monitors
    • 22. Navigate To/Quick Search
      Ctrl+,
      Provides search-as-you-type support for files, types, and members
      Enables quick searching
      Provides “fuzzy” search
      Ctrl+- goes back
    • 23. Highlighting References
      Automatic highlighting of symbols
      Works with declarations, references, and many other symbols
      Makes it easy to find all uses of a symbol
    • 24. Box Selection
      In VS 2008, could press ALT key to select rectangular region
      Now, additional features:
      Text insertion: Type into a box selection to insert text on every line
      Paste contents from one box selection to another
      Zero-width boxes
      Make a vertical selection zero-width to create multi-line insertion point for new or copied text
    • 25. Generate from Usage
      Automatically creates “stub” code from code you have typed
      Enables you to use classes and members before you define them
      Very useful for TDD-style coding approaches
    • 26. Debugging Improvements
      Breakpoints
      Can add labels to breakpoints
      All breakpoints are searchable
      Can import/export breakpoints
      Floating Data Tips
      Call Hierarchy (C# Only)
    • 27. VB & C# 2010 Language
      New in VS 2010
      Already exists in VS 2008
    • 28. VB & C# 2010 IDE
      New in VS 2010
      Already exists in VS 2008
    • 29. Shared Language Features
      .NET Client Profile
      In-process Side-by-Side Execution
      Code Contracts
      Improved support for Parallelism
      Task Parallel Library
      PLINQ
      Visual Studio Parallel Tasks window
      Managed Extensibility Framework
      No-PIA
    • 30. demo
      IDE Enhancements
    • 31. So much more!
      Extension Manager
      Visual Studio Productivity Power Tools
      Power Commands for Visual Studio
      Visual Studio Tips and Tricks
      Zain Naboulsi: http://blogs.msdn.com/b/zainnab
      Scott Cate: http://scottcate.com/tricks
      Other references
      http://delicious.com/chriskoenig/vs2010
    • 32. Ship Great Software
    • 33. Five Steps to Any Process
    • 34. Five Steps to Fixing A Bug
      Queue
      Setup
      Run
      Wait
      Move
      • Tester files bug
      • 35. Developer searches for the source of the defect
      • 36. Developer fixes bug
      • 37. Bug is assigned to tester
      • 38. Code is moved to test environment
    • Microsoft® Test Manager 2010
      Create test cases for requirements
      Plan & execute test runs
      Optimized for manual testing
      Create “Actionable” bugs & track results
    • 39. Actionable Bug
      Enables immediate action
      Contains:
      Steps to Reproduce
      System Information
      Screenshots & Video Capture
      IntelliTrace
    • 40. IntelliTrace
      Historical record of code execution
      Like a DVR for debugging
      Examine actual code execution
    • 41. demo
      IntelliTrace
    • 42. Understand Existing Systems
      Maximizing Productivity
      Ship Great Software
    • 43. Contact Me
      chriskoenig.net
      christopherkoenig
      @chriskoenig
    • 44. Q&A
    • 45. © 2009 Microsoft Corporation. All rights reserved. Microsoft, Visual Studio, the Visual Studio logo, and [list other trademarks referenced] are trademarks of the Microsoft group of companies.
       
      The information herein is for informational purposes only and represents the current view of Microsoft Corporation as of the date of this presentation.  Because Microsoft must respond to changing market conditions, it should not be interpreted to be a commitment on the part of Microsoft, and Microsoft cannot guarantee the accuracy of any information provided after the date of this presentation.  MICROSOFT MAKES NO WARRANTIES, EXPRESS, IMPLIED, OR STATUTORY, AS TO THE INFORMATION IN THIS PRESENTATION.