53,356 research outputs found
An approach to reconcile the agile and CMMI contexts in product line development
Software product line approaches produce reusable platforms and architectures for products set developed by specific companies. These approaches are strategic in nature requiring coordination, discipline,
commonality and communication. The Capability Maturity Model (CMM) contains important guidelines for process improvement, and specifies "what" we must have into account to achieve the disciplined processes
(among others things). On the other hand, the agile context is playing an increasingly important role in current software engineering practices, specifying "how" the software practices must be addressed to obtain agile processes. In this paper, we carry out a preliminary analysis for reconciling agility and maturity models in software product line domain,
taking advantage of both.Postprint (published version
A survey of agent-oriented methodologies
This article introduces the current agent-oriented methodologies. It discusses what approaches have been followed (mainly extending existing object oriented and knowledge engineering methodologies), the suitability of these approaches for agent modelling, and some conclusions drawn from the survey
Relating BIP and Reo
Coordination languages simplify design and development of concurrent systems.
Particularly, exogenous coordination languages, like BIP and Reo, enable system
designers to express the interactions among components in a system explicitly.
In this paper we establish a formal relation between BI(P) (i.e., BIP without
the priority layer) and Reo, by defining transformations between their semantic
models. We show that these transformations preserve all properties expressible
in a common semantics. This formal relation comprises the basis for a solid
comparison and consolidation of the fundamental coordination concepts behind
these two languages. Moreover, this basis offers translations that enable users
of either language to benefit from the toolchains of the other.Comment: In Proceedings ICE 2015, arXiv:1508.0459
Pattern Reification as the Basis for Description-Driven Systems
One of the main factors driving object-oriented software development for
information systems is the requirement for systems to be tolerant to change. To
address this issue in designing systems, this paper proposes a pattern-based,
object-oriented, description-driven system (DDS) architecture as an extension
to the standard UML four-layer meta-model. A DDS architecture is proposed in
which aspects of both static and dynamic systems behavior can be captured via
descriptive models and meta-models. The proposed architecture embodies four
main elements - firstly, the adoption of a multi-layered meta-modeling
architecture and reflective meta-level architecture, secondly the
identification of four data modeling relationships that can be made explicit
such that they can be modified dynamically, thirdly the identification of five
design patterns which have emerged from practice and have proved essential in
providing reusable building blocks for data management, and fourthly the
encoding of the structural properties of the five design patterns by means of
one fundamental pattern, the Graph pattern. A practical example of this
philosophy, the CRISTAL project, is used to demonstrate the use of
description-driven data objects to handle system evolution.Comment: 20 pages, 10 figure
Coordination of Dynamic Software Components with JavaBIP
JavaBIP allows the coordination of software components by clearly separating
the functional and coordination aspects of the system behavior. JavaBIP
implements the principles of the BIP component framework rooted in rigorous
operational semantics. Recent work both on BIP and JavaBIP allows the
coordination of static components defined prior to system deployment, i.e., the
architecture of the coordinated system is fixed in terms of its component
instances. Nevertheless, modern systems, often make use of components that can
register and deregister dynamically during system execution. In this paper, we
present an extension of JavaBIP that can handle this type of dynamicity. We use
first-order interaction logic to define synchronization constraints based on
component types. Additionally, we use directed graphs with edge coloring to
model dependencies among components that determine the validity of an online
system. We present the software architecture of our implementation, provide and
discuss performance evaluation results.Comment: Technical report that accompanies the paper accepted at the 14th
International Conference on Formal Aspects of Component Softwar
Domain-oriented architecture design for production control software
this paper, we present domain-oriented architectural design heuristics for production control software. Our approach is based upon the following premisses. First, software design, like all other forms of design, consists of the reduction of uncertainty about a final product by making design decisions. These decisions should as much as possible be based upon information that is certain, either because they represent laws of nature or because they represent previously made design decisions. An import class of information concerns the domain of the software. The domain of control software is the part of the world monitored and controlled by the software; it is the larger system into which the software is embedded. The software engineer should exploit system-level domain knowledge in order to make software design decisions. Second, in the case of production control software, using system-level knowledge is not only justified, it is also imposed on the software engineer by the necessity to cooperate with hardware engineers. These represent their designs by means of Process and Instrumentation Diagrams (PIDs) and Input-Output (IO) lists. They do not want to spend time, nor do they see the need, to duplicate the information represented by these diagrams by means of diagrams from software engineering methods. Such a duplication would be an occasion to introduce errors of omission (information lost during the translation process) or commission (misinterpretation, misguided but invisible design decisions made during the translation) anyway. We think it is up to the software engineer to adapt his or her notations to those of the system engineers he or she must work with. Third, work in patterns and software architectures started from the programminglanguage level and is now moving..
Software engineering and middleware: a roadmap (Invited talk)
The construction of a large class of distributed systems can be simplified by leveraging middleware, which is layered between network operating systems and application components. Middleware resolves heterogeneity and facilitates communication and coordination of distributed components. Existing middleware products enable software engineers to build systems that are distributed across a local-area network. State-of-the-art middleware research aims to push this boundary towards Internet-scale distribution, adaptive and reconfigurable middleware and middleware for dependable and wireless systems. The challenge for software engineering research is to devise notations, techniques, methods and tools for distributed system construction that systematically build and exploit the capabilities that middleware deliver
Ontology-based collaborative framework for disaster recovery scenarios
This paper aims at designing of adaptive framework for supporting
collaborative work of different actors in public safety and disaster recovery
missions. In such scenarios, firemen and robots interact to each other to reach
a common goal; firemen team is equipped with smart devices and robots team is
supplied with communication technologies, and should carry on specific tasks.
Here, reliable connection is mandatory to ensure the interaction between
actors. But wireless access network and communication resources are vulnerable
in the event of a sudden unexpected change in the environment. Also, the
continuous change in the mission requirements such as inclusion/exclusion of
new actor, changing the actor's priority and the limitations of smart devices
need to be monitored. To perform dynamically in such case, the presented
framework is based on a generic multi-level modeling approach that ensures
adaptation handled by semantic modeling. Automated self-configuration is driven
by rule-based reconfiguration policies through ontology
- âŠ