How and why should software designers make ‘continuous design and improvements’ a priority in the development process? This is the question guest blogger Rob James explores in the following guest post. Rob James is a skilled programmer who loves the design process of software development. He can be found blogging about software development, or writing reviews of software (many of which are currently available on the market).
When working on software, it’s important to remember the principle of continuous design, and how it can ultimately benefit a final product. Continued design reflects an approach where different versions of software can be developed through iterative and incremental design for retesting and improvement, rather than being extensively planned out and produced in a linear way. Whether working on commodity trading software or database design, the value of creating, testing, and improving cannot be understated.
More traditional software design processes involve a waterfall model, whereby careful planning takes place at the start of a project’s lifecycle, and is then developed through to a final stage for testing. By comparison, continued design can affect iterative and incremental strategies, as well as evolutionary design and agile models. In this context, less planning is made at the start of a project, and more versions of software developed and testing in a cyclical way.
In this process, developers work on continued testing and changes to a project – the aim here is to learn from testing and feedback of real models, rather than working on a software project through to completion and then having to deal with problems. Redesigning and elaborating on small parts of a software application can depend on extensive alterations in the evolution of a product.
By being more flexible with rapidly developing and troubleshooting prototypes, software companies can fix issues with software during an ongoing lifecycle. This cyclical approach can be useful in terms of widening the number of options for software development as different prototypes are tested, from architecture through to applications, as well as in regards to the end user experience.
In terms of design, incremental approaches to evolving software focuses on continual improvement and the fine tuning of features by going back over the same problems and finding solutions. Each new version is able to benefit from the mistakes of the last, creating what developer Jeremy Miller describes as a ‘process of continuous design that happens throughout the project life cycle.’ Martin Fowler and Pramod Sandalage also advocate an approach to software design where bugs and the general architecture of a project are worked out over time and improved by consistent testing and feedback from users.
Fowler and Sandalage argue that ‘you assume that you cannot fix the requirements of the system up-front’ in the planning stage, but instead have to go through many different versions of a software platform before it gets to where it needs to be. This kind of agile planning can work to embrace change, rather than trying to get everything set up at the beginning of the design process. Fowler and Sandalage go on to suggest that ‘you look at design as an on-going process that is interleaved with construction, testing, and even delivery,’ with software expected to adapt and go through multiple versions before and after it reaches users. By doing so, it’s possible for software designers to make continuous design and improvements an important factor in producing the best possible software.