Overview
This boot camp helps participants increase the speed of software development while also delivering more value. The course will help participants improve the processes and traceability of work across the entire software development lifecycle. The course covers a broad range of topics related to Team Foundation Server and Visual Studio 2013. From requirement gathering to deploying the code, the course demonstrates how to bring everything together and get better visibility into projects as well as better traceability and reporting. Participants of the course will learn how to better and more efficiently develop code, while automating the build and deploy processes.
What You'll Learn
- Use powerful work management tools to eliminate bottlenecks and optimize cycles
- Use Team Foundation Server to document requirements and build storyboards and wireframes
- Version control everything – use Team Build and fully manage code repositories including integration with Git and GitHub
- Use TFS as a platform for integrating Development and Operations – streamline the IT team to deploy faster, with continuous quality improvement
- Easily manage test cases, execute test plans and automate testing
- Setup and manage the SDLC processes in TFS using Agile, Scrum CMMI or any custom process
- Identify performance issues faster with powerful measuring and monitoring
- Use TFS and Visual Studio 2015/2017 Ultimate to improve collaboration and increase overall team efficiency
- Enforce system architecture with a full suite of architectural tools
- Learn to use TFS code analysis and how it enforces coding stadards
Curriculum
- Introducing TFS and Visual Studio 2015/2017
- Overview of Application Lifecycle Management
- TFS and Visual Studio 2015/2017 Ultimate in the enterprise
- Overview of targeted roles and capabilities
- New architecture and administration in TFS 2015/2017
- Introducing work items
- Work item type definitions
- Process templates
- Work item relationships (“links”)
- Hierarchical work item management
- Work item traceability
- User interfaces and work items
- Work item queries
- Managing work items with Excel and Project
- Practice Labs:
- Using TFS work items
- Using Team web access
- Using hierarchical work items
- Creating and managing requirements
- Creating flat work items queries
- Managing work item data in Excel
- Creating hierarchical work item queries
- Hierarchical data in Project and Excel
- Planning a release
- Using a product backlog and user stories
- Using features
- Planning an Iteration (Sprint)
- Creating an Iteration Backlog
- Running an Iteration
- Completing an Iteration Retrospectives
- Practice Labs –
- Setting up features and product backlog
- Plan and run a sprint
- Description and Team Foundation Server version control concepts
- Parallel development
- Storage and Reverse-Delta storage
- Workspaces
- Adding files to Version Control
- Check-out/Check-in
- Deleting files from version control
- Using GIT for version control
- Practice Labs –
- Setting up version control n TFS
- Using versioned files and projects
- Using GIT version control repository
- Viewing version control history
- File and version comparison
- Annotate
- Labels
- Using Shelvesets
- Practice Labs –
- Using version control history and annotate
- Using version control labels
- Shelving code and using Shelvesets
- Branching overview
- Branching guidance and workflow
- Creating and managing branches
- Branch visualizer
- Branch history
- Practice labs –
- Branching and branching visualization
- Using version control history across branches
- Merging between branches
- Promoting code
- Merging best practices
- Practice labs –
- Merging between branches and tracking merge history
- Merging conflict changes
- Configuring client tools
- Viewing deleted files
- Undelete
- Custom compare/merge tools
- Version control security and policies
- Policy overrides
- Code rollback
- Managing multiple workspaces
- Gated check-ins and workflows
- Practice labs –
- Rolling back code
- Using workspace
- Manual versus automated builds
- Automated builds with TFS 2015/2017
- Build architecture
- Build server pooling and tags
- Build definitions
- Creating a build
- Scheduling/continuous integration
- Gated check-ins
- Retention policies
- Querying and monitoring builds
- Extending and customizing builds
- Practice labs –
- Creating new builds
- Test workflow and quality assurance guidance
- Testing on Agile teams
- Tester roles and responsibilities
- Microsoft Test Manager 2015/2017 tools
- Test planning with MTM
- Introducing test plans, suites and cases
- Using test plan configurations
- Adjust test settings
- Authoring test cases and test steps
- Launching Microsoft Test Runner
- Analyzing Test Runs
- Using Test Impact analysis
- Leveraging MTM plug-ins
- Practice Labs –
- Using Microsoft Test Manager 2015/2017
- Test plans and configuration with Microsoft Test Manager
- Writing test cases
- Running tests and analyzing results
- Recording tests and automated playback
- Using test runs and bugs
- Background and history of visual studio
- Common user interface (UI) elements
- Developing solutions
- Practice labs –
- Visual studio and test projects
- Overview of Coded UI test tools
- Create coded UI tests from existing tests
- Creating coded UI tests using the coded UI test builder
- Validating coded UI tests
- Writing your own coded UI tests
- Practice labs –
- Recording a coded UI test
- Creating a coded UI test from test recordings
- Adding validation rules
- Creating a data-driven coded UI test
- Introducing IntelliTrace
- Debugging exceptions
- IntelliTrace events
- Post mortem analysis
- Practice labs – Using IntelliTrace while debugging
- Introducing unit tests
- Test-driven development
- Unit test philosophy and understanding
- Using the visual studio unit test tools
- Leveraging code coverage
- Using test impact analysis
- Practice labs –
- Creating unit tests with the Visual Studio
- Creating data – driven unit tests
- Enabling and using code coverage
- Enabling code coverage during builds
- Using test impact analysis
- Understanding developer quality
- Enabling and using code analysis
- Using/customized code analysis rule sets
- Leveraging code metrics
- Using the performer profiler
- Interpreting performance profiler reports
- Practice labs –
- Enabling code analysis, resolving issues
- Creating custom code analysis rule sets
- Creating custom code analysis rules
- Profiling code to fix performance issues
- Using and interpreting code metrics
- Overview and challenges of database development
- Overview of Visual Studio 2015/2017 Ultimate Database Tools
- Database Projects
- Overview of Database Project Structure
- Importing Existing Databases
- Importing Options & Configurations
- Components of a Database Project
- Navigating a Database Project Using Object View & Schema View
- Practice labs –
- Build & Deploy Database Projects
- Using Stored Procedures
- Modifying Database Schemas
- Refactoring Databases
- Deploying Databases to Non-Local Environments
- Deploying Databases to Production Environments
- Deployment Workflow & Managing Production Deployments
- Setting up Multiple SQL deployment Configurations
- Deploying Breaking Changes
- Visual Studio Reporting with Reporting Services
- Built-In Process Template Reports
- Team Project Dashboards Customizing SharePoint Dashboards Reporting with Excel
- Practice labs –
- Using the Team Project Dashboard
- TFS Reports Using Excel
- TFS Reports Using Reporting Services
Who should attend
This boot camp is targeted towards software developers, IT managers, IT Project Managers, Testers, and others involved in the software development process. The course is highly recommended for:
- Developers
- Software Managers and Team Leads
- IT Project Managers
- Testers
- Others directly involved in the software development process
Prerequisites
Participants don’t need to be programmers for taking up this course. Though, some experience with Visual Studio is beneficial for the version control modules of this course. Completing the Fundamentals of DevOps course prior to taking up this course would also be beneficial.
