![AGILE ENGINEERING PRACTICES
Behavior Driven Development [BDD]
•Behavior Driven Development (or BDD) is an approach
that gets team members to collaborate on describing the
Behaviors of the user story or product feature they’re
attempting to build.
•The Behaviors are described with a series of examples,
written in a language that users would be able to understand,
that each prove one point about the feature or User Story.](https://image.slidesharecdn.com/agileengineeringpractices-241209143119-5095d8ba/85/Introduction-to-Agile-Engineering-Practices-pptx-9-320.jpg)
![AGILE ENGINEERING PRACTICES
Behavior Driven Development [BDD]
•BDD improves quality and reduce defects since
it ensures that several team members agreed on
the problem that needed solving.](https://image.slidesharecdn.com/agileengineeringpractices-241209143119-5095d8ba/85/Introduction-to-Agile-Engineering-Practices-pptx-10-320.jpg)
Introduction to Agile Engineering Practices.pptx
- 2. AGILE METHODOLOGIES HAFIZ MUHAMMAD IRFAN
- 4. AGILE ENGINEERING PRACTICES •In Agile Engineering, teams quickly iterate, test, and gather feedback on product design. •It divides big challenges into measurable chunks of work and promises more accurate and rapid product development cycles. •Teams are self-managed and work in short two-week sprints driven by user feedback. •This feedback guides teams to build a product that meets user needs.
- 5. AGILE ENGINEERING PRACTICESLE • Rather than start with a lengthy requirements phase that covers the entire span of the project, requirements are created as the team works. • Requirements are specific and tied to user value. • By testing features and new builds, teams verify if they are solving user problems and developing the right product.
- 6. AGILE ENGINEERING PRACTICES •In software development, the single best way to improve quality, and eventually speed, is writing less code. •Most of the time spent writing code should be to understand the problem and then find the simplest solution to it. •The practices used to facilitate this in Agile software development are popularly known as Agile Engineering Practices.
- 7. AGILE ENGINEERING PRACTICES • Behavior Driven Development • Collective Code Ownership • Continuous Delivery • Continuous Integration • Emergent/Evolutionary Architecture • Mob Programming • Pair Programming • Refactoring • 10 Minute Build • Test Driven Development • Trunk-Based Development • Unit Testing
- 9. AGILE ENGINEERING PRACTICES Behavior Driven Development [BDD] •Behavior Driven Development (or BDD) is an approach that gets team members to collaborate on describing the Behaviors of the user story or product feature they’re attempting to build. •The Behaviors are described with a series of examples, written in a language that users would be able to understand, that each prove one point about the feature or User Story.
- 10. AGILE ENGINEERING PRACTICES Behavior Driven Development [BDD] •BDD improves quality and reduce defects since it ensures that several team members agreed on the problem that needed solving.
- 11. AGILE ENGINEERING PRACTICES Collective Code Ownership •Collective Code Ownership is the premise that the whole team owns the code. •Anyone on the team can add new features, fix a bug, write a test case, or refactor.
- 12. AGILE ENGINEERING PRACTICES Continuous Delivery • Continuous Delivery is the game of delivering features to Production whenever a change is made. • It shortens the feedback, and even the payment cycle, because you are delivering product more frequently. • Because the steps are run multiple times a Sprint, teams need to automate all of the steps along the way to deployment.
- 13. AGILE ENGINEERING PRACTICES • In some organizations, a human (or the Product Owner ) 😉 decides with each build if enough additional value has been created to be worth deploying. • This approach tends to be a sub-optimization. • Along with the feedback benefits, Continuous Delivery also reduces risk since each deployment is smaller and therefore, if there is a problem, it can be rolled back and found more easily.
- 14. AGILE ENGINEERING PRACTICES Agile Architecture • Agile Architecture emphasizes the minimum amount of design upfront, and focusing on building something and evolving the architecture as our understanding changes. • Architecture in software development is often defined as relationships between the parts in a system.
- 15. AGILE ENGINEERING PRACTICES Agile Architecture • Traditional approaches to software architecture emphasize Big Upfront Design – get it right at the start. • The problem, of course, is that requires us to foresee all architectural considerations (scale, security, fault tolerance, fault recovery) at the moment when our understanding of our problems is at its weakest. • Agile Architecture allows for the design to evolve and adapt as more is learned about what is needed.
- 16. AGILE ENGINEERING PRACTICES Mob Programming • Mob Programming (perhaps better called Ensemble Programming) is the logical extension of Pair Programming. • The entire team work together to deliver a single Product Backlog Item (or User Story). • They work using the same computer, at the same time. • They do all of the steps of their development process together, from requirements -> code -> testing (and any other steps you want).
- 17. AGILE ENGINEERING PRACTICES Mob Programming • Because the entire team focused on one story at a time, then it is truly Limiting WIP(Work in Progress). • Furthermore, teams that do this tend to have higher throughput because of better quality. • This also helps with knowledge sharing and cross-skilling.
- 18. AGILE ENGINEERING PRACTICES Pair Programming • Pair Programming is when two people write code together on one machine. • It helps improve code quality, readability, and simplicity. • Not only is it an on-the-fly code review, since it has two pairs of eyes looking it over, but it is also a form of design review, thereby beating regular code reviews on several fronts. • Pairing also helps with Sprint progress by moving the focus to completing stories and limiting the WIP.
- 19. AGILE ENGINEERING PRACTICES Refactoring • Refactoring is the process of restructuring existing code without changing its external Behavior. • Refactoring is done to improve the simplicity and readability of a piece of code. Most refactoring are simple (e.g. rename method, extract method, etc.) and have been automated by modern development tools to guarantee safety/correctness. • A refactoring is like renaming a section header in a document to better convey the core idea to the reader, or splitting a large, unwieldy paragraph into smaller parts.
- 20. AGILE ENGINEERING PRACTICES 10 Minute Build • 10 Minute Build is the idea that we should be able to build a system and run its test suites in 10 minutes or less. • Fast build-and-test provides quicker feedback to the developers who wrote the code. • It allows them to move on to the next thing – a new feature or improving the current one.
- 21. AGILE ENGINEERING PRACTICES 10 Minute Build • 10 Minute Build is the idea that we should be able to build a system and run its test suites in 10 minutes or less. • Fast build-and-test provides quicker feedback to the developers who wrote the code. • It allows them to move on to the next thing – a new feature or improving the current one.
- 22. AGILE ENGINEERING PRACTICES 10 Minute Build • In comparison, when builds are slow, Developers wander off to do new things while waiting (must See: Multitasking), which results in increased cost to go back and fix defects when they’re found later in the build, especially since longer builds are run less often so it will take longer to find errors.
- 23. AGILE ENGINEERING PRACTICES Test Driven Development (TDD) • Test Driven Development (TDD) is the engineering practice where the developer writes their Unit Test case before they write their code. • Like Unit Testing, it is not a replacement for Exploratory Testing nor will Testers be unemployed. • Instead, it forces a Developer to declare their intentions before they start to write the code.
- 24. AGILE ENGINEERING PRACTICES Trunk Based Development • Git, Mercurial and other source control tools provide robust and easy to use branching capabilities. • For work with Open-Source software —where anyone could be a contributor and the environment is low trust the use of branches is useful. • For modern Agile teams attempting to continually improve (refactor) the code and use tools like Continuous Integration, Continuous Delivery etc, long-lived (> 1 day) branches just add
- 25. AGILE ENGINEERING PRACTICES Unit Testing • Unit Testing is the process of writing small, code-level tests that prove that the method did what the developer intended when the test was written. • Well-written Unit Tests test only one specific aspect or path through a single method. • a Unit Test is simply a tool to help a developer discover if they built what they intended to. • Running Unit Tests frequently (usually every 10 -15 minutes) will give quick feedback if changes have harmed the behavior of some other part of the code.