1,721,080 research outputs found
Declarative Macro-Programming of Collective Systems with Aggregate Computing: An Experience Report
No full textMassive deployments of devices across all kinds of environments pose the need for engineering their collaborative, macro-level behaviour. To address this challenge, so-called macro-programming approaches have emerged. A prominent nature-inspired example of macro-programming is aggregate computing. In aggregate computing, macroscopic and self-organising behaviour is declared as a functional manipulation of computational fields. Fields are macro-level abstractions mapping devices to values over time, whose computation details, typically based on an execution model of asynchronous sense-compute-interact rounds, are abstracted. In more than ten years of research, multiple software engineering concerns in aggregate computing systems have been investigated, addressing aspects at the level of the language, execution dynamics, middleware, and deployment. Arguably, the enabling factor for many of such investigations and results is precisely the declarative nature of the aggregate computing paradigm. In this experience report, we analyse aggregate computing through the lenses of declarative programming, and draw significant insights and perspectives related to the engineering of complex adaptive systems
MacroSwarm: A scala framework for swarm programming
Full text linkProgramming swarm behaviors is a challenging task, due to the need to express collective behaviors in terms of local interactions among simple agents. Even if several programming frameworks have been proposed, they are often based on low-level abstractions, which makes the development of swarm applications complex and error-prone. Thus, we present MacroSwarm, an aggregate programming framework for the development of swarm behaviors. With this framework, it is possible to define a large variety of swarm behaviors, starting from simple movements to more complex ones, such as aggregation, flocking, and collective decision-making. In this paper, we present the main features of the framework and some simple examples of its API usage
MacroSwarm: A Field-Based Compositional Framework for Swarm Programming
Full text linkSwarm behaviour engineering is an area of research that seeks to investigate methods for coordinating computation and action within groups of simple agents to achieve complex global goals like collective movement, clustering, and distributed sensing. Despite recent progress in the study and engineering of swarms (of drones, robots, vehicles), there is still need for general design and implementation methods that can be used to define complex swarm coordination in a principled way. To face this need, this paper proposes a new field-based coordination approach, called MacroSwarm, to design fully composable and reusable blocks of swarm behaviour. Based on the macroprogramming approach of aggregate computing, it roots on the idea of modelling each block of swarm behaviour by a purely functional transformation of sensing fields into actuation description fields, typically including movement vectors. We showcase the potential of MacroSwarm as a framework for collective intelligence by simulation, in a variety of scenarios including flocking, morphogenesis, and collective decision-making
Machine Learning for Aggregate Computing: a Research Roadmap
Full text linkAggregate computing is a macro-approach for programming collective intelligence and self-organisation in distributed systems. In this paradigm, a single 'aggregate program' drives the collective behaviour of the system, provided that the agents follow an execution protocol consisting of asynchronous sense-compute-act rounds. For actual execution, a proper aggregate computing middleware or platform has to be deployed across the nodes of the target distributed system, to support the services needed for the execution of applications. Overall, the engineering of aggregate computing applications is a rich activity that spans multiple concerns including designing the aggregate program, developing reusable algorithms, detailing the execution model, and choosing a deployment based on available infrastructure. Traditionally, these activities have been carried out through ad-hoc designs and implementations tailored to specific contexts and goals. To overcome the complexity and cost of manually tailoring or fixing algorithms, execution details, and deployments, we propose to use machine learning techniques, to automatically create policies for applications and their management. To support such a goal, we detail a rich research roadmap, showing opportunities and challenges of integrating aggregate computing and learning
Low-code design of collective systems with ScaFi-Blocks
No full textScaFi-Blocks is a visual, low-code programming environment for designing and implementing swarm algorithms. Built on the ScaFi aggregate computing framework and the Blockly visual programming library, ScaFi-Blocks enables users to visually compose algorithms using intuitive building blocks, abstracting away the complexities of traditional swarm programming frameworks. This approach simplifies the development of collective behaviours for a wide range of swarm systems, including robot swarms, IoT device ensembles, and sensor networks, fostering broader accessibility and innovation within the field. This contribution bridges the gap between visual programming and textual code, lowering the barrier to entry for non-experts while promoting a deeper understanding of aggregate computing principles
A programming approach to collective autonomy
Full text linkResearch and technology developments on autonomous agents and autonomic computing promote a vision of artificial systems that are able to resiliently manage themselves and autonomously deal with issues at runtime in dynamic environments. Indeed, autonomy can be leveraged to unburden humans from mundane tasks (cf. driving and autonomous vehicles), from the risk of operating in unknown or perilous environments (cf. rescue scenarios), or to support timely decision-making in complex settings (cf. data-centre operations). Beyond the results that individual autonomous agents can carry out, a further opportunity lies in the collaboration of multiple agents or robots. Emerging macro-paradigms provide an approach to programming whole collectives towards global goals. Aggregate computing is one such paradigm, formally grounded in a calculus of computational fields enabling functional composition of collective behaviours that could be proved, under certain technical conditions, to be self-stabilising. In this work, we address the concept of collective autonomy, i.e., the form of autonomy that applies at the level of a group of individuals. As a contribution, we define an agent control architecture for aggregate multi-agent systems, discuss how the aggregate computing framework relates to both individual and collective autonomy, and show how it can be used to program collective autonomous behaviour. We exemplify the concepts through a simulated case study, and outline a research roadmap towards reliable aggregate autonomy
MacroSwarm: A Field-based Compositional Framework for Swarm Programming
Full text linkSwarm behaviour engineering is an area of research that seeks to investigate methods and techniques for coordinating computation and action within groups of simple agents to achieve complex global goals like pattern formation, collective movement, clustering, and distributed sensing. Despite recent progress in the analysis and engineering of swarms (of drones, robots, vehicles), there is still a need for general design and implementation methods and tools that can be used to define complex swarm behaviour in a principled way. To contribute to this quest, this article proposes a new field-based coordination approach, called MacroSwarm, to design and program swarm behaviour in terms of reusable and fully composable functional blocks embedding collective computation and coordination. Based on the macroprogramming paradigm of aggregate computing, MacroSwarm builds on the idea of expressing each swarm behaviour block as a pure function, mapping sensing fields into actuation goal fields, e.g., including movement vectors. In order to demonstrate the expressiveness, compositionality, and practicality of MacroSwarm as a framework for swarm programming, we perform a variety of simulations covering common patterns of flocking, pattern formation, and collective decision-making. The implications of the inherent self-stabilisation properties of field-based computations in MacroSwarm are discussed, which formally guarantee some resilience properties and guided the design of the library
Aggregate centrality measures for IoT-based coordination
Full text linkCollecting statistics from graph-based data is an increasingly studied topic in the data mining community. We argue that they can have great value in the coordination of dynamic IoT systems as well, especially to support complex coordination strategies related to distributed situation recognition. Thanks to a mapping to the field calculus, a distribution coordination model proposed for collective adaptive systems, we show that many existing “centrality measures” for graphs can be naturally turned into field computations that compute the centrality of nodes in a network. Not only this mapping gives evidence that the field coordination is well-suited to accommodate massively parallel computations over graphs, but also it provides a new basic “brick” of coordination which can be used in several contexts, there including improved leader election or network vulnerabilities detection. We validate our findings by simulation, first measuring the ability of the translated algorithm to self-adjust to network changes, then investigating an application of centrality measures for data summarisation
Towards Reinforcement Learning-based Aggregate Computing
Full text linkRecent trends in pervasive computing promote the vision of Collective Adaptive Systems (CASs): large-scale collections of relatively simple agents that act and coordinate with no central orchestrator to support distributed applications. Engineering global behaviour out of local activity and interaction, however, is a difficult task, typically addressed by try-and-error approaches in simulation environments. In the context of Aggregate Computing (AC), a prominent functional programming approach for CASs based on field-based coordination, this difficulty is reflected in the design of versatile algorithms preserving efficiency in a variety of environments. To deal with this complexity, in this work we propose to apply Machine Learning techniques to automatically devise local actions to improve over manually-defined AC algorithms specifications. Most specifically, we adopt a Reinforcement Learning-based approach to let a collective learn local policies to improve over the standard gradient algorithm—a cornerstone brick of several higher-level self-organisation algorithms. Our evaluation shows that the learned policies can speed up the self-stabilisation of the gradient to external perturbations
Declarative Deployment Planning for Green Pulverised Collective Computational Systems
No full textTo promote non-functional goals (e.g., energy efficiency and reactivity) in system implementations, multiple strategies can be adopted, including the partitioning of distributed applications and the smart deployment of the resulting sub-components across the edge-cloud continuum. Within the aggregate computing approach to collective adaptive systems engineering (e.g., IoT ecosystems and robot swarms), the pulverisation model of partitioning and deployment works by splitting the collective computation into device computation rounds and in turn the device computation round in terms of five components: sensing, actuation, behaviour, state, and communication components. Previous research has investigated how different deployments of pulverised systems can provide different trade-offs involving performance and efficiency, with methodologies and simulation tools to carry out the comparison. However, there is still no contribution about the generation or search of effective deployments in the first place. To address this gap, this work introduces Declarative Deployment Planning for Pulverised Systems (DePPS), an approach and toolchain based on simulation and a Prolog-based planner to guide the search of candidate deployments of pulverised systems. The benefits of the approach lie in its declarativity, modularity, scalability, and amenability for continuous reasoning of deployment alternatives. We exercise the approach with synthetic experiments and find out that we can achieve “greener” deployments (i.e., with low energy consumption and carbon footprint) while preserving good latencies compared to uniform peer-to-peer deployments
- …
