Extensibility

Extensibility is a software engineering and systems design principle that provides for future growth. Extensibility is a measure of the ability to extend a system and the level of effort required to implement the extension. Extensions can be through the addition of new functionality or through modification of existing functionality. The principle provides for enhancements without impairing existing system functions.

An extensible system is one whose internal structure and dataflow are minimally or not affected by new or modified functionality, for example recompiling or changing the original source code might be unnecessary when changing a system’s behavior, either by the creator or other programmers. Because software systems are long lived and will be modified for new features and added functionalities demanded by users, extensibility enables developers to expand or add to the software’s capabilities and facilitates systematic reuse. Some of its approaches include facilities for allowing users’ own program routines to be inserted and the abilities to define new data types as well as to define new formatting markup tags.

Extensible design in software engineering is to accept that not everything can be designed in advance. A light software framework which allows for changes is provided instead. Small commands are made to prevent losing the element of extensibility, following the principle of separating work elements into comprehensible units, in order to avoid traditional software development issues including low cohesion and high coupling and allow for continued development. Embracing change is essential to the extensible design, in which additions will be continual. Each chunk of the system will be workable with any changes, and the idea of change through addition is the center of the whole system design. Extensible design supports frequent re-prioritization and allows functionality to be implemented in small steps upon request, which are the principles advocated by the Agile methodologies and iterative development. Extensibility imposes fewer and cleaner dependencies during development, as well as reduced coupling and more cohesive abstractions, plus well defined interfaces.

Fickleness lies at the basis of all software because of human phenomena since software is an "evolving entity" which is developed and maintained by human beings, yielding ongoing system changes in software specification and implementation. Components of a software are often developed and deployed by unrelated parties independently. Adaptable software components are necessary since components from external vendors are unlikely to fit into a specific deployment scenario off-the-rack, taking third party users other than the manufacturer into consideration. Many software systems and software product-lines are derived from a base system, which share a common software architecture or sometimes large parts of the functionality and implementation but are possibly equipped with different components that require an extensible base system.

Building software systems that are independently extensible is an important challenge. An independently extensible system not only allows two people to independently develop extensions to the system, but also allows the two extensions to be combined without a global integrity check.

There are three different forms of software extensibility: white-box extensibility, gray-box extensibility, and black-box extensibility, which are based on what artifacts and the way they are changed.

Under this form of extensibility, a software system can be extended by modifying the source code, and it is the most flexible and the least restrictive form. There are two sub-forms of extensibility, open-box extensibility and glass-box extensibility, depending on how changes are applied.

Changes are performed invasively in open-box extensible systems; i.e. original source code is directly being hacked into. It requires available source code and the modification permitted source code license. Open-box extensibility is most relevant to bug fixing, internal code refactoring, or production of next version of a software product.