This is the ninth of 12 posts about the principles of agile software development. The purpose is to go back to the start of the agile manifesto (http://agilemanifesto.org/principles.html) and discuss the implementation of the 12 principles in real-life software engineering. Goals of agility are to go deliver software of higher quality, faster, with a higher acceptance to end-users and able to follow the changing business requirements to strive for competitive advantage.
The question is: is this going to work in practice or is this only based on a nice marketing and sales story.
Principle 9: Continuous attention to technical excellence and good design enhances agility.
The first time I looked at this principle I thought: “How is this possible”. Agility focuses on quickly delivering working software (reading: “Quick and dirty”). I experienced this is not true. Attention to technical excellence is making the agile process working better. Technical excellence can make the development process more flexible. In this context, I would like to point out that there is a difference between technical excellence / good design compared to complex design and technical complexity. How many developers, designers and architects (the ivory tower / PowerPoint architects) cannot resist creating complex designs, patterns and code with no other purpose than to show off their technical superiority? How many projects have stranded in complex designs and abstract meta-models without creating any business value? These projects are good to be displayed in the Museum Of Modern Software Development but completely useless in the real world.
Smart technology and smart design
Every developer, architect and designer must work with principles of smart design in their minds. In my opinion there are only two principles: 1) the concept must work and 2) other team members understand and are able apply the principle.
Smart technology and good design has its greatest advantage when it is used for the benefit of the whole application and the whole team. Not just for sub-optimal improvements for a single function or a single developer. Good excellent technology and good design has to make coding easy and the application modular, more flexible and adaptable. By using the right frameworks and supporting tools you are able to deliver higher quality software much faster than you where used to. In practice this means using frameworks for common tasks like authorization, persistence and navigation and tools for building, releasing and deploying your application.
In fact all tasks, that are labor-intensive and demand a lot of concentration and focus, are likely candidates to be implemented via frameworks and tools.
Monitoring and evaluation
Within your team you have to monitor the correct application of design and technology. Your project has to have several review moments where the application of design patterns and technology is reviewed. The deviations from the design must be corrected or (when approved) provided with extra documentation. Besides reviewing the correct application of standards in design and technology you have to be able to review the correctness of the chosen technology. This is not something you do every day (or week). But occasionally it is wise to check if you are on the right pathway. There is nothing wrong with concluding the chosen technology does not fit the goal anymore. This can be the result of growing insight in the technology or the result of the growing size in the application itself. Perhaps it was wise to start the project with an easy and straightforward solution. After a while the applications functionality grew and a more advanced solution was needed. This is the moment where you review the technology and jointly decide to choose something else. Make sure you have a working alternative and this alternative is in line with smart principles (working and understandable).
Automating repetitive jobs
Choose the right technology to make your work more easy and interesting. Repetitive jobs can and must be automated. This to ensure the tasks are performed correctly and complete every time and to reduce the costs. Use these frameworks combined with a continuous build environment to maximize the agility of your development environment.
Good design and excellent technology are the enablers of the agility of your development environment. Make sure you choose the right technology and the right design and not the most complex and cutting edge. This means that the choices you make have to comply with the principles: understandable and working. The choices you make have to support business value and not just the curiosity of the technology expert. With the right design and the right technology, you are able to develop and deliver fast with higher quality.
Other posts about the AGILE Principles (soon to come):
- Our highest priority is to satisfy the customer through early and continuous delivery of valuable software.
- Welcome changing requirements, even late in development. Agile processes harness change for the customer’s competitive advantage.
- Deliver working software frequently, from a couple of weeks to a couple of months, with a preference to the shorter timescale.
- Business people and developers must work together daily throughout the project.
- Build projects around motivated individuals. Give them the environment and support they need, and trust them to get the job done.
- The most efficient and effective method of conveying information to and within a development team is face-to-face conversation.
- Working software is the primary measure of progress.
- Agile processes promote sustainable development. The sponsors, developers, and users should be able to maintain a constant pace indefinitely.
- Continuous attention to technical excellence and good design enhances agility.
- Simplicity–the art of maximizing the amount of work not done–is essential.
- The best architectures, requirements, and designs emerge from self-organizing teams.
- At regular intervals, the team reflects on how to become more effective, then tunes and adjusts its behavior accordingly.