IMT Institutional Repository: No conditions. Results ordered -Date Deposited. 2024-03-29T11:17:29ZEPrintshttp://eprints.imtlucca.it/images/logowhite.pnghttp://eprints.imtlucca.it/2016-05-26T10:06:19Z2016-05-26T10:06:19Zhttp://eprints.imtlucca.it/id/eprint/3491This item is in the repository with the URL: http://eprints.imtlucca.it/id/eprint/34912016-05-26T10:06:19ZModelling and Analyzing Adaptive Self-assembly Strategies with MaudeBuilding adaptive systems with predictable emergent behavior is a challenging task and it is becoming a critical need. The research community has accepted the challenge by introducing approaches of various nature: from software architectures, to programming paradigms, to analysis techniques. We recently proposed a conceptual framework for adaptation centered around the role of control data. In this paper we show that it can be naturally realized in a reflective logical language like Maude by using the Reflective Russian Dolls model. Moreover, we exploit this model to specify and analyse a prominent example of adaptive system: robot swarms equipped with obstacle-avoidance self-assembly strategies. The analysis exploits the statistical model checker PVesta.Roberto BruniAndrea CorradiniFabio GadducciAlberto Lluch LafuenteAndrea Vandinandrea.vandin@imtlucca.it2016-02-12T13:04:06Z2016-04-06T07:58:07Zhttp://eprints.imtlucca.it/id/eprint/3064This item is in the repository with the URL: http://eprints.imtlucca.it/id/eprint/30642016-02-12T13:04:06ZReconciling White-Box and Black-Box Perspectives on Behavioral Self-adaptationThis paper proposes to reconcile two perspectives on behavioral adaptation commonly taken at different stages of the engineering of autonomic computing systems. Requirements engineering activities often take a black-box perspective: A system is considered to be adaptive with respect to an environment whenever the system is able to satisfy its goals irrespectively of the environment perturbations. Modeling and programming engineering activities often take a white-box perspective: A system is equipped with suitable adaptation mechanisms and its behavior is classified as adaptive depending on whether the adaptation mechanisms are enacted or not. The proposed approach reconciles black- and white-box perspectives by proposing several notions of coherence between the adaptivity as observed by the two perspectives: These notions provide useful criteria for the system developer to assess and possibly modify the adaptation requirements, models and programs of an autonomic system.Roberto BruniAndrea CorradiniFabio GadducciMatthias HölzlAlberto Lluch LafuenteAndrea Vandinandrea.vandin@imtlucca.itMartin Wirsing2016-02-12T12:27:56Z2016-02-12T12:27:56Zhttp://eprints.imtlucca.it/id/eprint/3062This item is in the repository with the URL: http://eprints.imtlucca.it/id/eprint/30622016-02-12T12:27:56ZA White Box Perspective on Behavioural AdaptationWe present a white-box conceptual framework for adaptation developed in the context of the EU Project ASCENS coordinated by Martin Wirsing. We called it CoDa, for Control Data Adaptation, since it is based on the notion of control data. CoDa promotes a neat separation between application and adaptation logic through a clear identification of the set of data that is relevant for the latter. The framework provides an original perspective from which we survey a representative set of approaches to adaptation, ranging from programming languages and paradigms to computational models and architectural solutions.Roberto BruniAndrea CorradiniFabio GadducciAlberto Lluch LafuenteAndrea Vandinandrea.vandin@imtlucca.it2016-02-12T11:52:51Z2016-02-12T12:08:13Zhttp://eprints.imtlucca.it/id/eprint/3061This item is in the repository with the URL: http://eprints.imtlucca.it/id/eprint/30612016-02-12T11:52:51ZModelling and analyzing adaptive self-assembly strategies with MaudeBuilding adaptive systems with predictable emergent behavior is a difficult task and it is becoming a critical need. The research community has accepted the challenge by introducing approaches of various nature: from software architectures to programming paradigms and analysis techniques. Our white-box conceptual approach to adaptive systems based on the notion of control data promotes a clear distinction between the application and the adaptation logic. In this paper we propose a concrete instance of our approach based on (i) a neat identification of control data; (ii) a hierarchical architecture that provides the basic structure to separate the adaptation and application logics; (iii) computational reflection as the main mechanism to realize the adaptation logic; (iv) probabilistic rule-based specifications and quantitative verification techniques to specify and analyze the adaptation logic. We show that our solution can be naturally realized in Maude, a Rewriting Logic based framework, and illustrate our approach by specifying, validating and analyzing a prominent example of adaptive systems: robot swarms equipped with self-assembly strategies.Roberto BruniAndrea CorradiniFabio GadducciAlberto Lluch LafuenteAndrea Vandinandrea.vandin@imtlucca.it2015-03-03T09:49:51Z2015-03-03T09:49:51Zhttp://eprints.imtlucca.it/id/eprint/2626This item is in the repository with the URL: http://eprints.imtlucca.it/id/eprint/26262015-03-03T09:49:51ZCaSPiS: a calculus of sessions, pipelines and servicesService-oriented computing is calling for novel computational models and languages with well-disciplined primitives for client–server interaction, structured orchestration and unexpected events handling. We present CaSPiS, a process calculus where the conceptual abstractions of sessioning and pipelining play a central role for modelling service-oriented systems. CaSPiS sessions are two-sided, uniquely named and can be nested. CaSPiS pipelines permit orchestrating the flow of data produced by different sessions. The calculus is also equipped with operators for handling (unexpected) termination of the partner's side of a session. Several examples are presented to provide evidence of the flexibility of the chosen set of primitives. One key contribution is a fully abstract encoding of Misra et al.'s orchestration language Orc. Another main result shows that in CaSPiS it is possible to program a ‘graceful termination’ of nested sessions, which guarantees that no session is forced to hang forever after the loss of its partner.Michele BorealeRoberto BruniRocco De Nicolar.denicola@imtlucca.itMichele Loreti2014-10-09T12:45:52Z2015-04-08T10:37:32Zhttp://eprints.imtlucca.it/id/eprint/2315This item is in the repository with the URL: http://eprints.imtlucca.it/id/eprint/23152014-10-09T12:45:52ZStatic analysis techniques for session-oriented calculiIn the Sensoria project, core calculi have been adopted as a linguistic means to model and analyze service-oriented applications. The present chapter reports about the static analysis techniques developed for the Sensoria session-oriented core calculi CaSPiS and CC. In particular, it presents a type system for client progress and control flow analysis in CaSPiS and type systems for conversation fidelity and progress in CC. The chapter gives an overview of the these techniques, summarizes the main results and presents the analysis of a common example taken from the Sensoria financial case-study: the credit request scenario.Lucia AcciaiChiara BodeiMichele BorealeRoberto BruniHugo Torres Vieirahugo.torresvieira@imtlucca.it2013-12-12T13:11:42Z2016-07-13T10:29:47Zhttp://eprints.imtlucca.it/id/eprint/2056This item is in the repository with the URL: http://eprints.imtlucca.it/id/eprint/20562013-12-12T13:11:42ZModelling and analyzing adaptive self-assembling strategies with MaudeBuilding adaptive systems with predictable emergent behavior is a challenging task and it is becoming a critical need. The research community has accepted the challenge by introducing approaches of various nature: from software architectures, to programming paradigms, to analysis techniques. We recently proposed a conceptual framework for adaptation centered around the role of control data. In this paper we show that it can be naturally realized in a reflective logical language like Maude by using the Reflective Russian Dolls model. Moreover, we exploit this model to specify, validate and analyse a prominent example of adaptive system: robot swarms equipped with self-assembly strategies. The analysis exploits the statistical model checker PVeStA.Roberto BruniAndrea CorradiniFabio GadducciAlberto Lluch-Lafuentealberto.lluch@imtlucca.itAndrea Vandinandrea.vandin@imtlucca.it2013-12-12T13:11:24Z2013-12-12T13:11:24Zhttp://eprints.imtlucca.it/id/eprint/2057This item is in the repository with the URL: http://eprints.imtlucca.it/id/eprint/20572013-12-12T13:11:24ZConstraint Design RewritingWe propose an algebraic approach to the design and transformation of constraint networks, inspired by Architectural Design Rewriting. The approach can be understood as (i) an extension of ADR with constraints, and (ii) an application of ADR to the design of reconfigurable constraint networks. The main idea is to consider classes of constraint networks as algebras whose operators are used to denote constraint networks with terms. Constraint network transformations such as constraint propagations are specified with rewrite rules exploiting the network’s structure provided by terms.Roberto BruniAlberto Lluch-Lafuentealberto.lluch@imtlucca.itUgo Montanari2013-05-16T13:56:29Z2016-07-13T10:47:56Zhttp://eprints.imtlucca.it/id/eprint/1584This item is in the repository with the URL: http://eprints.imtlucca.it/id/eprint/15842013-05-16T13:56:29ZA Conceptual Framework for AdaptationWe present a white-box conceptual framework for adaptation. We called it CODA, for COntrol Data Adaptation, since it is based on the notion of control data. CODA promotes a neat separation between application and adaptation logic through a clear identification of the set of data that is relevant for the latter. The framework provides an original perspective from which we survey a representative set of approaches to adaptation ranging from programming languages and paradigms, to computational models and architectural solutions.Roberto BruniAndrea CorradiniFabio GadducciAlberto Lluch-Lafuentealberto.lluch@imtlucca.itAndrea Vandinandrea.vandin@imtlucca.it2013-05-16T13:06:14Z2016-07-13T09:48:45Zhttp://eprints.imtlucca.it/id/eprint/1581This item is in the repository with the URL: http://eprints.imtlucca.it/id/eprint/15812013-05-16T13:06:14ZA Conceptual Framework for AdaptationIn this position paper we present a conceptual vision of adaptation, a key feature of autonomic systems. We put some stress on the role of control data and argue how some of the programming paradigms and models used for adaptive systems match with our conceptual framework.Roberto BruniAndrea CorradiniFabio GadducciAlberto Lluch-Lafuentealberto.lluch@imtlucca.itAndrea Vandinandrea.vandin@imtlucca.it2013-05-16T13:05:40Z2016-07-13T10:47:36Zhttp://eprints.imtlucca.it/id/eprint/1583This item is in the repository with the URL: http://eprints.imtlucca.it/id/eprint/15832013-05-16T13:05:40ZAdaptation is a GameControl data variants of game models such as Interface Automata are suitable for the design and analysis of self-adaptive systems.Roberto BruniAndrea CorradiniFabio GadducciAlberto Lluch-Lafuentealberto.lluch@imtlucca.itAndrea Vandinandrea.vandin@imtlucca.it2013-03-18T07:40:52Z2016-02-12T13:26:47Zhttp://eprints.imtlucca.it/id/eprint/1535This item is in the repository with the URL: http://eprints.imtlucca.it/id/eprint/15352013-03-18T07:40:52ZAdaptable transition systemsWe present an essential model of adaptable transition systems inspired by white-box approaches to adaptation and based on foundational models of component based systems. The key feature of adaptable transition systems are control propositions, imposing a clear separation between ordinary, functional behaviours and adaptive ones. We instantiate our approach on interface automata yielding adaptable interface automata, but it may be instantiated on other foundational models of component-based systems as well. We discuss how control propositions can be exploited in the specification and analysis of adaptive systems, focusing on various notions proposed in the literature, like adaptability, control loops, and control synthesis.Roberto BruniAndrea CorradiniFabio GadducciAlberto Lluch-Lafuentealberto.lluch@imtlucca.itAndrea Vandinandrea.vandin@imtlucca.it2013-02-26T14:19:14Z2015-03-03T09:50:55Zhttp://eprints.imtlucca.it/id/eprint/1493This item is in the repository with the URL: http://eprints.imtlucca.it/id/eprint/14932013-02-26T14:19:14ZCaSPiS: A Calculus of Sessions, Pipelines and ServicesService-oriented computing is calling for novel computational models and languages with well
disciplined primitives for client-server interaction, structured orchestration and unexpected events handling. We present CaSPiS, a process calculus where the conceptual abstractions of sessioning and pipelining play a central role for modelling service-oriented systems. CaSPiS sessions are two-sided, uniquely named and can be nested. CaSPiS pipelines permit orchestrating the flow of data produced by different sessions. The calculus is also equipped with operators for handling (unexpected) termination of the partner’s side of a session. Several examples are presented to provide evidence of the flexibility of the chosen set of primitives. One key contribution is a fully abstract encoding of Misra et al.’s orchestration language Orc. Another main result shows that in CaSPiS it is possible to program a “graceful termination” of nested sessions, which guarantees that no session is forced to hang forever after the loss of its partner.Michele BorealeRoberto BruniRocco De Nicolar.denicola@imtlucca.itMichele Loreti2012-06-29T11:15:48Z2014-01-29T14:27:01Zhttp://eprints.imtlucca.it/id/eprint/1291This item is in the repository with the URL: http://eprints.imtlucca.it/id/eprint/12912012-06-29T11:15:48ZEvaluating the performance of model transformation styles in MaudeRule-based programming has been shown to be very successful in many application areas. Two prominent examples are the specification of model transformations in model driven development approaches and the definition of structured operational semantics of formal languages. General rewriting frameworks such as Maude are flexible enough to allow the programmer to adopt and mix various rule styles. The choice between styles can be biased by the programmer’s background. For instance, experts in visual formalisms might prefer graph-rewriting styles, while experts in semantics might prefer structurally inductive rules. This paper evaluates the performance of different rule styles on a significant benchmark taken from the literature on model transformation. Depending on the actual transformation being carried out, our results show that different rule styles can offer drastically different performances. We point out the situations from which each rule style benefits to offer a valuable set of hints for choosing one style over the other.Roberto BruniAlberto Lluch-Lafuentealberto.lluch@imtlucca.it2011-12-22T09:22:41Z2016-07-13T10:49:38Zhttp://eprints.imtlucca.it/id/eprint/1048This item is in the repository with the URL: http://eprints.imtlucca.it/id/eprint/10482011-12-22T09:22:41ZModelling and analyzing adaptive self-assembling strategies with MaudeBuilding adaptive systems with predictable emergent behavior is a challenging task and it is becoming a critical need. The research community has accepted the challenge by introducing approaches of various nature: from software architectures, to programming paradigms, to analysis techniques. We recently proposed a conceptual framework for adaptation centered around the role of control data. In this paper we show that it can be naturally realized in a reflective logical language like Maude by using the Reflective Russian Dolls model. Moreover, we exploit this model to specify and analyse a prominent example of adaptive system: robot swarms equipped with obstacle-avoidance self-assembly strategies. The analysis exploits the statistical model checker PVesta.Roberto BruniAndrea CorradiniFabio GadducciAlberto Lluch-Lafuentealberto.lluch@imtlucca.itAndrea Vandinandrea.vandin@imtlucca.it2011-11-22T14:16:35Z2011-12-20T12:00:25Zhttp://eprints.imtlucca.it/id/eprint/1020This item is in the repository with the URL: http://eprints.imtlucca.it/id/eprint/10202011-11-22T14:16:35ZStyle-Based architectural reconfigurationsWe introduce Architectural Design Rewriting (ADR), an approach to the design of reconfigurable software architectures whose key features are: (i) rule-based approach (over graphs); (ii) hierarchical design; (iii) algebraic presentation; and (iv) inductively-defined reconfigurations. Architectures are modelled by graphs whose edges and nodes represent components and connection ports. Architectures are designed hierarchically by a set of edge replacement rules that fix the architectural style. Depending on their reading, productions allow: (i) top-down design by refinement, (ii) bottom-up typing of actual architectures, and (iii) well-formed composition of architectures. The key idea is to encode style proofs as terms and to exploit such information at run-time for guiding reconfigurations. The main advantages of ADR
are that: (i) instead of reasoning on flat architectures, ADR specifications provide a convenient hierarchical structure, by exploiting the architectural classes introduced by the style, (ii) complex reconfiguration schemes can be defined inductively, and (iii) style-preservation is guaranteed.Roberto BruniAlberto Lluch-Lafuentealberto.lluch@imtlucca.itUgo MontanariEmilio Tuosto2011-11-22T13:59:55Z2011-12-20T12:00:25Zhttp://eprints.imtlucca.it/id/eprint/1019This item is in the repository with the URL: http://eprints.imtlucca.it/id/eprint/10192011-11-22T13:59:55ZArchitectural design rewriting as an architecture description languageArchitectural Design Rewriting (ADR) is a declarative rule-based approach for the design of dynamic software architectures. The key features that make ADR a suitable and expressive framework are the algebraic presentation of graph-based structures and the use of conditional rewrite rules. These features enable the modelling of, e.g. hierarchical design, inductively defined reconfigurations and
ordinary computation. Here, we promote ADR as an Architectural
Description Language.Roberto BruniAlberto Lluch-Lafuentealberto.lluch@imtlucca.itUgo MontanariEmilio Tuosto2011-09-13T09:52:21Z2011-09-27T11:09:23Zhttp://eprints.imtlucca.it/id/eprint/863This item is in the repository with the URL: http://eprints.imtlucca.it/id/eprint/8632011-09-13T09:52:21ZA formal support to business and architectural design for service-oriented systems Architectural Design Rewriting (ADR) is an approach for the design of software architectures developed within Sensoria by reconciling graph transformation and process calculi techniques. The key feature that makes ADR a suitable and expressive framework is the algebraic handling of structured graphs, which improves the support for specification, analysis and verification of service-oriented architectures and applications. We show how ADR is used as a formal ground for high-level modelling languages and approaches developed within Sensoria. Roberto BruniHoward FosterAlberto Lluch-Lafuentealberto.lluch@imtlucca.itUgo MontanariEmilio Tuosto2011-09-13T09:42:21Z2011-09-27T11:09:23Zhttp://eprints.imtlucca.it/id/eprint/862This item is in the repository with the URL: http://eprints.imtlucca.it/id/eprint/8622011-09-13T09:42:21ZHierarchical models for service-oriented systems We present our approach to the denotation and representation of hierarchical graphs: a suitable algebra of hierarchical graphs and two domains of interpretations. Each domain of interpretation focuses on a particular perspective of the graph hierarchy: the top view (nested boxes) is based on a notion of embedded graphs while the side view (tree hierarchy) is based on gs-graphs. Our algebra can be understood as a high-level language for describing such graphical models, which are well suited for defining graphical representations of service-oriented systems where nesting (e.g. sessions, transactions, locations) and linking (e.g. shared channels, resources, names) are key aspects. Roberto BruniAndrea CorradiniFabio GadducciAlberto Lluch-Lafuentealberto.lluch@imtlucca.itUgo Montanari2011-09-12T13:50:29Z2011-09-27T11:09:23Zhttp://eprints.imtlucca.it/id/eprint/859This item is in the repository with the URL: http://eprints.imtlucca.it/id/eprint/8592011-09-12T13:50:29ZOn structured model-driven transformationsStructural aspects play a key role in the model-driven development of software systems. Effective techniques and tools must therefore be based on suitable representation formalisms that facilitate the specification, manipulation and analysis of the structure of models. Graphical and algebraic approaches have been shown to be very successful for such purposes: 1) graphs offer natural a representation of topological structures, 2) algebras offer a natural representation of compositional structures, 3) both graphs and algebras can be manipulated in a declarative way by means of rule-based techniques, 4) they allow for a layered presentation of models that enables compositional techniques and favours scalability. Most of the existing approaches represent such layering in a plain manner by overlapping the intra- and the inter-layered structure. It has been shown that some layering structures can be conveniently represented by an explicit hierarchical structure enabling then structurally inductive manipulations of the resulting models. Moreover, providing an inductive presentation of the structure facilitates the compositional analysis and verification of models. In this paper we compare and reconcile some recent approaches and synthesise them into an algebraic and graph-based formalism for representing and manipulating models with inductively defined hierarchical structure.Roberto BruniAlberto Lluch-Lafuentealberto.lluch@imtlucca.itUgo Montanari2011-06-06T09:03:49Z2011-09-19T10:00:54Zhttp://eprints.imtlucca.it/id/eprint/323This item is in the repository with the URL: http://eprints.imtlucca.it/id/eprint/3232011-06-06T09:03:49ZAGILE: Software Architecture for MobilityArchitecture-based approaches have been promoted as a means of controlling the complexity of system construction and evolution, in particular for providing systems with the agility required to operate in turbulent environments and to adapt very quickly to changes in the enterprise world. Recent technological advances in communication and distribution have made mobility an additional factor of complexity, one for which current architectural concepts and techniques can be hardly used. The AGILE project is developing an architectural approach in which mobility aspects can be modelled explicitly and mapped on the distribution and communication topology made available at physical levels. The whole approach is developed over a uniform mathematical framework based on graph-oriented techniques that support sound methodological principles, formal analysis, and refinement. This paper describes the AGILE project and some of the results gained during the first project year. Luis Filipe AndradePaolo BaldanHubert BaumeisterRoberto BruniAndrea CorradiniRocco De Nicolar.denicola@imtlucca.itJose Luiz FiadeiroFabio GadducciStefania GnesiPiotr HoffmanNora KochPiotr KosiuczenkoAlessandro LapadulaDiego LatellaAntonia LopesMichele LoretiMieke MassinkFranco MazzantiUgo MontanariCristóvão OliveiraRosario PuglieseAndrzej TarleckiMichel WermelingerMartin WirsingArtur Zawlocki2011-05-26T10:16:54Z2014-03-03T11:59:47Zhttp://eprints.imtlucca.it/id/eprint/282This item is in the repository with the URL: http://eprints.imtlucca.it/id/eprint/2822011-05-26T10:16:54ZProvably Correct Implementations of ServicesA number of formalisms have been defined to support the specification and analysis of service oriented applications. These formalisms have been equipped with tools (types or logics) to guarantee the correct behavior of the specified services. Due to the semantic gap between the specification formalism and the programming languages of service oriented overlay computers a critical issue is guaranteeing that correctness is preserved when running the specified systems over available implementations. We have defined a service oriented abstract machine, equipped with a formal structural semantics, that can be used to implement service specification formalisms. We use our abstract machine to implement different service oriented formalisms that have been recently proposed, each posing specific challenges that we can address successfully. By exploiting the SOS semantics of the abstract machine and those of the considered service oriented formalisms we do prove that our implementations are correct (sound and complete). We also discuss possible implementations of other formalisms.
Roberto BruniRocco De Nicolar.denicola@imtlucca.itMichele LoretiLeonardo Gaetano Mezzina2011-05-26T10:11:50Z2011-07-11T14:36:25Zhttp://eprints.imtlucca.it/id/eprint/281This item is in the repository with the URL: http://eprints.imtlucca.it/id/eprint/2812011-05-26T10:11:50ZSessions and Pipelines for Structured Service ProgrammingService-oriented computing is calling for novel computational models and languages with primitives for client-server interaction, orchestration and unexpected events handling. We present CaSPiS, a process calculus where the notions of session and pipelining play a central role. Sessions are two-sided and can be equipped with protocols executed by each side. Pipelining permits orchestrating the flow of data produced by different sessions. The calculus is also equipped with operators for handling (unexpected) termination of the partner’s side of a session. Several examples are presented to provide evidence for the flexibility of the chosen set of primitives. Our main result shows that in CaSPiS it is possible to program a “graceful termination” of nested sessions, which guarantees that no session is forced to hang forever after the loss of its partner. Michele BorealeRoberto BruniRocco De Nicolar.denicola@imtlucca.itMichele Loreti2011-05-25T09:13:57Z2011-07-11T14:36:25Zhttp://eprints.imtlucca.it/id/eprint/295This item is in the repository with the URL: http://eprints.imtlucca.it/id/eprint/2952011-05-25T09:13:57ZSCC: A Service Centered CalculusWe seek for a small set of primitives that might serve as a basis for formalising and programming service oriented applications over global computers. As an outcome of this study we introduce here SCC, a process calculus that features explicit notions of service definition, service invocation and session handling. Our proposal has been influenced by Orc, a programming model for structured orchestration of services, but the SCC’s session handling mechanism allows for the definition of structured interaction protocols, more complex than the basic request-response provided by Orc. We present syntax and operational semantics of SCC and a number of simple but nontrivial programming examples that demonstrate flexibility of the chosen set of primitives. A few encodings are also provided to relate our proposal with existing ones.
Michele BorealeRoberto BruniLuis CairesRocco De Nicolar.denicola@imtlucca.itIvan LaneseMichele LoretiFrancisco MartinsUgo MontanariAntonio RavaraDavide SangiorgiVasco Thudichum VasconcelosGianluigi Zavattaro2011-05-18T10:31:57Z2011-07-11T14:34:34Zhttp://eprints.imtlucca.it/id/eprint/147This item is in the repository with the URL: http://eprints.imtlucca.it/id/eprint/1472011-05-18T10:31:57ZA Graph Syntax for Processes and ServicesWe propose a class of hierarchical graphs equipped with a simple algebraic syntax as a convenient way to describe configurations in languages with inherently hierarchical features such as sessions, fault- handling scopes or transactions. The graph syntax can be seen as an intermediate representation language, that facilitates the encoding of structured specifications and, in particular, of process calculi, since it provides primitives for nesting, name restriction and parallel composition. The syntax is based on an algebraic presentation that faithfully characterises families of hierarchical graphs, meaning that each term of the language uniquely identifies an equivalence class of graphs (modulo graph isomorphism). Proving soundness and completeness of an encoding (i.e. proving that structurally equivalent processes are mapped to isomorphic graphs) is then facilitated and can be done by structural induction. Summing up, the graph syntax facilitates the definition of faithful encodings, yet allowing a precise visual representation. We illustrate our work with an application to a workflow language and a service-oriented calculus.Roberto BruniFabio GadducciAlberto Lluch-Lafuentealberto.lluch@imtlucca.it2011-05-18T10:27:27Z2016-04-06T07:57:34Zhttp://eprints.imtlucca.it/id/eprint/146This item is in the repository with the URL: http://eprints.imtlucca.it/id/eprint/1462011-05-18T10:27:27ZA Service-Oriented UML Profile with Formal SupportWe present a UML Profile for the description of service oriented applications. The profile focuses on style-based design and reconfiguration aspects at the architectural level. Moreover, it has formal support in terms of an approach called Architectural Design Rewriting, which enables formal analysis of the UML specifications. We show how our prototypical implementation can be used to analyse and verify properties of a service oriented application.
Roberto BruniMatthias HölzlNora KochAlberto Lluch-Lafuentealberto.lluch@imtlucca.itPhilip MayerUgo MontanariAndreas SchroederMartin Wirsing2011-05-18T09:02:33Z2011-07-11T14:34:34Zhttp://eprints.imtlucca.it/id/eprint/145This item is in the repository with the URL: http://eprints.imtlucca.it/id/eprint/1452011-05-18T09:02:33ZAn Algebra of Hierarchical Graphs and its Application to Structural EncodingWe define an algebraic theory of hierarchical graphs, whose axioms
characterise graph isomorphism: two terms are equated exactly when
they represent the same graph. Our algebra can be understood as
a high-level language for describing graphs with a node-sharing, embedding
structure, and it is then well suited for defining graphical
representations of software models where nesting and linking are key
aspects. In particular, we propose the use of our graph formalism as a
convenient way to describe configurations in process calculi equipped
with inherently hierarchical features such as sessions, locations, transactions,
membranes or ambients. The graph syntax can be seen as an
intermediate representation language, that facilitates the encodings of
algebraic specifications, since it provides primitives for nesting, name
restriction and parallel composition. In addition, proving soundness
and correctness of an encoding (i.e. proving that structurally equivalent
processes are mapped to isomorphic graphs) becomes easier as it can
be done by induction over the graph syntax.Roberto BruniFabio GadducciAlberto Lluch-Lafuentealberto.lluch@imtlucca.it2011-05-17T15:01:44Z2014-10-08T09:39:01Zhttp://eprints.imtlucca.it/id/eprint/150This item is in the repository with the URL: http://eprints.imtlucca.it/id/eprint/1502011-05-17T15:01:44ZOn symbolic semantics for name-decorated contextsUnder several regards, various of the recently proposed computational paradigms are open-ended, i.e. they may comprise components whose behaviour is not or cannot be fully specified. For instance, applications can be distributed across different administration domains that do not fully disclose their internal business processes to each other, or the dynamics of the system may allow reconfigurations and dynamic bindings whose specification is not available at design time. While a large set of mature design and analysis techniques for closed systems have been developed, their lifting to the open case is not always straightforward. Some existing approaches in the process calculi community are based on the need of proving properties for components that may hold in any, or significantly many, execution environments. Dually, frameworks describing the dynamics of systems with unspecified components have also been presented. In this paper we lay some preliminary ideas on how to extend a symbolic semantics model for open systems in order to deal with name-based calculi. Moreover, we also discuss how the use of a simple type system based on name-decoration for unknown components can improve the expressiveness of the framework. The approach is illustrated on a simple, paradigmatic calculus of web crawlers, which can be understood as a term representation of a simple class of graphs.Andrea BraccialiRoberto BruniAlberto Lluch-Lafuentealberto.lluch@imtlucca.it2011-05-17T14:56:11Z2014-10-08T09:36:46Zhttp://eprints.imtlucca.it/id/eprint/151This item is in the repository with the URL: http://eprints.imtlucca.it/id/eprint/1512011-05-17T14:56:11ZHierarchical design rewriting with MaudeArchitectural Design Rewriting (ADR) is a rule-based approach for the design of dynamic software architectures. The key features that make ADR a suitable and expressive framework are the algebraic presentation and the use of conditional rewrite rules. These features enable, e.g. hierarchical (top-down, bottom-up or composition-based) design and inductively-defined reconfigurations. The contribution of this paper is twofold: we define Hierarchical Design Rewriting (HDR) and present our prototypical tool support. HDR is a flavour of ADR that exploits the concept of hierarchical graph to deal with system specifications combining both symbolic and interpreted parts. Our prototypical implementation is based on Maude and its presentation serves several purposes. First, we show that HDR is not only a well-founded formal approach but also a tool-supported framework for the design and analysis of software architectures. Second, our illustration tailored to a particular algebra of designs and a particular scenario traces a general methodology for the reuse and exploitation of ADR concepts in other scenarios.
Roberto BruniAlberto Lluch-Lafuentealberto.lluch@imtlucca.itUgo Montanari2011-05-13T13:13:01Z2011-07-11T14:34:34Zhttp://eprints.imtlucca.it/id/eprint/153This item is in the repository with the URL: http://eprints.imtlucca.it/id/eprint/1532011-05-13T13:13:01ZGraph-Based Design and Analysis of Dynamic Software ArchitecturesWe illustrate two ways to address the specification, modelling and analysis of dynamic software architectures using: i) ordinary typed graph transformation techniques implemented in Alloy; ii) a process algebraic presentation of graph transformation implemented in Maude. The two approaches are compared by showing how different aspects can be tackled, including representation issues, modelling phases, property specification and analysis.
Roberto BruniAntonio BucchiaroneStefania GnesiDan HirschAlberto Lluch-Lafuentealberto.lluch@imtlucca.it2011-04-12T09:19:59Z2011-07-11T14:34:34Zhttp://eprints.imtlucca.it/id/eprint/156This item is in the repository with the URL: http://eprints.imtlucca.it/id/eprint/1562011-04-12T09:19:59ZService Oriented Architectural DesignWe propose Architectural Design Rewriting (ADR), an approach to formalise the development and reconfiguration of software architectures based on term-rewriting. An architectural style consists of a set of architectural elements and operations called productions which define the well-formed compositions of architectures. Roughly, a term built out of such ingredients constitutes the proof that a design was constructed according to the style, and the value of the term is the constructed software architecture. A main advantage of ADR is that it naturally supports style-preserving reconfigurations. The usefulness of our approach is shown by applying ADR to SRML, an emergent paradigm inspired by the Service Component Architecture. We model the complex operation that composes several SRML modules in a single one by means of suitable rewrite rules. Our approach guarantees that the resulting module respects SRML’s metamodel.Roberto BruniAlberto Lluch-Lafuentealberto.lluch@imtlucca.itUgo MontanariEmilio Tuosto2011-03-31T14:41:48Z2011-07-11T14:34:34Zhttp://eprints.imtlucca.it/id/eprint/149This item is in the repository with the URL: http://eprints.imtlucca.it/id/eprint/1492011-03-31T14:41:48ZTen virtues of structured graphsThis paper extends the invited talk by the first author about the virtues
of structured graphs. The motivation behind the talk and this paper relies on our
experience on the development of ADR, a formal approach for the design of styleconformant,
reconfigurable software systems. ADR is based on hierarchical graphs
with interfaces and it has been conceived in the attempt of reconciling software architectures
and process calculi by means of graphical methods. We have tried to
write an ADR agnostic paper where we raise some drawbacks of flat, unstructured
graphs for the design and analysis of software systems and we argue that hierarchical,
structured graphs can alleviate such drawbacks.Roberto BruniAlberto Lluch-Lafuentealberto.lluch@imtlucca.it2011-03-31T13:40:00Z2011-07-11T14:34:34Zhttp://eprints.imtlucca.it/id/eprint/141This item is in the repository with the URL: http://eprints.imtlucca.it/id/eprint/1412011-03-31T13:40:00ZExploiting the Hierarchical Structure of Rule-Based Specifications for Decision PlanningRule-based specifications have been very successful as a declarative approach in many domains, due to the handy yet solid foundations offered by rule-based machineries like term and graph rewriting. Realistic problems, however, call for suitable techniques to guarantee scalability. For instance, many domains exhibit a hierarchical structure that can be exploited conveniently. This is particularly evident for composition associations of models. We propose an explicit representation of such structured models and a methodology that exploits it for the description and analysis of model- and rule-based systems. The approach is presented in the framework of rewriting logic and its efficient implementation in the rewrite engine Maude and is illustrated with a case study.
}Alberto Lluch-Lafuentealberto.lluch@imtlucca.itRoberto BruniArtur BoronatUgo MontanariGeneroso Paolillo2011-03-31T10:55:12Z2011-07-11T14:34:34Zhttp://eprints.imtlucca.it/id/eprint/142This item is in the repository with the URL: http://eprints.imtlucca.it/id/eprint/1422011-03-31T10:55:12ZOn GS-Monoidal Theories for Graphs with NestingWe propose a sound and complete axiomatisation of a class of graphs with nesting and either locally or globally restricted nodes. Such graphs allow to represent explicitly and at the right level of abstraction some relevant topological and logical features of models and systems, including nesting, hierarchies, sharing of resources, and pointers or links. We also provide an encoding of the proposed algebra into terms of a gs-monoidal theory, and through these into a suitable class of wellscoped term graphs, showing that this encoding is sound and complete with respect to the axioms of the algebra.
Roberto BruniAndrea CorradiniFabio GadducciAlberto Lluch-Lafuentealberto.lluch@imtlucca.itUgo Montanari2011-03-31T10:44:09Z2011-07-11T14:34:34Zhttp://eprints.imtlucca.it/id/eprint/144This item is in the repository with the URL: http://eprints.imtlucca.it/id/eprint/1442011-03-31T10:44:09ZAn Algebra of Hierarchical GraphsWe define an algebraic theory of hierarchical graphs, whose axioms characterise graph isomorphism: two terms are equated exactly when they represent the same graph. Our algebra can be understood as a high-level language for describing graphs with a node-sharing, embedding structure, and it is then well suited for defining graphical representations of software models where nesting and linking are key aspects.
Roberto BruniFabio GadducciAlberto Lluch-Lafuentealberto.lluch@imtlucca.it