6,978 research outputs found
Kompics: a message-passing component model for building distributed systems
The Kompics component model and programming framework was designedto simplify the development of increasingly complex distributed systems. Systems built with Kompics leverage multi-core machines out of the box and they can be dynamically reconfigured to support hot software upgrades. A simulation framework enables deterministic debugging and reproducible performance evaluation of unmodified Kompics distributed systems.
We describe the component model and show how to program and compose event-based distributed systems. We present the architectural patterns and abstractions that Kompics facilitates and we highlight a case study of a complex
distributed middleware that we have built with Kompics. We show how our approach enables systematic development and evaluation of large-scale and dynamic distributed systems
Automatic Generation of Basis Component Path Coverage for Software Architecture Testing
Architecture-centric development is one of the most promising methods for improving software quality, reducing software cost and raising software productivity. Software architecture research not only focuses on the design phase, but also covers every phase of software life cycle. Software architecture has characteristics different from traditional software, conventional testing methods do not apply directly to software architecture. Basis path testing is a very simple and efficient white-box testing method. Traditional methods generate basis path according to the control flow graph, they are not suitable for generating component path when we detect more software architecture errors. This paper presents a new concept - Basis Component Path (BCP) for C2-style architecture, and proposes a method to generate the BCPs. C2-style architecture is represented by components, connectors, and interfaces, and uses an architecture component interaction graph (CIG) to describe interface connection relationship. We also provide an algorithm to generate BCP set. Experiments apply the proposed method in a typical C2-style architecture and the result shows that the proposed method can generate BCP set which contains as many BCPs as possible efficiently, and it meets the requirements of the basis component path testing
Clafer: Lightweight Modeling of Structure, Behaviour, and Variability
Embedded software is growing fast in size and complexity, leading to intimate
mixture of complex architectures and complex control. Consequently, software
specification requires modeling both structures and behaviour of systems.
Unfortunately, existing languages do not integrate these aspects well, usually
prioritizing one of them. It is common to develop a separate language for each
of these facets. In this paper, we contribute Clafer: a small language that
attempts to tackle this challenge. It combines rich structural modeling with
state of the art behavioural formalisms. We are not aware of any other modeling
language that seamlessly combines these facets common to system and software
modeling. We show how Clafer, in a single unified syntax and semantics, allows
capturing feature models (variability), component models, discrete control
models (automata) and variability encompassing all these aspects. The language
is built on top of first order logic with quantifiers over basic entities (for
modeling structures) combined with linear temporal logic (for modeling
behaviour). On top of this semantic foundation we build a simple but expressive
syntax, enriched with carefully selected syntactic expansions that cover
hierarchical modeling, associations, automata, scenarios, and Dwyer's property
patterns. We evaluate Clafer using a power window case study, and comparing it
against other notations that substantially overlap with its scope (SysML, AADL,
Temporal OCL and Live Sequence Charts), discussing benefits and perils of using
a single notation for the purpose
Working Notes from the 1992 AAAI Workshop on Automating Software Design. Theme: Domain Specific Software Design
The goal of this workshop is to identify different architectural approaches to building domain-specific software design systems and to explore issues unique to domain-specific (vs. general-purpose) software design. Some general issues that cut across the particular software design domain include: (1) knowledge representation, acquisition, and maintenance; (2) specialized software design techniques; and (3) user interaction and user interface
Command & Control: Understanding, Denying and Detecting - A review of malware C2 techniques, detection and defences
In this survey, we first briefly review the current state of cyber attacks,
highlighting significant recent changes in how and why such attacks are
performed. We then investigate the mechanics of malware command and control
(C2) establishment: we provide a comprehensive review of the techniques used by
attackers to set up such a channel and to hide its presence from the attacked
parties and the security tools they use. We then switch to the defensive side
of the problem, and review approaches that have been proposed for the detection
and disruption of C2 channels. We also map such techniques to widely-adopted
security controls, emphasizing gaps or limitations (and success stories) in
current best practices.Comment: Work commissioned by CPNI, available at c2report.org. 38 pages.
Listing abstract compressed from version appearing in repor
Performance Modeling and Analysis of Software Architectures Specified Through Graph Transformations
Software architecture plays an important role in the success of modern, large and distributed software systems. For many of the software systems -- especially safety-critical ones -- it is important to specify their architectures using formal modeling notations. In this case, it is possible to assess different functional and non-functional properties on the designed models. Graph Transformation System (GTS) is a formal yet understandable language which is suitable for architectural modeling. Most of the existing works done on architectural modeling and analysis by GTS are concentrated on functional aspects, while for many systems it is crucial to consider non-functional aspects for modeling and analysis at the architectural level. In this paper, we present an approach to performance analysis of software architectures specified through GTS. To do so, we first enrich the existing architectural style -- specified through GTS - with performance information. Then, the performance models are generated in PEPA (Performance Evaluation Process Algebra) -- a formal language based on the stochastic process algebra -- using the enriched GTS models. Finally, we analyze different features like throughput, utilization of different software components, etc. on the generated performance models. All the main concepts are illustrated through a case study
An empirical study of architecting for continuous delivery and deployment
Recently, many software organizations have been adopting Continuous Delivery
and Continuous Deployment (CD) practices to develop and deliver quality
software more frequently and reliably. Whilst an increasing amount of the
literature covers different aspects of CD, little is known about the role of
software architecture in CD and how an application should be (re-) architected
to enable and support CD. We have conducted a mixed-methods empirical study
that collected data through in-depth, semi-structured interviews with 21
industrial practitioners from 19 organizations, and a survey of 91 professional
software practitioners. Based on a systematic and rigorous analysis of the
gathered qualitative and quantitative data, we present a conceptual framework
to support the process of (re-) architecting for CD. We provide evidence-based
insights about practicing CD within monolithic systems and characterize the
principle of "small and independent deployment units" as an alternative to the
monoliths. Our framework supplements the architecting process in a CD context
through introducing the quality attributes (e.g., resilience) that require more
attention and demonstrating the strategies (e.g., prioritizing operations
concerns) to design operations-friendly architectures. We discuss the key
insights (e.g., monoliths and CD are not intrinsically oxymoronic) gained from
our study and draw implications for research and practice.Comment: To appear in Empirical Software Engineerin
Scalability and Performance of Microservices Architectures.
Annotation- The inevitability of continuous evolution and seamless integration of dynamic alterations remains a paramount consideration in the realm of software engineering This concern is particularly pronounced within the context of contemporary microservices architectures embedded in heterogeneous and decentralized systems composed of numerous interdependent components A pivotal focal point within such a software design paradigm is to sustain optimal performance quality by ensuring harmonious collaboration among autonomous facets within an intricate framework The challenge of microservices evolution has predominantly revolved around upholding the harmonization of diverse microservices versions during updates all while curbing the computational overhead associated with such validation This study leverages previous research outcomes and tackles the evolution predicament by introducing an innovative formal model coupled with a fresh exposition of microservices RESTful APIs The amalgamation of Formal Concept Analysis and the Liskov Substitution Principle plays a pivotal role in this proposed solution A series of compatibility constraints is delineated and subjected to validation through a controlled experiment employing a representative microservices syste
Early aspects: aspect-oriented requirements engineering and architecture design
This paper reports on the third Early Aspects: Aspect-Oriented Requirements Engineering and Architecture Design Workshop, which has been held in Lancaster, UK, on March 21, 2004. The workshop included a presentation session and working sessions in which the particular topics on early aspects were discussed. The primary goal of the workshop was to focus on challenges to defining methodical software development processes for aspects from early on in the software life cycle and explore the potential of proposed methods and techniques to scale up to industrial applications
- …