Efficient Engineering of Complex Self-Organising Systems by Self-Stabilising Fields

Self-organising systems are notoriously difficult to engineer, particularly due to the interactions between complex specifications and the simultaneous need for efficiency and for resilience to faults and changes in execution conditions. We address this problem with an engineering methodology that separates these three aspects, allowing each to be engineered independently. Beginning with field calculus, we identify the largest known sub-language of self-stabilising programs, guaranteed to eventually attain correct behaviour despite any perturbation in state or topology. Construction of complex systems is then facilitated by identifying "building block" operators expressed in this language, into which many complex specifications can be readily factored, thereby attaining resilience but possibly with improvable efficiency. Efficient implementation may then be achieved by substituting high-performance coordination mechanisms that are asymptotically equivalent to particular applications of building block operators. We illustrate this workflow by construction and simulation of example applications for evacuation alerts and for live estimation of crowd feedback at mass events.

[1]  Jean-Louis Giavitto,et al.  Computations in Space and Space in Computations , 2004, UPP.

[2]  Robin Milner,et al.  Principal type-schemes for functional programs , 1982, POPL '82.

[3]  A. Church A Set of Postulates for the Foundation of Logic , 1932 .

[4]  Jacob Beal,et al.  Organizing the Aggregate: Languages for Spatial Computing , 2012, ArXiv.

[5]  Ryan Newton,et al.  Region streams: functional macroprogramming for sensor networks , 2004, DMSN '04.

[6]  David E. Culler,et al.  Supporting aggregate queries over ad-hoc wireless sensor networks , 2002, Proceedings Fourth IEEE Workshop on Mobile Computing Systems and Applications.

[7]  Shlomi Dolev,et al.  Self Stabilization , 2004, J. Aerosp. Comput. Inf. Commun..

[8]  David E. Culler,et al.  Hood: a neighborhood abstraction for sensor networks , 2004, MobiSys '04.

[9]  Philip Wadler,et al.  Featherweight Java: a minimal core calculus for Java and GJ , 1999, OOPSLA '99.

[10]  Jacob Beal,et al.  Flexible self-healing gradients , 2009, SAC '09.

[11]  Mirko Viroli,et al.  Description and composition of bio-inspired design patterns: a complete overview , 2012, Natural Computing.

[12]  Daniel Coore,et al.  Botanical computing: a developmental approach to generating interconnect topologies on an amorphous computer , 1999 .

[13]  Jacob Beal,et al.  A Calculus of Computational Fields , 2013, ESOCC Workshops.

[14]  Jacob Beal,et al.  Practical Aggregate Programming with Protelis , 2017, 2017 IEEE 2nd International Workshops on Foundations and Applications of Self* Systems (FAS*W).

[15]  S. Strogatz,et al.  Synchronization of pulse-coupled biological oscillators , 1990 .

[16]  Mirko Viroli,et al.  A Calculus of Self-stabilising Computational Fields , 2014, COORDINATION.

[17]  Elizabeth Sklar,et al.  NetLogo, a Multi-agent Simulation Environment , 2007, Artificial Life.

[18]  Jacob Beal,et al.  Fast self-healing gradients , 2008, SAC '08.

[19]  Marjan Mernik,et al.  Formal and Practical Aspects of Domain-Specific Languages: Recent Developments , 2012 .

[20]  Jacob Beal,et al.  Building Blocks for Aggregate Programming of Self-Organising Applications , 2014, 2014 IEEE Eighth International Conference on Self-Adaptive and Self-Organizing Systems Workshops.

[21]  Franco Zambonelli,et al.  Developing pervasive multi-agent systems with nature-inspired coordination , 2015, Pervasive Mob. Comput..

[22]  Jean-Louis Giavitto,et al.  Computation in Space and Space in Computation , 2004 .

[23]  Jacob Beal,et al.  Infrastructure for engineered emergence on sensor/actuator networks , 2006, IEEE Intelligent Systems.

[24]  Jacob Beal,et al.  Protelis: practical aggregate programming , 2015, SAC.

[25]  Radhika Nagpal Programmable self-assembly: constructing global shape using biologically-inspired local interactions and origami mathematics , 2001 .

[26]  Jack Dongarra,et al.  Recent Advances in Parallel Virtual Machine and Message Passing Interface , 1998, Lecture Notes in Computer Science.

[27]  Franco Zambonelli,et al.  Programming pervasive and mobile computing applications: The TOTA approach , 2009, TSEM.

[28]  Message Passing Interface Forum MPI: A message - passing interface standard , 1994 .

[29]  Jacob Beal,et al.  Code Mobility Meets Self-organisation: A Higher-Order Calculus of Computational Fields , 2015, FORTE.