A survey of self-management in dynamic software architecture specifications

As dynamic software architecture use becomes more widespread, a variety of formal specification languages have been developed to gain a better understanding of the foundations of this type of software evolutionary change. In this paper we survey 14 formal specification approaches based on graphs, process algebras, logic, and other formalisms. Our survey will evaluate the ability of each approach to specify self-managing systems as well as the ability to address issues regarding expressiveness and scalability. Based on the results of our survey we will provide recommendations on future directions for improving the specification of dynamic software architectures, specifically self-managed architectures

Programming Protocol-Independent Packet Processors

P4 is a high-level language for programming protocol-independent packet processors. P4 works in conjunction with SDN control protocols like OpenFlow. In its current form, OpenFlow explicitly specifies protocol headers on which it operates. This set has grown from 12 to 41 fields in a few years, increasing the complexity of the specification while still not providing the flexibility to add new headers. In this paper we propose P4 as a strawman proposal for how OpenFlow should evolve in the future. We have three goals: (1) Reconfigurability in the field: Programmers should be able to change the way switches process packets once they are deployed. (2) Protocol independence: Switches should not be tied to any specific network protocols. (3) Target independence: Programmers should be able to describe packet-processing functionality independently of the specifics of the underlying hardware. As an example, we describe how to use P4 to configure a switch to add a new hierarchical label

Towards a chemical model for software architecture reconfiguration

The chemical abstract machine is a general-purpose, simple, and intuitive programming model. Among other domains, it has been used for the specification and analysis of the computational behaviour of software architectures. In this paper we explore the ability of the formalism to express the dynamics of the architecture itself and to unify different approaches to reconfiguration within a single framework

Meta-programming composers in 2nd generation component systems

Future component systems will require that components can be composed flexibly. In contrast to current systems which only support a fixed set of composition mechanisms, the component system should provide a composition language in which users can define their own specific composers. It is argued for an object-oriented setting that this will be possible by meta-programming the class-graph. Composers will be based on two important elements. First, they will express coupling by graph-based operators which transform parts of the class-graph (coupling design patterns). Second, during these transformations, elementary meta-operators will be used to transform data and code, rearranging slots and methods of parameter-components. Thus during their reuse, components are queried by introspection and transformed by meta-programming. Composers that use meta-programming generalize connectors in architectural languages. Hence they encapsulate context-dependent aspects of a system, and make components independent of their embedding context. Since meta-programming composers may change behavior of components transparently, meta-programming composers will lead to a nice form of grey-box reuse, which supports embedding of components (and classes) into application contexts in a new and flexible way

Evolution of negative application conditions on second-order graph rewriting

Graph grammars are a suitable formalism to modeling computational systems. This formalism is based on rules and data-driven transformations capable of simulating real systems, rules have application conditions and post conditions that can change the system state. Moreover the use of graphs allows an intuitive visual interface essential for the modeler. It is well known that software systems are always evolving, evolutions may range from minor refactorings or bug fixes to major interface changes or new architectural design. The formalization of these evolution processes in graph grammars is done via higher-order principles, which allows programmed higher-level rules to induce modifications on lower-level rules, the system rules. In this work, we extend the current framework of higher-order transformations for graph grammars in order to allow the evolution of rules with negative application conditions. Besides this extension, we provide the first working implementation of the whole framework of higher-order graph grammars in the Verigraph tool enabling the practical usage of this techniques.Gramática de grafos é um formalismo para modelagem de sistemas computacionais. Este formalismo é baseado em regras e transformações de dados capazes de simular sistemas reais, regras tem pré e pós condições de aplicação que podem mudar o estado do sistema. Além disso, o uso de grafos permite uma interface visual intuitiva, que é essencial para o modelador. Se sabe que sistemas computacionais estão sempre evoluindo, essas evoluções podem varias de pequenas refatorações ou correções de problemas, até mudanças maiores em interfaces ou nova arquitetura. A formalização deste processo de evolução em gramáticas de grafos é feita com base em regras de segunda ordem, que possibilitam induzir modificações nas regras da gramática de primeira ordem. Neste trabalho, nós estendemos o framework atual de gramáticas de grafos de segunda ordem de forma a permitir evolução de regras com condições negativas de aplicação. Além desta extensão, nós provemos a primeira implementação do framework de gramáticas de grafos de segunda ordem na ferramenta Verigraph, possibilitando assim o uso na prática destas técnicas

On Designing Multicore-aware Simulators for Biological Systems

The stochastic simulation of biological systems is an increasingly popular technique in bioinformatics. It often is an enlightening technique, which may however result in being computational expensive. We discuss the main opportunities to speed it up on multi-core platforms, which pose new challenges for parallelisation techniques. These opportunities are developed in two general families of solutions involving both the single simulation and a bulk of independent simulations (either replicas of derived from parameter sweep). Proposed solutions are tested on the parallelisation of the CWC simulator (Calculus of Wrapped Compartments) that is carried out according to proposed solutions by way of the FastFlow programming framework making possible fast development and efficient execution on multi-cores.Comment: 19 pages + cover pag

Zero-cost meta-programmed stateful functors in F*

Writing code is hard; proving it correct is even harder. As the scale of verified software projects reaches new heights, the problem of efficiently verifying large amounts of software becomes more and more salient. Nowhere is this issue more evident than in the context of verified cryptographic libraries. To achieve feature-parity and be competitive with unverified cryptographic libraries, a very large number of algorithms and APIs need to be verified. However, the task is oftentimes repetitive, and factoring out commonality between algorithms is fraught with difficulties, requiring until now a significant amount of manual effort. This paper shows how a judicious combination of known functional programming techniques leads to an order-of-magnitude improvement in the amount of verified code produced by the popular HACL* cryptographic library, without compromising performance. We review three techniques that build upon each other, in order of increasing sophistication. First, we use dependent types to crisply capture the specification and state machine of a block algorithm, a cryptographic notion that was until now only informally and imprecisely specified. Next, we rely on partial evaluation to author a higher-order, stateful functor that transforms any unsafe block API into a safe counterpart. Finally, we rely on elaborator reflection to automate the very process of authoring a functor, using a code-rewriting tactic. This culminates in a style akin to templatized C++ code, but relying on a userland tactic and partial evaluation, rather than built-in compiler support

Specification of Software Architecture Reconfiguration

In the past years, Software Architecture has attracted increased attention by academia and industry as the unifying concept to structure the design of complex systems. One particular research area deals with the possibility of reconfiguring architectures to adapt the systems they describe to new requirements. Reconfiguration amounts to adding and removing components and connections, and may have to occur without stopping the execution of the system being reconfigured. This work contributes to the formal description of such a process. Taking as a premise that a single formalism hardly ever satisfies all requirements in every situation, we present three approaches, each one with its own assumptions about the systems it can be applied to and with different advantages and disadvantages. Each approach is based on work of other researchers and has the aesthetic concern of changing as little as possible the original formalism, keeping its spirit. The first approach shows how a given reconfiguration can be specified in the same manner as the system it is applied to and in a way to be efficiently executed. The second approach explores the Chemical Abstract Machine, a formalism for rewriting multisets of terms, to describe architectures, computations, and reconfigurations in a uniform way. The last approach uses a UNITY-like parallel programming design language to describe computations, represents architectures by diagrams in the sense of Category Theory, and specifies reconfigurations by graph transformation rules