Non-Concept Software Subsystems: Tangible and Intangible

Concepts modified by a Non- prefix apparently denote a negation, an opposite of the concept without this prefix. But, generally the situation is rather subtle: non- implies only partial negation and the concept suggests preserved identity with some reduced quality or absent attribute. In this work tangible and intangible software subsystems based upon Non- concepts are defined and pluggable ontologies are proposed for their representation. Pluggable ontologies are a kind of nano-ontologies, which by their minimal size facilitate fast composition of new software subsystems. These ontologies are made pluggable by Design Sockets, a novel kind of class. These are abstract connectors for removed/added parts, functionalities or identities, and for subdued qualities. Design Sockets are the basis of a Design Pattern for dynamically modifiable software systems. Pragmatic implications of Non- concepts include manageable design of product lines with multiple models. Non- concepts are also relevant to the controversy whether composition is or is not identity. The resolution is not sharp. Identity is entangled with composition, and is preserved to a certain extent, until further removal causes identity breakdown.

💡 Research Summary

The paper begins by re‑examining the linguistic and philosophical semantics of the prefix “Non‑”. Unlike a pure negation, “Non‑” signals a partial reduction or suppression of a property while preserving the underlying identity of the concept to a limited degree. This nuanced view is then transferred to software engineering, where the authors argue that many architectural decisions are not binary “add” or “remove” operations but rather involve the selective weakening or disabling of existing capabilities.

Building on this premise, the authors categorize software subsystems into two orthogonal families: tangible subsystems, which consist of concrete artefacts such as code modules, APIs, databases, and services; and intangible subsystems, which are abstract entities like policies, contracts, quality attributes, and design principles. By attaching “Non‑” to a subsystem name (e.g., “Non‑Persistent Cache”, “Non‑Blocking Transaction”), designers can explicitly denote that the subsystem implements a reduced version of the original functionality rather than a completely different one. This naming convention makes the design intent transparent and supports systematic reasoning about partial feature removal.

The technical contribution consists of two intertwined mechanisms. First, the authors introduce “plug‑able ontologies”, a class of ultra‑compact “nano‑ontologies” that encode a concept, its attributes, and its relationships in a handful of RDF‑style triples. Because of their minimal size, these ontologies can be loaded, swapped, or discarded at runtime with negligible overhead, enabling dynamic reconfiguration of both tangible and intangible subsystems. Second, they define a novel class called a “Design Socket”. A Design Socket abstracts the insertion point of a removed, added, or replaced part of a system. It is characterised by three axes: input (required capabilities), output (provided services), and constraints (quality, security, performance limits). A concrete “plug” that occupies a socket implements a specific Non‑subsystem; swapping plugs changes the system’s behaviour while the surrounding architecture remains stable.

The Design Socket pattern yields a family of dynamically modifiable software systems. In a micro‑service scenario, for instance, a socket might host a “Non‑Secure Communication” plug that can later be replaced with a “Non‑Encrypted Communication” plug, thereby lowering security guarantees without breaking client‑server contracts. Similarly, intangible plugs can encode policy changes, SLA adjustments, or performance targets, allowing these high‑level concerns to be altered at the metadata level rather than by recompiling code.

Beyond the engineering benefits, the paper engages with the long‑standing debate on whether composition destroys identity. By demonstrating that partial reductions preserve a “soft” identity until a critical threshold is crossed (e.g., the complete removal of a core capability), the authors propose a continuum model of identity: systems retain a recognizable core while peripheral attributes may be toggled on or off. This perspective offers a more flexible foundation for product‑line engineering, where multiple product variants share a common backbone but diverge through selective application of Non‑subsystems.

Finally, the authors argue that the concepts introduced are broadly applicable to contemporary paradigms such as plugin‑based architectures, model‑driven engineering, and feature‑toggle frameworks. By formalising “Non‑” as a first‑class design construct, providing ultra‑lightweight ontologies for rapid composition, and offering Design Sockets as abstract connectors, the paper equips architects with a systematic toolbox for building systems that can evolve incrementally, adapt to new requirements without wholesale rewrites, and manage the trade‑off between flexibility and identity preservation. The overall contribution lies in shifting the mindset from binary addition/removal toward a spectrum of partial modification, thereby reducing maintenance costs and enhancing the agility of large‑scale software ecosystems.