Here’s a quick review of the terms I have previously noted in my Coursera course: Software Processes and Agile Practices:
Software Process – models that you use to organize development into phases.
Software Practices – techniques or actions that you can use to help manage and track development
Methodologies – are defined groups of practices
Agile Practices and Agile Methodologies – practices and methodologies that are based upon the agile manifesto
One of the software development methodologies that adhere to agile practices is called Extreme Progamming. It is called as such because the practices applied here are taken from other methodologies but to an extreme level.
One fundamental component of this practice is all about client satisfaction. This means that the product manager and the development team will make sure that the client’s needs are met and that the client is as satisfied as possible. However, in a real world scenario, there are various types of clients and the practices of extreme programming does that.
Extreme programming values the following:
- constantly delivering software
- responding to change
- effective team work
Extreme Programming also focuses on these 5 aspects of development:
Extreme programming is also commonly defined by 12 basic principles. These are:
- Planning Game – the client and the development team work together to plan a product following these 3 basic rules.
- They will come up with a list of new features that is expressed as a user story. Then, these will be converted to software requirements & client needs.
- The development team will create estimates for how much effort they allot in the next iteration and how each user story will take to complete.
- The client and the development team will then prioritize user stories, then decide when to release a working version of each feature.
- Small Releases – the release of the product has to be small and as frequent as possible.
- The development team will plan with the client which features make good business sense and can be released early in the project.
- The development team and the client need to find the right balance between what the client wants to complete and what can be developed early.
- System Metaphor – this is a metaphor that the team comes up with to describe the product to a non-technical person and what it does.
- Simple Design – here, the designs has to be as simple as they can be
- Continuous testing – the tests has to be written for a feature or requirement before the source code is written. This adheres to the test-driven development. The idea here is to use the tests as executable forms of requirement. There are 2 ways these features or requirements are tested:
- Acceptance Tests – the client will test each feature of the overall product to see if it works as specified. These tests can be automated or they can be a script of user interface actions that a human follows.
- Unit Tests – these are automated tests written by developers to test lower level functionality.
- Refactoring – this is all about restructuring the design of the code without changing the behavior of the code. It encourages responding to new changes.
- Pair Programming – two developers work side by side at one computer to develop and review the code. This way, the developments will more likely take calculated risks which can lead to innovation because they are not doing it alone.
- Collective Code Ownership – this practice suggest that the software product manager has to encourage the entire development team to contribute new ideas to any part of the product. This means that anyone can add code to any part of the product. With this, whether the product becomes successful or not, the whole team is responsible for it.
- Continuous Integration – this requires the developers to combine their code often and that all tests should pass 100% before and after the integration.
- 40-Hour Work Week – this is encouraging work-life balance among the developers, even with the most passionate ones.
- On-site Customer – this invites the client to be part of the development team and be around anytime to clarify and answer questions about anything that might come up.
- Coding Standards – this means that all developers code to the same standards. This means following a set of common code conventions.
In his first version of the Extreme Programming Rules, Don Wells has laid out 29 extreme programming rules; however, some of those rules are overlapping with the above 12 rules mentioned. There are management practices included in these 29 rules that is also interesting to mention here:
- Give the team a dedicated, open work space.
- Work spaces should have multiple computers that belong to no one.
- These work spaces should be located in the middle of the room and not along the walls to encourage the team to work together.
- There should be a meeting table with white boards where the team can collaborate and brainstorm.
- Move people around.
- This encourages communication and flexible work relationships. This means that everyone knows how to develop and operate all parts of the product.
- Change XP itself.
- This means to fix extreme programming practices when it breaks. When something does not work, change it. By having frequent project retrospective meetings, it will be easy to determine what’s working and what’s not.
As the practice of XP has its benefits, it also has its weakness. These are:
- The individual practices do not have as much value as the overall methodology. But sometimes, implementing all the practices is not practical.
- XP is designed for small development teams.
- There is lack of upfront planning with extreme programming. It does not encourage real upfront software architecture planning.
- Difficulty to arrange an on-site client. In real world, clients won’t always be immediately available.
As such, extreme programming has many great practices for software development, but as a software product manager, it is important to find practices that work for the development team. This is just one of the many methodologies, but for sure, knowing a lot of this methodologies gives an edge for the team to implement what is effective.
University of Alberta (2020). Software Processes and Agile Practices. [Coursera Course] under the Software Product Management Specialization. Taken November 2020.
Patzelt, M. (2020). Extreme Programming. [Video]. Embedded under the course study videos under the Week 3 of the Software Processes and Agile Practices Coursera Course. Taken November 22, 2020.