Dynamic Self-Assembly of Hierarchical Software Structures/Systems

We present initial results on achieving synthesis of complex software systems via a biophysics-emulating, dynamic selfassembly scheme. This approach offers novel constructs for constructing large hierarchical software systems and reusing parts of them. Sets of software building blocks actively participate in the construction and subsequent modification of the larger-scale programs of which they are a part. The building blocks interact through a software analog of selective protein-protein bonding. Self-assembly generates hierarchical modules (including both data and executables); creates software execution pathways; and concurrently executes code via the formation and release of activitytriggering bonds. Hierarchical structuring is enabled through encapsulants that isolate populations of building block binding sites. The encapsulated populations act as larger-scale building blocks for the next hierarchy level. Encapsulant populations are dynamic, as their contents can move in and out. Such movement changes the populations of interacting sites and also modifies the software execution. "External overrides", analogous to protein phosphorylation, temporarily switch off undesired subsets of behaviors (code execution, data access/modification) of other structures. This provides a novel abstraction mechanism for code reuse. We present an implemented example of dynamic selfassembly and present several alternative strategies for specifying goals and guiding the self-assembly process. Self-assembling Software Background Dynamic self-assembly is a ubiquitous process in nonequilibrium physical and biological systems (Whitesides and Grzybowski, 2002). We are developing an approach to create artificial systems that dynamically self-assemble into hierarchical structures. We are interested more broadly in physical realizations of such processes and how computational capability emerges in biological systems. As a first step, we are developing dynamically-selfassembling software systems that are modeled after physical systems and physical self-assembly processes. This paper is our first report on this research direction. We have developed the infrastructure to allow software selfassembly processes to occur, and provide an example of the use of this approach to self-assemble and modify software modules. A central result here is that a variety of software selfassembly processes become available by emulating physical self assembly. As we describe below, physicsemulating self-assembly can generate data structures, multiple kinds of executable code structures, dynamic execution pathways, hierarchies of software modules, movement of modules within the hierarchy and triggers that execute or inhibit certain code structures. These processes can also dismantle any structure that has been assembled. The concept of bonding is a central part of our approach. We translate the physical notions of bonding, as they occur in biology (i.e. strong covalent bonds and weak proteinprotein bonds), into software. Our “strong” software bonding mechanism directly builds long-lived software structures. These lead to software structures with parts that execute sequentially and deterministically. “Weak” bonding is a more active process that not only assembles executable software structures but also triggers their execution. The weakly-bonded structures and the code execution pathways associated with them are transient. Further, weak bonds can be used to interfere with the action of other bonding processes on the same structure. This type of override is analogous to protein phosphorylation. This provides functionality that is distinct from object-oriented inheritance as it allows removal of unwanted functionality from the “outside” of the existing software structure. This additional flexibility may be useful for enhancing software reuse. The detailed implementation of these ideas is described in a later section.