18,284 research outputs found
Recommended from our members
Better abstractions for reusable components & architectures
Software architecture (SA) is a crucial component of Model Driven Engineering (MDE), since it eases the communication and reuse of designs and components. However, existing languages (e.g., UML, AADL, SysML) are lacking many needed features. In particular, they provide rudimentary support for connectors, a first-class element in the components and connectors (C&C) architectural view and one of the most reusable architectural elements. This is unfortunate, since the difficult properties that need to be guaranteed for complex systems are mainly the non-functional properties, like throughput, security and dependability, which are greatly influenced by the employed connectors. This work reviews the basic abstractions of the C&C view of SA and examines extra architectural elements which can support the detailed, explicit and separate description of behaviour, interaction and control logic
Experiences in Multi-domain Management Service Development
The developers of management systems and the management services that operate over them will be faced with increasing complexity as services are developed for the open service market. This paper presents experiences in the development of management services that span several administrative domains and which are therefore representative of the complexities of the open service market. The work described involved the development of TMN based management systems that provided management services in support of multimedia teleservices operating over broadband networks
Towards a design-by-contract based approach for realizable connector-centric software architectures
Despite being a widely-used language for specifying software systems, UML remains less than ideal for software architectures. Architecture description languages (ADLs) were developed to provide more comprehensive support. However, so far the application of ADLs in practice has been impeded by at least one of the following problems: (i) advanced formal notations, (ii) lack of support for complex connectors, and (iii) potentially unrealizable designs. In this paper we propose a new ADL that is based on Design-by-Contract (DbC) for specifying software architectures. While DbC promotes a formal and precise way of specifying system behaviours, it is more familiar to practising developers, thus allowing for a more comfortable way of specifying architectures than using process algebras. Furthermore, by granting connectors a first-class status, our ADL allows designers to specify not only simple interaction mechanisms as connectors but also complex interaction protocols. Finally, in order to ensure that architectural designs are always realizable we eliminate potentially unrealizable constructs in connector specifications (the connector “glue”)
From a Domain Analysis to the Specification and Detection of Code and Design Smells
Code and design smells are recurring design problems in software systems that must be identified to avoid their possible negative consequences\ud
on development and maintenance. Consequently, several smell detection\ud
approaches and tools have been proposed in the literature. However,\ud
so far, they allow the detection of predefined smells but the detection\ud
of new smells or smells adapted to the context of the analysed systems\ud
is possible only by implementing new detection algorithms manually.\ud
Moreover, previous approaches do not explain the transition from\ud
specifications of smells to their detection. Finally, the validation\ud
of the existing approaches and tools has been limited on few proprietary\ud
systems and on a reduced number of smells. In this paper, we introduce\ud
an approach to automate the generation of detection algorithms from\ud
specifications written using a domain-specific language. This language\ud
is defined from a thorough domain analysis. It allows the specification\ud
of smells using high-level domain-related abstractions. It allows\ud
the adaptation of the specifications of smells to the context of\ud
the analysed systems.We specify 10 smells, generate automatically\ud
their detection algorithms using templates, and validate the algorithms\ud
in terms of precision and recall on Xerces v2.7.0 and GanttProject\ud
v1.10.2, two open-source object-oriented systems.We also compare\ud
the detection results with those of a previous approach, iPlasma
A Web-Based Tool for Analysing Normative Documents in English
Our goal is to use formal methods to analyse normative documents written in
English, such as privacy policies and service-level agreements. This requires
the combination of a number of different elements, including information
extraction from natural language, formal languages for model representation,
and an interface for property specification and verification. We have worked on
a collection of components for this task: a natural language extraction tool, a
suitable formalism for representing such documents, an interface for building
models in this formalism, and methods for answering queries asked of a given
model. In this work, each of these concerns is brought together in a web-based
tool, providing a single interface for analysing normative texts in English.
Through the use of a running example, we describe each component and
demonstrate the workflow established by our tool
Evaluating Software Architectures: Development Stability and Evolution
We survey seminal work on software architecture evaluationmethods. We then look at an emerging class of methodsthat explicates evaluating software architectures forstability and evolution. We define architectural stabilityand formulate the problem of evaluating software architecturesfor stability and evolution. We draw the attention onthe use of Architectures Description Languages (ADLs) forsupporting the evaluation of software architectures in generaland for architectural stability in specific
From Temporal Models to Property-Based Testing
This paper presents a framework to apply property-based testing (PBT) on top
of temporal formal models. The aim of this work is to help software engineers
to understand temporal models that are presented formally and to make use of
the advantages of formal methods: the core time-based constructs of a formal
method are schematically translated to the BeSpaceD extension of the Scala
programming language. This allows us to have an executable Scala code that
corresponds to the formal model, as well as to perform PBT of the models
functionality. To model temporal properties of the systems, in the current work
we focus on two formal languages, TLA+ and FocusST.Comment: Preprint. Accepted to the 12th International Conference on Evaluation
of Novel Approaches to Software Engineering (ENASE 2017). Final version
published by SCITEPRESS, http://www.scitepress.or
Enabling High-Level Application Development for the Internet of Things
Application development in the Internet of Things (IoT) is challenging
because it involves dealing with a wide range of related issues such as lack of
separation of concerns, and lack of high-level of abstractions to address both
the large scale and heterogeneity. Moreover, stakeholders involved in the
application development have to address issues that can be attributed to
different life-cycles phases. when developing applications. First, the
application logic has to be analyzed and then separated into a set of
distributed tasks for an underlying network. Then, the tasks have to be
implemented for the specific hardware. Apart from handling these issues, they
have to deal with other aspects of life-cycle such as changes in application
requirements and deployed devices. Several approaches have been proposed in the
closely related fields of wireless sensor network, ubiquitous and pervasive
computing, and software engineering in general to address the above challenges.
However, existing approaches only cover limited subsets of the above mentioned
challenges when applied to the IoT. This paper proposes an integrated approach
for addressing the above mentioned challenges. The main contributions of this
paper are: (1) a development methodology that separates IoT application
development into different concerns and provides a conceptual framework to
develop an application, (2) a development framework that implements the
development methodology to support actions of stakeholders. The development
framework provides a set of modeling languages to specify each development
concern and abstracts the scale and heterogeneity related complexity. It
integrates code generation, task-mapping, and linking techniques to provide
automation. Code generation supports the application development phase by
producing a programming framework that allows stakeholders to focus on the
application logic, while our mapping and linking techniques together support
the deployment phase by producing device-specific code to result in a
distributed system collaboratively hosted by individual devices. Our evaluation
based on two realistic scenarios shows that the use of our approach improves
the productivity of stakeholders involved in the application development
- …