Training
Engineering practices in modern software development
Engineering practices are a particular challenge when adopting Agile. Yet without them, building a high-quality product is next to impossible. To start applying engineering practices on a project, you need to understand the benefits they bring, as well as the challenges and nuances of adopting them. Every project and team is unique, but there are still proven strategies that will help you start adopting them and succeed.
The goal of the training is to walk you through the family of core engineering practices used in Agile and to give your team the initial push to adopt them. Over 16 hours, we’ll cover 8 engineering practices and approaches:
- Code review
- Pair programming
- Unit testing
- Refactoring
- Application build automation
- Continuous integration
- Functional test automation
- TDD
They are all interconnected and deliver the greatest benefit when applied together. Each one supports the others, complementing and extending them. Every practice will be demonstrated on a real Java project, whose code will be available to participants afterward to study as learning material. There will be time during the training for questions and for discussing specific scenarios and real-life examples from participants, with advice and comments from the trainers. Participants will be able to share their own experience, talk with colleagues, and hear other people’s views.
This training introduces you to the principles behind each practice and the benefits of adopting them. The trainers will share their many years of successful hands-on experience applying these practices. The training also covers several strategies for adopting the practices gradually at different stages of a project. By the end of the training, you will:
- Gain theoretical knowledge of engineering practices in Agile
- Learn techniques for adopting and applying them at different stages of a project
- See firsthand how effective some engineering practices are
- Expand your knowledge with real-life examples that will help you start working with engineering practices on your project quickly and effectively
- Get expert answers to your questions about real-life situations on your project or team
- Avoid many mistakes and difficulties in your real-world work
- Target audience
- Developers, team leads, managers
- Price
- $350per participant
- Date and time
- 16 hours / 2 days
Detailed program
- Introduction
- Overview of engineering practices
- Goals and benefits of using them
- The concept of code quality
- Introductions
- Gathering expectations and requests
- Program outline
- The working scenario (an existing project, not-so-great code, few or no tests, and nothing automated)
- Code review and pair programming
- Why review code
- How to review code
- Roles and choosing a reviewer
- Practical tips for running reviews
- Principles of pair programming
- How to work in pairs
- Technical setup for working in pairs
- Pair programming styles
- A pair programming simulation game
- Static code analyzers, with Sonar as an example
- Unit testing
- Why unit testing is necessary
- Benefits for developers
- Core principles and rules of unit testing
- Principles of working with mocks
- Types of test doubles (stub, dummy, mock, spy)
- Techniques for writing unit tests
- Tools for writing unit tests
- A practical demonstration
- Testing the database, external services, and the file system
- What two working days look like for different teams
- Refactoring
- What refactoring is and what it’s for
- Examples of code smells
- Types of basic refactorings, with code examples
- Using the IDE for refactoring
- Supporting refactoring with unit tests
- Working through an example and reviewing the results
- Build automation
- What problems build automation solves
- What to include and which steps to take
- Choosing a build tool
- A practical demonstration of build automation
- Practices and useful tips
- Continuous integration
- The principles behind CI
- Practices for working with CI
- Overview of tools
- A tool in action (TeamCity, Hudson)
- Adding a project and setting up the workflow
- Tips and useful practices
- Automated functional testing
- Advantages and disadvantages of automation
- The regression death spiral and ways to combat it
- Automation tools
- A hands-on session with Selenium
- Approaches and practices for reliable, repeatable tests
- Integrating tests into the existing build infrastructure
- TDD
- What TDD is
- The rules and principles of TDD
- Benefits of TDD
- Practical examples for different parts of an application
- TDD in functional testing
- Tools and the specifics of using them in TDD
- Q&A
Past runs
- April 6-7, 2012Kyiv, UkraineTraining: Engineering practices in Agile
- December 15, 2011Kyiv, UkraineConference: XP Days UkraineTraining: Engineering practices in Agile
- July 17, 2010Kyiv, UkraineTraining: Engineering practices in Agile
