Manifesto for Adaptable Software Development

We believe that the activities in the left are required to face the challenges of modern software development.

Experimentation instead of Specification
Evolution instead of Implementation
Adaptation instead of Modification
Extension instead of Growth

Perhaps the activities in the right were once good enough, but they are not adequate to the new reality of building complex software systems.

Experimentation instead of Specification

Traditional software development focuses on the detailed specification of system requirements, functional and non-functional. Modern software development should allow the discovery of requirements through experimentation. For example, a Lean approach allows us to build a Minimum Viable Product (MVP) while delaying decisions until the Last Responsible Moment. Sound engineering practices are necessary to build flexible software platforms to support cost-effective experimentation.

Evolution instead of Implementation

Traditional software development focuses on the prioritized implementation of features according to the specified requirements. Modern software development should allow the constant evolution of the system’s functionality to meet the dynamically varying customer needs. For example, Domain Modeling allows us to capture the essential aspects of an application while enabling future specializations. Domain knowledge is necessary to define the central entities and relationships that will remain stable during the system’s evolution.

Adaptation instead of Modification

In traditional software development, code must be modified in order to meet changing requirements. Modern software development should allow the existing code base to be easily adapted to satisfy any change in requirements. For example, Frameworks allow us to have several alternative components that may be chosen according to current needs. The design of a good Framework should be such to eliminate completely the dependency on concrete components.

Extension instead of Growth

In traditional software development, the system must grow in order to accommodate additional requirements. Modern software development should allow the easy extension of the system’s functionality through modular features. For example, Plug-ins allow us to add new features to an existing application without increasing its size and complexity. The design of a good Plug-in should be such that does not expose details about the system being extended nor the Plug-in extending it.

Do you agree? Please share your comments below.

About Hayim Makabee

Veteran software developer, enthusiastic programmer, author of a book on Object-Oriented Programming, co-founder and CEO at KashKlik, an innovative Influencer Marketing platform.
This entry was posted in Adaptable Design, Agile, Lean Development, Software Architecture, Software Evolution and tagged , , , , . Bookmark the permalink.

5 Responses to Manifesto for Adaptable Software Development

  1. putchavn says:

    Yes, that is a good approach but it should not be applied to ALL software development and all phases of software development.

    Identification of what to develop, how much of it should be new and how much can be reused from the work already done (and found effective and efficient) are crucial aspects of engineering effort.. Of course, this itself may involve “quick and dirty prototyping” but only in parts and only for some selected phases of development.

    IMO the Agile or Adaptable what is now proposed would fail if they are NOT judiciously applied to selected parts / phases of development. Goals and Planning are vital and should not be thrown to winds in the excitement of quick action.

  2. jconne says:

    Is this like Toyota building to standards and changing the standards as often as improvements are identified?

  3. Dan Prince says:

    Nicely said. Thank you for posting.

    While I agree with what putchavn said I also believe that any greenfield development of a system should utilize this approach.

  4. Andy Ng says:

    This is a good approach and is the core of what I also believe in too. Every system has a core, take Maven as an example, the core is a standardized build process and you use plugins or write the customised plugins to extends it to your specific build requirements.

  5. Pingback: A Collection of Manifestos

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s