The importance of tech excellence — there’s more in agility than only ceremonials
Technical excellence and codebase’s complexity
Agility can be defined as a user-centric software development process that aims at delivering software in small batches to the end-user in order to get fast feedbacks and to generate knowledge.
Technical excellence consists of practices enabling softwares, products, applications, to be delivered fast, with high quality and be maintained without prohibitive costs in the long run.
In the context of this article, technical excellence will refer to three main areas, the constant focus on maintaining a high level of exigence on these aspects:
— Decoupled architecture: the architecture consists of modular and independant components that are consistent functionnally ; one component serves different features and changing one feature of one component can be done in isolation from other components:
— Self-testing development: developers are continuously implementing tests in order to validate that the code written has the expected behavior; TDD appears to be the most effective technic to do it
— Automated deployment and continuous integration: codebase evolutions are merged as soon as possible (several times a day) and automatically deployed on prod-like environment to be tested (with automatic tests and manual — exploratory tests as well)
As you develop more and more features, the codebase gets bigger, it’s getting hard to understand it as a whole and all the interactions in it. These practices will help you control the increase of your codebase’s complexity:
— Decoupled architecture keep changes localized, therefore complexity remains localized as well on a limited scope
— Self-testing development forces you to keep small testable unities, along with decoupled architecture; furthermore you can detect regressions as soon as they arrive and help you knowing exactly the behavior of your system at all times
— Automated deployment and continuous integration will help you focus on value-added tasks and synchronize teams regularly withou having to perform quick & dirty hot fixes because you deferred the painful integration of codebase’s evolutions
Antipattern: agility without technical excellence
At the beginning of a project, there might be a lot of enthusiasm. Delivery is fast in the beginning; agile processes enable the team to be very dynamic; users are happy to see features arriving “fast”
But if you haven’t been careful about the technical excellence the complexity of codebase grows,
— 1 as you don’t automate test and still want to ship quickly to users, defects will begin to come and their number will grow;
— 2 as you don’t automate deployment and implement CI, merges will get more and more painful and therefore you will naturally lean on doing them less often;
— 3 with an intrincated architecture, developing a new feature gets complicated because it might have impacts on other part of your application; therefore (i) you’re reluctant to developing them, (ii) when you do so, inexplicable regressions might occur (and you’ll have difficulties identifying them without automated tests)
All is then gathered to have a nice vicious circle:
How your agile development process can benefit from technical excellence
Self-testing development will give you:
— Better design through TDD approach, among other reasons because in order to have an effective testing strategy, tests must run fast and therefore testable units must be small and decoupled from each other
— Faster feedback, because you don’t need to wait for painful merges or deployments and then for manual acceptance tests to check if your code behaves as expected, you can see it (and fix it) right away
— Maintainability in the end, with an effective automated test suites, 1 there are less bugs because the system is defect free; 2 the test suite is a safe guard preventing you from changing behavior unpurposedly, quite the opposite it will help you continuously refactoring
Automated deployment / continuous integration:
— It enables your teams to focus on the value-added task of developing feature for the end-user instead of (i) manually provisioning and deploying software; (ii) trying to fix all the defects happening because of a “merge hell”
— You can figure out more rapidly your software’s behavior in “live conditions” because you can directly deploy it in prod-like environments
— Make deployments and integration less painful because performed more often [(1) more used to it; (2) changes are smaller); (3) users give feedback more frequently]
Through a decoupled architecture:
— Components are better isolated and therefore changes are located and so are their potential pbs. Therefore it’s way easier to add more and more features for users
— With hexagonal architecture paradigm, business rules / business invariants are properly housed and protected which helps you focusing on business complexity without having to deal with “details” like data persistance or view aspects
What are the benefits for you?
In the end, you are winning on all sides:
On the technical side, it’s easier to develop new features and it’s actually the one thing expected from software, namely being easy to make change.
On the people side:
— Users are more satisfied because they were able to give feedback regularly and the software given to them is reliable and efficient,
— Teams are more engaged because they enjoy building new features instead of fixing bugs, moreover they can be proud of their work
On the financial side: costs are more predictible and controllable, revenues keep on increasing because satisfied users retain and refer to other people.
If you are willing to make agility right with us, join us: https://careers.loreal.com/fr_FR/content/HOME.
Interested about tech like us? Get in touch with us and stay tuned for more article to come.
