Your SlideShare is downloading. ×
Novedades En Visual Studio Team System 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

Novedades En Visual Studio Team System 2010

1,663
views

Published on

Published in: Technology

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

  • Be the first to like this

No Downloads
Views
Total Views
1,663
On Slideshare
0
From Embeds
0
Number of Embeds
2
Actions
Shares
0
Downloads
97
Comments
0
Likes
0
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
  • The video from this session can be found at http://channel9.msdn.com/pdc2008/TL47
  • Rulesets are customizable.
  • Can record entire application lifetime or just portions of the lifetime.
  • Ejecutar aplicaciones basadas en 2.0 y 4.0 en el mismo proceso CLRLos componentes antiguos utilizan el CLR antiguoLos nuevos componentes utilizan el nuevo CLR
  • MESSAGING:C# 1.0With the launch of the C# language, it was a major shift we took to a full managed environment. This was a big step for programming languages at Microsoft. C# 2.0 -With the second release of C# we introduced fully reified Generics into the language. This was a very powerful addition to the type system.C# 3.0 -C# 3.0 introduced LINQ which we talked about previouslyC# 4.0 -Not just “dynamic” as in late-binding, but those features that allow the compiler to “get out of the developer’s way”.
  • MESSAGING:Visual Basic 1 – Visual Basic 3Made Windows programming accessibleHelped make Windows the premier platform in the worldVisual Basic 4 – Visual Basic 6Made targeting COM and OLE approachable for most developersVisual Basic 7 – Visual Basic 9Bringing the “ease of use” to the .NET platformHelped establish the CLR as the premier managed runtime in the worldVisual Basic 10Continuing this trend to make it easy to use and leverage the platform
  • MESSAGING:There is a good reason why the Dynamic Language Runtime (DLR) exists. The problem is that, today, dynamically-typed languages like Python and Ruby can’t easily run directly on top of the CLR as the CLR is primarily designed for statically-typed languages. By creating the DLR, we help plug that hole and allow dynamically-typed languages to run on top of the CLR (by working through the DLR).
  • MESSAGING:The DLR provides core services that are necessary for dynamically-typed languages to work on the CLRThe DLR also provides other services that can be used by statically-typed languages as well to achieve more dynamic behavior:Expression Trees (including Statements)Dynamic DispatchCall Site Caching
  • MESSAGING:The power of the DLR is that there are many binders for the DLR. Yes, we can interop with dynamic languages like Python and Ruby like we expect to. However, perhaps even more importantly, there are binders available for .NET, Silverlight, and Office. This allows us to interact between these platforms in very powerful ways that we were unable to currently.
  • MESSAGING:As long as we stay in our statically-typed world, interacting with objects is a pleasant and intuitive experience. However, as soon as you step out of that boundary and have to start using reflection, your code becomes much less elegant, harder to read, and harder to maintain. Using ScriptObject in the DLR makes this a bit easier as it provides some direct method calls to invoke methods with specific parameters. And while this is an improvement, it’s still a departure from the way we are used to interacting with objects.Using the new dynamic keyword in C# 4, we can call the .Add method above exactly as it were statically typed like in our first code snippet. In this case, the calc object is statically typed to be dynamic (yes, that’s true). Once we have a dynamic object references, we can dynamically invoke methods, do dynamic conversion, etc.
  • Dependency matrix: colors indicate whether object inherit, references, calls, etc.
  • Visual Studio is a “programmer’s” interfaceNo test case managementDifficult to relate tests to requirementsDifficult to identify best tests to runManual testing interface unfriendly for functional testersNo automated user interface testing
  • “Ping pong” effect during resolutionInsufficient defect detailsUnknown machine configurationUnknown runtime detailsNo screenshot“It works on my machine”
  • Setting up multiple test environmentsDedicated machine resources results in poor utilization of hardwareSharing environment data with developers for defect resolution
  • Work item tracking improvements, including support for work breakdown hierarchies and customizable link types that allow queries which include the relationships between different types of work. For example, you’ll be able to query for all requirements linked to a particular test.New project scheduling features that enable better coordination between project management and the rest of the organization.  The 2010 release includes dedicated integration with Project Server for enterprise wide project management. Additionally you can expect new features for Agile project including more integration with Excel.Dashboards and cross project reports that provide roll up of status across diverse projects with drill down capabilities to investigate hot spots in the data.A simplified data warehouse and reporting experience that makes it easier to build custom reports that fit exactly the questions you want to answer.
  • Team Build 2010 Feature and Agile Development BenefitDistributed BuildsTeams can iterate on the code base faster because each build finishes in less time than it would if it executed on a single machineShelveset BuildsUsers can validate their changes in a shelveset build on the server without risking a build break. This is useful when a developer is working on a feature over an extended period and wants to reduce the integration risk when they’re done by periodically building against the tip.Gated Check-inFor large teams working in a single branch, gated check-in is essential to having a good build available for testing. Without it, you would have a never ending series of build breaks.Symbol and Source Server SupportLet’s teams quickly debug automated test failures even if the version that failed isn’t the same as what they have in their local workspace. This feature also makes the Debugging History tool window work for server builds.Build Details View with links to errors/warningsWhen a server build (Team Build) fails due to an error or warning, the user can navigate directly to the problem source file from the build details view, rather than scrolling through megabytes of build log output.Build NotificationsOur tray application notifies you when builds succeed or fail so that you respond more quickly to fix build breaks or to pickup new builds for testing.
  • OverviewWhen you’re building software as a team, there’s a natural cycle that you follow – testers find bugs, developers fix bugs, testers verify fixes. In order for this cycle to be productive, testers need builds that include fixes to the bugs that the developers have fixed. If the build is broken, there is a risk of holding up the entire team until it is fixed.Gated check-in provides a way to prevent build breaks by validating a developer’s changes prior to committing them to the version control repository. Those changes are validated via an automated build. If the build fails, the user’s pending changes are rejected and passed back to them as a shelveset, otherwise the changes are committed to the repository.Shelve-and-build, a related feature, lets the developer validate their changes with a private automated build. Unlike gated check-in, shelve-and-build is something the developer can choose to do. It can help identify breaks in code that the developer may not generally build on their local machine.Value Proposition       If a single developer on your team typically breaks the build just once a year and you have 52 developers working on your project, the build could be broken every week. If you have 260 developers, the build could be broken every day. When the build breaks, the entire team may be stalled resulting in substantial productivity losses. Those losses could be prevented by the gated check-in feature.
  • The video from this session can be found at http://channel9.msdn.com/pdc2008/TL47
  • Transcript

    • 1. Novedades en VSTS 2010
      Imposible mostrar todo …
      Ya no está en pañales …
      Bruno Capuano
      MVP Team System
      http://www.avanade.es
      Blog: http://elbruno.com
      Email: bcapuano@gmail.com
    • 2. Historia de Visual Studio
      Software
      +
      Servicios
      ALM
      Servicios Web
      Aplicaciones
      Distribuidas
      Windows ClienteServidor
    • 3. Visual Studio TeamSystem 2008
    • 4. Visual Studio Team System 2010
    • 5. Novedades en el IDE
    • 6. Mejoras en el IDE de Visual Studio
    • 7. Visual Studio 2010 basado en WPF
    • 8. Orientación al desarrollo
    • 9. Code Analysis
    • 10. Depurador Histórico (HistoricalDebugger)
    • 11. Demo – Novedades en el IDE
    • 12. Novedades en los lenguajes y en el .Net Framework
    • 13. .NET Framework – Arquitectura Actual
      .NET Framework 3.5 + SP1
      Entity Framework
      MVC
      Dynamic Data
      Data Services
      .NET Framework 3.5
      Add-in
      Framework
      LINQ
      WF & WCF Enhancements
      Additional Enhancements
      .NET Framework 3.0 + SP1
      Windows Presentation Foundation
      Windows Communication Foundation
      Windows Workflow Foundation
      Windows CardSpace
      .NET Framework 2.0 + SP1
    • 14. .NET Framework 4.0
      User Interface
      Data Access
      Services
      Windows Presentation Foundation
      ASP.NET
      (WebForms, MVC, Dynamic Data)
      Entity Framework
      ADO.NET
      Data Services
      Windows Communication Foundation
      WinForms
      LINQ to SQL
      Windows Workflow Foundation
      “Velocity”
      Core
      Base Class Library
      Dynamic Language Runtime
      Languages
      Managed Extensibility Framework
      LINQ
      Parallel Extensions
      Common Language Runtime
    • 15. Nuevo modelo de proceso: SidebySide
      2.0 add-in
      3.0 add-in
      3.5 add-in
      1.1 add-in
      3.5
      .NET 1.1
      3.0
      .NET 2.0
      Host Process (i.e. Outlook)
    • 16. Nuevo modelo de proceso: SidebySide
      2.0 add-in
      3.0 add-in
      3.5 add-in
      4.0 add-in
      3.5
      .NET 4.0
      3.0
      .NET 2.0
      Host Process (i.e. Outlook)
    • 17. Mejoras en Base Class Library
    • 18. La evolución de C#
      C# 4.0
      Dynamic
      C# 3.0
      LINQ
      C# 2.0
      Genéricos
      C# 1.0
      Código Manejado
    • 19. La evolución de Visual Basic
      VB10
      Más … más …
      VB7-VB9
      Se agregó la potencia de .NET
      VB4-VB6
      Se simplificó la programación de Componentes
      VB1 – VB3
      Se simplificó la
      programación
      para Windows
    • 20. C# y Visual Basic
      Better support for Native/COM/Managed Interop (no PIA)
    • 21. Demo – Novedades en C# y Visual Basic.Net
    • 22. ¿Porqué “DynamicLanguageRuntime”?
      Dynamically-Typed
      Ruby
      Python
      Statically-Typed
      VB
      C#
      Common Language Runtime
    • 23. ¿Porqué “DynamicLanguageRuntime”?
      Dynamically-Typed
      Ruby
      Python
      Statically-Typed
      VB
      Dynamic Language Runtime
      C#
      Common Language Runtime
    • 24. Programación con .NET DLR
      IronPython
      IronRuby
      C#
      VB.NET
      Others…
      Dynamic Language Runtime
      Expression Trees
      Dynamic Dispatch
      Call Site Caching
      PythonBinder
      RubyBinder
      COMBinder
      JScriptBinder
      ObjectBinder
    • 25. Dynamically Typed Objects
      Calculator calc = GetCalculator();
      int sum = calc.Add(10, 20);
      object calc = GetCalculator();
      TypecalcType = calc.GetType();
      object res = calcType.InvokeMember("Add",
      BindingFlags.InvokeMethod, null,
      newobject[] { 10, 20 });
      int sum = Convert.ToInt32(res);
      ScriptObject calc = GetCalculator();
      object res = calc.Invoke("Add", 10, 20);
      int sum = Convert.ToInt32(res);
      Statically typed to be dynamic
      dynamic calc = GetCalculator();
      int sum = calc.Add(10, 20);
      Dynamic method invocation
      Dynamic conversion
    • 26. Herramientas de Modelado
    • 27. Nuevas herramientas de modelado
    • 28. UML: Diagrama de Clases
    • 29. UML: Diagrama de Secuencia
    • 30. UML: Diagramas de Casos de uso
    • 31. UML: Diagramas de Actividad
    • 32. UML: Diagramas de Componentes
    • 33. Layer Diagram
    • 34.
      • Descubrir relaciones entres Namespaces, clases y ensamblados
      • 35. Comprender el codigo existente.
      • 36. Detectar problemas.
      Diagrama de Dependencias
    • 37. Demo – Herramientas de Modelado
    • 38. Pruebas
    • 39. Microsoft Test & Lab Manager
      Herramienta de pruebas profesional
      Orientada a personal de Q&A no técnico
      Orientada a Work Items Work para gestión de casos de pruebas, planificación y gestión de estados
      Enfocado a requisitos
      Identificación de pruebas de alta prioridad
      Funcionalidad de pruebas manuales extendida
      Definición de pruebas
      Test Runner manual amigable
      Herramientas de captura de defectos
      Pruebas de Interfaz automatizadas
      Web, Windows Forms y WPF
    • 40. Microsoft Test & Lab Manager
    • 41. Colaboración Desarrollador / Tester
      Automáticamente recoge los detalles de los defectos y su ejecución
      Pasos para reproducirlo
      Información del sistema
      Capturas de pantalla
      Video a pantalla completa indexado
      Traza para el historical debugging
      Entorno de pruebas
      Elimina el efecto ping-pong o “no repro”
    • 42. Detalles de los Defectos
    • 43. Test Lab Management
      Objetivos
      Virtualizar los recursos de los laboratorios de test
      Menores requisitos técnicos para la creación de entornos de prueba
      Permite la creación de entornos para la resolución de defectos
      Beneficios
      Simplifica el setup de los entornos
      Simplifica las pruebas en múltiples configuraciones
      Permite la vuelta a las configuraciones “limpias”
      Habilita checkpoints para ayudar en la resolución de defectos
      Optimiza la utilización de recursos hardware
    • 44. Test Lab Management
    • 45. Y porsupuesto: TFS 2010
    • 46. Team Foundation Server 2010
    • 47. TFS 2010: Despliegue y Administración
    • 48. Despliegues Complejos
      TFS Build Farm
      HR Applications
      TFS AT
      NLB
      Finance Applications
      TFS AT
      TFS Proxies
      Company Web site
      TFS AT
      Test Rig
      SharePoint Farm
      Data
      Warehouse
      Project Server
      Virtual Machine Manager
    • 49. TFS 2010: Control de Versiones
    • 50. Organizando/Coordinando proyectos
    • 51. 40
      40
      20
      20
      80
      80
      40
      40
    • 52. Nuevos informes
    • 53. Nuevos Informes
    • 54. Demo – Novedades en TFS
    • 55. Más … (I)
    • 56. TFS Build
    • 57. TFS Build: Gestión
    • 58. Build Workflow: Ejemplo
      Edit Code
      Submit gated check-in
      Automated Build
      Edit Code
      Y / N
      Ready for Test
    • 59. Demo – Novedades en Build
    • 60. Análisis de Impacto en Tests
    • 61. Demo – More …
    • 62. Lo que no vimos…
    • 63. Novedades en VSTS 2010
      Preguntas ¿?
      Bruno Capuano
      MVP Team System
      http://www.avanade.es
      Blog: http://elbruno.com
      Email: bcapuano@gmail.com
    • 64. Referencias
      My Blog: El Brunohttp://www.elbruno.com
      Novedades en Visual Studio Team System (V)
      http://geeks.ms/blogs/elbruno/archive/2009/01/02/vsts2010-listado-de-novedades-v.aspx
      Channel 9 10-4
      http://channel9.msdn.com/shows/10-4/
      Visual Studio Team System 2010 Beta 1
      http://tinyurl.com/ol7wgw
      Visual Studio Feedbackhttp://tinyurl.com/VSFeedback