DOI: 10.3897/jucs.147898

Authors: Gustavo Lazarotto Schroeder, Wesllei Felipe Heckler, Rosemary Francisco, Jorge Luis Victória Barbosa

Abstract: Smartphone use has increased globally and has become essential in daily life. Although benefits exist, concerns arise about the negative effects of prolonged hyperconnectivity. The excessive use of smartphones combined with demographic and mental health related risk factors can lead to problematic smartphone use (PSU). PSU is characterized as the compulsive use of smartphones that disrupts an individual’s daily life, work, and relationships. Considering this scenario, the present paper proposes OntoKratos as an ontology designed to detect and prevent PSU. The ontology enables inferences, such as determining the individual’s mental health and PSU state, inferring context information, identifying PSU demographic and emotional risk factors, and suggesting interventions. OntoKratos includes 89 classes, 43 object properties, 35 data properties, and 1,113 axioms. Evaluations performed through a simulated dataset demonstrated the ontology’s effectiveness regarding PSU identification and interventions for PSU behaviors. Ontology’s rules allowed the definition of accurate axioms, improving the correct classification and inference of eight instantiated individuals. This study presents the first ontology for PSU identification and intervention suggestions on PSU behaviors. OntoKratos allows to identify and assist individuals by considering mental health and PSU status, inferring potential PSU risk factors, and providing tailored intervention suggestions to cope with PSU.

HTML

PDF

DOI: 10.3897/jucs.128779

Authors: Carlos Goetz, Rodrigo Simon Bavaresco, Wesllei Felipe Heckler, Gustavo Lazarotto Schroeder, Rafael Kunst, Jorge Luis Victória Barbosa

Abstract: Stress is a mental disorder responsible for impacting the industry through psychosomatic illnesses, loss of productivity, and accidents caused by stressful workplaces. Conversely, the literature indicates that fostering mental well-being among workers can boost motivation and performance while alleviating symptoms of stress. The fourth industrial revolution incorporated technologies into work that allowed the automation of processes and control of environments. The fifth revolution introduced the application of research and innovation aimed at a human-centered consciousness, enabling the advancement of mental health through sensors and wearables. Despite advancements in stress classification technologies, there remain opportunities for further research into identifying stress motivators within industrial work environments. In this sense, this paper proposes an ontology to identify stressors considering personal and environmental data, allowing knowledge generation related to work stressors for mitigating the problem. The methodology utilized in this ontology development consisted of seven stages and two evaluation phases. The findings addressed four key questions related to competency as outlined in the model. The results revealed potential stressful scenarios, including the timing of occurrence, shared locations, environmental factors, and identifying groups experiencing moments of stress. This study presents as a scientific contribution the first ontology to address the identification of work-related stressors in the industrial environment.

HTML

PDF

DOI: 10.3897/jucs.97113

Authors: Ana P. Allian, Leandro F. Silva, Edson OliveiraJr, Elisa Y. Nakagawa

Abstract: Currently, software systems must be appropriately developed to support an amount of variability for accommodating different requirements. To support such development, a diversity of tools has already been designed for variability management (i.e., identification, modeling, evaluation, and realization). However, due to this diversity, there is a lack of consensus on what in fact software variability tools are and even what functionalities they should provide. Besides that, the building of new tools is still an effort- and time-consuming task. To support their building, we present VMTools-RA, a reference architecture that encompasses knowledge and practice for developing and evolving variability tools. Designed in a systematic way, VMTools-RA was evaluated throughout: a controlled experiment with software developer practitioners; and an instantiation of the VMTools-RA architecture to implement a software variability tool, named SMartyModeling. As a result, VMTools-RA is evidenced to be feasible and it can be considered an important contribution to the software variability and developers of variability-intensive software systems community, which require specific tools developed in a faster manner with less risk, what a reference architecture could provide.

HTML

XML

PDF

DOI: 10.3897/jucs.84558

Authors: Shashi Kant Shankar, Adolfo Ruiz-Calleja, Luis P. Prieto, María Jesús Rodríguez-Triana, Pankaj Chejara, Sandesh Tripathi

Abstract: Multimodal Learning Analytics (MMLA) solutions aim to provide a more holistic picture of a learning situation by processing multimodal educational data. Considering contextual information of a learning situation is known to help in providing more relevant outputs to educational stakeholders. However, most of the MMLA solutions are still in prototyping phase and dealing with different dimensions of an authentic MMLA situation that involve multiple cross-disciplinary stakeholders like teachers, researchers, and developers. One of the reasons behind still being in prototyping phase of the development lifecycle is related to the challenges that software developers face at different levels in developing context-aware MMLA solutions. In this paper, we identify the requirements and propose a data infrastructure called CIMLA. It includes different data processing components following a standard data processing pipeline and considers contextual information following a data structure. It has been evaluated in three authentic MMLA scenarios involving different cross-disciplinary stakeholders following the Software Architecture Analysis Method. Its fitness was analyzed in each of the three scenarios and developers were interviewed to assess whether it meets functional and non-functional requirements. Results showed that CIMLA supports modularity in developing context-aware MMLA solutions and each of its modules can be reused with required modifications in the development of other solutions. In the future, the current involvement of a developer in customizing the configuration file to consider contextual information can be investigated.

HTML

XML

PDF

DOI: 10.3897/jucs.90663

Authors: Venilton FalvoJr, Anderson da Silva Marcolino, Nemésio Freitas Duarte Filho, Edson OliveiraJr, Ellen Francine Barbosa

Abstract: The popularity of mobile devices in all social classes has motivated the development of mobile learning (m-learning) applications. The existing applications, even having many benefits and facilities in relation to the teaching-learning process, still presents problems and challenges, es- pecially regarding the development, reuse and architectural standardization. Particularly, there is a growing adoption of the Software Product Line (SPL) concept, in view of research that investigates these gaps. This paradigm enables organizations to explore the similarities and variabilities of their products, increasing the reuse of artifacts and, consequently, reducing costs and development time. In this context, we discuss how systematic reuse can improve the development of solutions in the m-learning domain. Therefore, this work presents the design, development and experimental evaluation of M-SPLearning, an SPL created to enable the systematic production of m-learning applications. Specifically, the conception of M-SPLearning covers from the initial study for an effective domain analysis to the implementation and evaluation of its functional version. In this regard, the products have been experimentally evaluated by industry software developers, pro- viding statistical evidence that the use of our SPL can speed up the time-to-market of m-learning applications, in addition to reducing their respective number of faults.

HTML

XML

PDF

DOI: 10.3897/jucs.70325

Authors: Manel Mena, Javier Criado, Luis Iribarne, Antonio Corral

Abstract: Cyber-Physical Systems (CPS) and Internet of Things (IoT) devices are handled by numerous different protocols. The management and connection to those devices tend to create usability and integrability issues. This brings about the need for a solution capable of facilitating the communication between different platforms and devices. The Web of Things (WoT) describes interfaces and interaction patterns among things, thereby abstracting itself from the underlying protocols used to manage those things and their implementation strategies. This paper describes the concept of Digital Dice, an abstraction of IoT devices and CPS capable of leveraging the advantages of microservices architectures and inspired by the concept of Digital Twins. A Digital Dice is a servient system of the WoT domain that represents a device by the features of the device, hence different WoT description models result in different microservices related to the particular thing. The paper explores the definition of Digital Dices and the conversion between WoT Thing Description Models and Digital Dices and the architecture that sustains the system.

HTML

XML

PDF

DOI: 10.3897/jucs.65083

Authors: Oscar Carlos Medina, Manuel Pérez Cota, Brenda Elizabeth Meloni, Marcelo Martín Marciszack

Abstract: A pattern is a model that allows reusing a successful solution to the same problem in a different context. A pattern implementation could be the elaboration of an analysis model to incorporate good practices patterns Conceptual Modelling of Electronic Government systems. Defining a new pattern, and selecting a previously existing one from a limited set, called catalogue, are essential activities that every analysis model must solve when using patterns. The present work describes a proposal to manage a Business Patterns catalogue that can be applied to Conceptual Modelling of software products. Business Patterns allow to model and design business processes inside an organization, being it public or private. An application, called “PatCat” (Pattern Catalogue), was developed to test de proposal, using the Business Model of an Information System for a public education institution as a pilot. The introduction of patterns at the beginning of the Modelling Process allows to simplify and clarify the requirements elicitation, amongst other benefits. Thus, a specific management application for a pattern catalogue is useful to standardize and speed up this software design task.

HTML

XML

PDF

DOI: 10.3897/jucs.2020.067

Authors: Ana Allian, Edson OliveiraJr, Rafael Capilla, Elisa Nakagawa

Abstract: For nearly 30 years, industry and researchers have proposed many software variability tools to cope with the complexity of modeling variability in software development, followed by a number of publications on variability techniques built upon theoretical foundations. After more than 25 years of the practice of software variability, there are not many studies investigating the impact of software variability tools in the industry and the perception of practitioners. For this reason, we investigate in this research work how existing software variability tools fulfill the needs of companies demanding this kind of tool support. We conducted a survey with practitioners from companies in eight different countries in order to analyze the missing capabilities of software variability management tools and we compared the results of the survey with the scientifoc literature through a systematic mapping study (SMS) to analyze if the proposed solutions cover the needs required by practitioners. Our major findings indicate that many tools lack important qualities such as interoperability, collaborative work, code generation, scalability, impact analysis, and test; while the results from the SMS showed these such capabilities are, to some extent, found in some of the existing tools.

HTML

XML

PDF

DOI: 10.3897/jucs.2020.051

Authors: Robin Horst, Ramtin Naraghi-Taghi-Off, Linda Rau, Ralf Dorner

Abstract: Bite-sized learning is a current educational trend in which educators divide content into relatively small, easily comprehensible chunks, called nuggets. In this paper, we introduce an authoring toolkit that relies on VR implementation of nuggets and show that a nugget-based approach is also facilitating the authoring of VR learning content. In particular, we present Immersive Nugget Tiles (IN-Tiles), a novel authoring toolkit aimed at authors who are not experts in VR. With IN-Tiles, manipulating VR nuggets and authoring VR learning content can be directly accomplished within a virtual environment allowing authors to immediately experience the results of their authoring efforts in VR. We discuss the underlying concepts of IN-Tiles, specifically how to visualize VR nuggets in a virtual environment and how to present affordances that support authoring and manipulating VR nuggets. We report the results of a user study where we evaluated the IN-Tiles toolkit and compared it to a conventional 2D authoring environment that also relies on component-based VR. The results support the hypothesis that nugget-based immersive authoring tools are suitable to create bitesized VR applications successfully and that authoring directly in VR has an added value particularly for authors who are no IT specialists.

HTML

XML

PDF

DOI: 10.3217/jucs-024-12-1731

Authors: Amit Rathee, Jitender Chhabra

Abstract: During various phases of software development lifecycle, the internal structure of the software degrades which finally results in increased maintenance efforts and hence cost. One quick solution to this problem is software remodularization in which restructuring of different software elements such as classes/ packages/ methods is done (without changing their original meaning and functionality). Several researchers have proposed different techniques for software remodularization. Each technique considers two points of view: dependency measurement among software elements (based on structural, conceptual and/or change history based relations) and performing clustering using different algorithms. So, in this paper, first of all, an empirical evaluation is carried out in order to test the role of different dependency relations in modeling dependency among different software elements. From an empirical evaluation, it is observed that the change history of a software system plays a major role in modeling dependency relations and hence must be used along with other relations for more accurate measures. Then, a new weighted dependency measurement scheme is proposed by combining structural, conceptual and change history based relations among software elements together, with more importance to evolutionary dependency relations. Finally, different dependency schemes are evaluated with six clustering algorithms by applying them to four standard open source Java software of variable sizes and belonging to different domains. The obtained results show that our proposed approach is capable of accurately determining dependence relations among various software elements as compared to other similar approaches present in literature and thus increases restructuring accuracy.

HTML

XML

PDF

DOI: 10.3217/jucs-024-11-1536

Authors: Jose Alvarez-Rodríguez, Roy Mendieta, Jose Luis de la Vara, Anabel Fraga, Juan Llorens

Abstract: The use of different techniques and tools is a common practice to cover all stages in the systems development lifecycle, generating a very good number of system artefacts. Moreover, these artefacts are commonly encoded in different formats and can only be accessed, in most cases, through proprietary and non-standard protocols. This scenario can be considered a real nightmare for software or systems reuse. Possible solutions imply the creation of a real collaborative development environment where tools can exchange and share data, information and knowledge. In this context, the OSLC (Open Services for Lifecycle Collaboration) initiative pursues the creation of public specifications (data shapes) to exchange any artefact generated during the development lifecycle, by applying the principles of the Linked Data initiative. In this paper, the authors present a solution to provide a real multi-format system artefact reuse by means of an OSLC-based specification to share and exchange any artefact under the principles of the Linked Data initiative. Finally, two experiments are conducted to demonstrate the advantages of enabling an input/output interface based on an OSLC implementation on top of an existing commercial tool (the Knowledge Manager). Thus, it is possible to enhance the representation and retrieval capabilities of system artefacts by considering the whole underlying knowledge graph generated by the different system artefacts and their relationships. After performing 45 different queries over logical and physical models stored in Papyrus, IBM Rhapsody and Simulink, results of precision and recall are promising showing average values between 70-80%.

HTML

XML

PDF

DOI: 10.3217/jucs-023-01-0042

Authors: Shayan Najd, Simon Jones

Abstract: We study the notion of extensibility in functional data types, as a new approach to the problem of decorating abstract syntax trees with additional information. We observed the need for such extensibility while redesigning the data types representing Haskell abstract syntax inside Glasgow Haskell Compiler (GHC). Specifically, we describe a programming idiom that exploits type-level functions to allow a particular form of extensibility. The approach scales to support existentials and generalised algebraic data types, and we can use pattern synonyms to make it convenient in practice.

HTML

XML

PDF

DOI: 10.3217/jucs-022-10-1380

Authors: Kousuke Mouri, Hiroaki Ogata, Noriko Uosaki, Erdenesaikhan Lkhagvasuren

Abstract: In the past decades, ubiquitous learning (u-learning) has been the focus of attention in educational research across the world. Majority of u-learning systems have been constructed using ubiquitous technologies such as RFID tags and cards, wireless communication, mobile phones, and wearable computers. There is also a growing recognition that it can be improved by utilizing ubiquitous learning logs collected by the u-learning system to enhance and increase the interactions among a learner, contexts, and context-based knowledge. One of the issues of analytics based on u-learning is how to detect or mine learning logs collected by u-learning systems. Moreover, it is necessary to evaluate whether the recommendations detected by analysis are appropriate in terms of learning levels, contexts and learners' preference. To tackle the issues, we developed a system that could recommend useful learning logs at the right place in the right time in accordance with personalization of learners. An experiment was conducted to evaluate the system's performance and the recommendations' usefulness for learning. In the evaluation experiment, we found important criteria for recommending in the real-world language learning. In addition, the participants were able to increase their learning opportunities by our recommendation method.

HTML

XML

PDF

DOI: 10.3217/jucs-021-13-1746

Authors: Nadia Bouassida, Salma Jamoussi, Ahmed Msaed, Hanêne Ben-Abdallah

Abstract: Any inexperienced designer may not take advantage of design patterns due to their high level of abstraction, on the one hand, and their overwhelming number, on the other hand. In this paper, we propose a new approach that first retrieves and recommends a design pattern that is adequate to a designer's modeling context, it then helps them in its instantiation. Our approach learns past pattern reuse cases and it interacts with the designer through a questionnaire to ensure that the retrieved pattern corresponds to their needs and intentions. It uses the text mining technique Principal Component Analysis on past experiences of design pattern reuses; the choice of this technique was based on an experimental evaluation we conducted to determine the most adequate text representation and mining technique for our problem. In a final assistance step, after retrieving the most appropriate design pattern, our approach transforms the design situation at hand into the pattern constituting the solution.

HTML

XML

PDF

DOI: 10.3217/jucs-021-13-1708

Authors: Enrique Flores, Alberto Barrón-Cedeño, Lidia Moreno, Paolo Rosso

Abstract: Nowadays, Internet is the main source to get information from blogs, encyclopedias, discussion forums, source code repositories, and more resources which are available just one click away. The temptation to re-use these materials is very high. Even source codes are easily available through a simple search on the Web. There is a need of detecting potential instances of source code re-use. Source code re-use detection has usually been approached comparing source codes in their compiled version. When dealing with cross-language source code re-use, traditional approaches can deal only with the programming languages supported by the compiler. We assume that a source code is a piece of text ,with its syntax and structure, so we aim at applying models for free text re-use detection to source code. In this paper we compare a Latent Semantic Analysis (LSA) approach with previously used text re-use detection models for measuring cross-language similarity in source code. The LSA-based approach shows slightly better results than the other models, being able to distinguish between re-used and related source codes with a high performance.

HTML

XML

PDF

DOI: 10.3217/jucs-021-11-1405

Authors: Iaakov Exman, Juan Llorens, Anabel Fraga, Jose Alvarez-Rodríguez

Abstract: There has been a growing awareness of deep relations between software and knowledge. Software, from an efficiency oriented way to program computing machines, gradually converged to human oriented Runnable Knowledge. Apparently this has happened unintentionally, but knowledge is not incidental to software. The basic thesis: runnable knowledge is the essence of abstract software. A knowledge distillation procedure is offered as a constructive feasibility proof of the thesis. A formal basis is given for these notions. Runnable knowledge is substantiated in the association of semantic structural models (like ontologies) with formal behavioral models (like UML statecharts). Meaning functions are defined for ontologies in terms of concept densities. Examples are provided to concretely clarify the meaning and implications of knowledge runnability. The paper concludes with the runnable knowledge convergence point: SKYWare, a new term designating the domain in which content meaning is completely independent of any underlying machine.

HTML

XML

PDF

DOI: 10.3217/jucs-021-06-0856

Authors: Alejandro Zambrano, Carlos Toro, Marcos Nieto, Ricardo Sotaquira, Cesar Sanín, Edward Szczerbicki

Abstract: This paper proposes a service-oriented architecture for video analysis which separates object detection from event recognition. Our aim is to introduce new tools to be considered in the pathway towards Cognitive Vision as a support for classical Computer Vision techniques that have been broadly used by the scientific community. In the article, we particularly focus in solving some of the reported scalability issues found in current Computer Vision approaches by introducing an experience based approximation based on the Set of Experience Knowledge Structure (SOEKS). In our proposal, object detection takes place client-side, while event recognition takes place server-side. In order to implement our approach, we introduce a novel architecture that aims at recognizing events defined by a user using production rules (a part of the SOEKS model) and the detections made by the client using their own algorithms for visual recognition. In order to test our methodology, we present a case study, showing the scalability enhancements provided.

HTML

XML

PDF

DOI: 10.3217/jucs-020-08-1071

Authors: Laura González, Guadalupe Ortiz

Abstract: Web services are nowadays one of the preferred technologies to implement service-oriented architectures and to communicate distributed applications. On the other hand, context-awareness is highly demanded for distributed applications. However, even though there are excellent tools and frameworks for service development, getting services to be context-aware is still under investigation. In turn, an Enterprise Service Bus (ESB) is a standards-based integration platform, which provides mediation capabilities (e.g. routing, transformation). ESBs are being increasingly used in conjunction with Complex Event Processing (CEP) engines to support event-driven architectures scenarios. In this regard, this paper proposes an ESB-based integration platform which, leveraging its mediation capabilities and a CEP engine, allows the construction of context-aware web services. Concretely, CEP techniques are used to detect the complex situations that may affect services and mediation mechanisms are used to adapt service requests and responses to make them context-aware.

HTML

XML

PDF

DOI: 10.3217/jucs-020-05-0797

Authors: Luiz Laerte Nunes Da Silva Junior, Alexandre Plastino, Leonardo Gresta Paulino Murta

Abstract: In the software development field, the amount of data related to documentation and to the source code itself is huge. Relevant knowledge can be extracted from these data, provided that the adequate tools are in place. In this context, data mining can be seen as an important tool. This paper presents a new approach for code completion based on sequential patterns mined from previous developed source code. According to what is being coded, suggestions of new code sequences are made based on the mined patterns. As a result, a plug-in for the Eclipse IDE, named Vertical Code Completion, was developed and applied over widely known Open Source systems, identifying that our approach could provide suggestions that would anticipate what a developer intends to code.

HTML

XML

PDF

DOI: 10.3217/jucs-020-05-0772

Authors: Otavio A. L. Lemos, Adriano De Paula, Gustavo Konishi, Sushil Bajracharya, Joel Ossher, Cristina Lopes

Abstract: Test-driven code search (TDCS) is an approach to code search and reuse that uses test cases as inputs to form the search query. Together with the test cases that provide more semantics to the search task, keywords taken from class and method names are still required. Therefore, the effectiveness of the approach also relies on how good these keywords are, i.e., how frequently they are chosen by developers to name the desired functions. To help users choose adequate words in their query test cases, visual aids can be used. In this paper we propose thesaurus-based tag clouds to show developers terms that are more frequently used in the code repository to improve their search. Terms are generated by looking up words similar to the initial keywords on a thesaurus. Tag clouds are then formed based on the frequency in which these terms appear in the code base. Our approach was implemented with an English thesaurus as an extension to CodeGenie, a Java- and Eclipse-based TDCS tool. Our evaluation shows evidence that the approach can help improve the number of returned results, recall (by ∼28%, on average), and precision (by ∼14%, on average). We also noticed the visual aid can be especially useful for non-native speakers of the language in which the code repository is written. These users are frequently unaware of the most common terms used to name specific functionality in the code, in the given language.

HTML

XML

PDF

DOI: 10.3217/jucs-020-05-0720

Authors: Rafael De Mello, Eldanae Teixeira, Marcelo Schots, Cláudia Maria Lima Werner, Guilherme Travassos

Abstract: Software Product Line Engineering (SPL) should ensure the correctness, completeness and consistenc y of its artefacts and related domain to prevent the propagation of defects in derived products. Software inspection techniques are effective in detecting defects in software artefacts and avoiding their propagation throughout the software development process. However, the results of a quasi-systematic review of the technical literature reported in this paper pointed to a lack of such techniques to support the inspection of SPL artefacts, including techniques to support the inspection of feature models (FMs) that are largely used in domain modelling. Therefore, a checklist-based inspection technique (FMCheck) has been developed to support the detection of defects on FMs. FMCheck is configurable and can be applied to the original feature model notation (the F ODA approach) and its extensions, including the Odyssey-FEX notation. The inspection technique was empirically evaluated, having indicated its feasibility and effectiveness. It is possible to see that inspectors applying FMCheck to inspect F-s can be more effective than those applying ad-hoc techniques, regarding four distinct domains.

HTML

XML

PDF

DOI: 10.3217/jucs-020-05-0692

Authors: Rodrigo Andrade, Henrique Rebelo, Márcio Ribeiro, Paulo Borba

Abstract: In Software Product Lines (SPL), we can bind reusable features to compose a product at different times, which in general are static or dynamic. The former allows customizability without any overhead at runtime. On the other hand, the latter allows feature activation or deactivation while running the application with the cost of performance and memory consumption. To implement features, we might use aspect-oriented programming (AOP), in which aspects enable a clear separation between invariable code and variable code. In this context, recent work provides AspectJ-based idioms to implement flexible feature binding. However, we identified some design deficiencies. Thus, to solve the issues of these idioms, we incrementally create three AspectJ-based idioms. We apply these idioms to provide flexible binding for 16 features from five different product lines. Moreover, to evaluate our idioms, we quantitatively analyze them with respect to code cloning, scattering, tangling, and size by means of software metrics. Besides that, we qualitatively discuss our idioms in terms of code reusability, changeability, instrumentation overhead, behavior, and feature interaction. In conclusion, we show evidences that our idioms address the issues of those existing ones.

HTML

XML

PDF

DOI: 10.3217/jucs-020-05-0666

Authors: Raphael De Oliveira, David Blanes, Javier Gonzalez-Huerta, Emilio Insfran, Silvia Abrahão, Sholom Cohen, Eduardo De Almeida

Abstract: The specification of requirements is a key activity for achieving the goals of any software project and it has long been established and recognized by researchers and practitioners. Within Software Product Lines (SPL), this activity is even more critical owing to the need to deal with common, variable, and product-specific requirements, not only for a single product but for the whole set of products. In this paper, we present a Feature-Driven Requirements Engineering approach (FeDRE) that provides support to the requirements specification of SPL. The approach realizes features into functional requirements by considering the variability captured in a feature model. It also provides detailed guidelines on how to associate chunks of features from a feature model and to consider them as the context for the Use Case specification. The evaluation of the approach is illustrated in a case study for developing an SPL of mobile applications for emergency notifications. This case study was applied within 14 subjects, 8 subjects from Universitat Politècnica de València and 6 subjects from Federal University of Bahia. Evaluations concerning the perceived ease of use, perceived usefulness, effectiveness and efficiency as regards requirements analysts using the approach are also presented. The results show that FeDRE was perceived as easy to learn and useful by the participants.

HTML

XML

PDF

DOI: 10.3217/jucs-020-05-0640

Authors: Mauricio Alférez, Roberto Lopez-Herrejón, Ana Moreira, Vasco Amaral, Alexander Egyed

Abstract: Software Product Line Engineering (SPLE) is a successful paradigm to produce a family of products for a specific domain. A challenge in SPLE is to check that different models used in early SPL specification do not contain inconsistent information that may be propagated and generate inconsistent products that do not conform to its requirements. This challenge is difficult to address due to the high number of possible combinations of product features and model fragments specifying those features. Variability Consistency Checking (VCC) offers automatic means to address that challenge. VCC relates information inferred from the relationships between features and from base models related to those features. Validating if all the products in an SPL satisfy user-defined consistency constraints is based on searching for a satisfying assignment of each formula generated by VCC. We validated VCC and its supporting tool on two case studies from different application domains, the results were encouraging as we did not observed significant performance penalties.

HTML

XML

PDF

DOI: 10.3217/jucs-020-05-0587

Authors: Felype Ferreira, Rohit Gheyi, Paulo Borba, Gustavo Soares

Abstract: Developers evolve software product lines (SPLs) manually or using typical program refactoring tools. However, when evolving an SPL to introduce new features or to improve its design, it is important to make sure that the behavior of existing products is not affected. Typical program refactorings cannot guarantee that because the SPL context goes beyond code and other kinds of core assets, and involves additional artifacts such as feature models and configuration knowledge. Besides that, we typically have to deal with a set of alternative assets that do not constitute a well-formed program in an SPL. As a result, manual changes and existing program refactoring tools may introduce behavioral changes or invalidate existing product configurations. To reduce such risks, we propose approaches and implement four tools for making product line evolution safer. These tools check if SPL transformations preserve the behavior of the original SPL products. They implement different and practical approximations of refinement notions from a theory for safely evolving SPLs. Besides specifying the algorithms of each approach, we compare them with respect to soundness, performance and code coverage in 35 evolution scenarios of an SPL with 32 KLOC.

HTML

XML

PDF

DOI: 10.3217/jucs-020-04-0534

Authors: Patricia Matsumoto, Eduardo Guerra

Abstract: An Adaptive Object Model (AOM) is a common architectural style for systems in which classes, attributes, relationships and behaviors of applications are represented as metadata consumed at runtime. This allows them to be very flexible and changeable at runtime, enabling their modification by end users without source code modification. Nevertheless, this flexibility comes with a cost of a greater complexity when developing the system, and therefore one usually uses a bottom-up approach, adding flexibility only when it is needed. As a consequence, many AOM components are tied to the specific domain of a single application and this fact makes it difficult to develop and use generic and reusable AOM frameworks that properly handle specific requirements of the AOM architecture. This work presents an architectural model that aims to adapt domain-specific AOM core structures to a common core structure by identifying AOM roles played by each element through custom metadata configuration. By doing this, this model allows the integration of domain-specific AOM applications and AOM frameworks, making it feasible to develop reusable components for the AOM architecture. This model is evaluated by creating an AOM framework and a case study based on it, in which is performed a modularity and a performance analysis.

HTML

XML

PDF

DOI: 10.3217/jucs-019-10-1433

Authors: Jennifer Pérez, Isidro Ramos, Jose Carsí, Cristóbal Costa-Soria

Abstract: The Model-Driven Development (MDD) paradigm has become widely spread in the last few years due to being based on models instead of source code, and using automatic generation techniques to obtain the final software product. Until now, the most mature methodologies that have been proposed to develop software following MDD are mainly based on functional requirements by following the Object-Oriented Paradigm. Therefore, mature MDD methodologies are required for supporting the code generation from models that specify non-functional requirements. The Aspect-Oriented Software Development (AOSD) approach was created to provide explicit mechanisms for developing non-functional requirements through reusable elements called aspects. Aspect-Oriented Software Architectures (AOSA) emerged to deal with the design of both, functional requirements and non-functional requirements, which opened an important challenge in the software engineering field: the definition of a methodology for supporting the development of AOSAs following the MDD paradigm. This new methodology should allow the code generation from models which specify functional and non-functional requirements. This paper presents a mature approach, called PRISMA, which deals with this challenge. Therefore, this contribution takes a step forward in the area presenting in detail the PRISMA MDD process, which has been applied to generate the code of several real applications of the tele-operated robotics domain. PRISMA MDD approach provides complete support for the development of technology-independent AOSAs, which can be compiled from high-level, aspect-oriented architectural models into different technology platforms and languages following an MDD process. This contribution illustrates how to apply the PRISMA MDD approach through the modelling framework that has been developed to support it, and a case study of a tele-operated robot that has been completely developed using this approach. Finally, the results obtained from the application of PRISMA MDD process to develop applications of the tele-operation domain are analyzed in terms of code generation.

HTML

XML

PDF

DOI: 10.3217/jucs-019-07-0873

Authors: Diogo Azevedo, Benjamim Fonseca, Hugo Paredes, Stephan Lukosch, Jordan Janeiro, Robert Briggs

Abstract: The need for computer-supported collaboration has grown over the last years and made collaboration an important factor within organizations. This trend has resulted in the development of a variety of tools and technologies to support the various forms of collaboration. Many collaborative processes, e.g. strategy building, scenario analysis, root cause analysis and requirements engineering, require various collaboration support tools. Data flow, fishbone and brainstorming diagrams, play an important role within these synchronous collaborative applications to create, evaluate, elaborate, discuss, and revise graphical models. Currently, the necessary tools are not integrated and flexible enough to support such processes. In this paper, a synchronous collaborative brainstorming diagram editor integrated in a flexible group support system is described. This approach goes beyond the current state of the art as it can be seamlessly integrated with other collaboration support tools such as text-based brainstorming or voting. The usability of the taken approach is evaluated within a case study on collaborative learning.

HTML

XML

PDF

DOI: 10.3217/jucs-019-02-0254

Authors: Fabiane Barreto Vavassori Benitti, Rodrigo Cezario da Silva

Abstract: The benefits of reusing artifacts in the software development process are well-known in the software engineering community, and the earlier in the system development life-cycle reuse is attempted, the more benefit can be expected. Thus, we highlight the reuse of requirement specifications, leading to greater reuse of other artifacts such as models, code and tests. This paper presents an approach to the requirements reuse, supported by a tool that gives suggestions for reuse from requirement patterns, a patterns catalog and traceability between requirements. The efficiency and effectiveness of the approach were evaluated using a quasi-experiment in a university. We conducted a quantitative evaluation of the approach, and an assessment of participants' perceptions regarding the use of the approach and the computational tool. Finally, we performed a qualitative assessment using the GQM method, from the point of view of experts in the area of requirements engineering, in order to obtain more indicators of the feasibility of applying the approach in companies. The results of the quasi-experiment indicate that the approach presented makes the activities of requirement elicitation and specification about 40% more efficient and effective in terms of the way they are conducted, without the support of the approach. Regarding the perceptions on the use, the experimental group positively evaluated the proposed approach and the developed tool. Based on the evaluation by the GQM method, indicators were obtained that the approach assists in activities of requirement elicitation and specification, from the point of view of experts.

HTML

XML

PDF

DOI: 10.3217/jucs-019-02-0233

Authors: Klaus Schmid, Holger Eichelberger, Christian Kröher

Abstract: Service-Oriented Computing (SoC) has been established as an important paradigm over the last decade. A particularly important part in a service-oriented solution is the service-oriented platform. This provides an environment and infrastructure for a number of service-oriented applications. An important challenge in complex application areas is the need to customize these platforms to the demands of a specific context. Product line technologies can support this by providing the concept of variability management to SoC. In this paper, we will provide a reference model for (domain-specific) service platforms and describe different approaches that provide customization possibilities in a service platform context. The complexity of handling the customization of large-scale service platforms in an integrated manner will be addressed by introducing the concept of production strategies for variability implementation techniques.

HTML

XML

PDF

DOI: 10.3217/jucs-019-02-0207

Authors: Hamideh Sabouri, Ramtin Khosravi

Abstract: Software product line engineering enables proactive reuse among a set of related products through explicit modeling of commonalities and differences among them. Features are usually used to distinguish different products as a product is identified by its supported feature set that is represented by a configuration. Dynamic product lines enhance flexibility of a product by allowing run-time reconfiguration. In this paper, we focus on modeling and verification of families of concurrent and distributed systems that are reconfigurable. To this end, we introduce the notion of variability in actor models to achieve family of reconfigurable actors. Then, we present our methodology to model this concept using the actor-based modeling language Rebeca. The model checking backbone of Rebeca enables us to ensure establishment of certain constraints on reconfigurations. We show the applicability and effectiveness of our approach by applying it on a set of case studies.

HTML

XML

PDF

DOI: 10.3217/jucs-019-01-0110

Authors: Matias Urbieta, Gustavo Rossi, Silvia Gordillo, Armanda Rodrigues, Joao Araujo, Ana Moreira

Abstract: The growing availability of on-line geographical information, since the advent of open map servers in the 2000s, originated a new generation of Web applications, those which combine "conventional" Web functionality with typical features of traditional Geographic Application System (GIS). The rapid growth in number and complexity of Web applications with geo-referenced data together with the need to support fast requirements change, demands for increased modularity. The volatility of some of these changing requirements, both in the scope of their geographic nature or in the period of time in which they are valid, stresses the importance of the applications" modularity. A solution is to take into consideration the crosscutting nature of these requirements and decouple their realization from "conventional" requirements in separate software modules. This paper proposes an end-to-end Aspect-Oriented approach to deal with spatial requirements from the early stages of applications development throughout to implementation. A significant contribution of this approach is the characterization of the most common spatial requirements in Web-GIS applications. The result is the improvement of

HTML

XML

PDF

DOI: 10.3217/jucs-018-11-1558

Authors: Miloš Milovanović, Miroslav Minović, Starčević Dušan

Abstract: In recent years identity management systems significantly increased the use of biometry. This process shifted this research area towards academia that in turn resulted with the rise of available biometric solutions, especially open source ones. Most of these solutions deal with only one biometric modality. The problem is that the price of the solution affects the precision and performances of the system. Open source solutions usually struggle with this issue since the funds for development are very limited. Possible solution can be found in using the multimodal approach that involves using several biometric modalities to improve preciseness and performances of the system. Unfortunately this opens another issue of interoperability among existing biometric solutions, acquisition devices and databases. This paper focuses on solving this issue, by proposing the interoperability framework for this purpose. Efficiency of the proposed framework was evaluated by using it as a development platform for developing a multimodal biometric application that combined three separate biometric modalities: fingerprint, face and voice. Proposed framework should further accelerate future development of biometric solutions.

HTML

XML

PDF

DOI: 10.3217/jucs-017-13-1765

Authors: Ahilton Barreto, Leonardo Gresta Paulino Murta, Ana Rocha

Abstract: Software product development has been taking advantage of reuse techniques for some decades. Concepts like software components, architectures, and product lines have been successfully applied in several contexts to develop software products, although some difficulties are still faced. Software processes have strong similarities with software products, and some researchers argue that they are software too. Therefore, we believe that software processes may take advantage of some benefits expected by the use of existing software products reuse techniques, adapted to software processes. It is also possible that similar difficulties are faced. This paper presents a software process definition approach based on reuse techniques, which aims at making some of the benefits expected by software product reuse available to software process definition activities. Concepts such as process components, architectures, process lines and features are described and used. We describe the proposed approach, tools developed to support it, and also results of a survey on the expected benefits and difficulties on software process reuse in the point of view of experienced software process engineers.

HTML

XML

PDF

DOI: 10.3217/jucs-017-05-0807

Authors: Paula Fernandes, Cláudia Maria Lima Werner, Eldanae Teixeira

Abstract: Feature modeling is an approach to represent commonalities and variabilities among products of a product line. Context-aware applications use context information to provide relevant services and information for their users. One of the challenges to build a context-aware product line is to develop mechanisms to incorporate context information and adaptation knowledge in a feature model. This paper presents UbiFEX, an approach to support feature analysis for context-aware software product lines, which incorporates a modeling notation and a mechanism to verify the consistency of product configuration regarding context variations. Moreover, an experimental study was performed as a preliminary evaluation, and a prototype was developed to enable the application of the proposed approach.

HTML

XML

PDF

DOI: 10.3217/jucs-017-05-0777

Authors: Javier Cubo, Carlos Canal, Ernesto Pimentel

Abstract: Using pre-existing software components (COTS) to develop software systems requires the composition and adaptation of the component interfaces to solve mismatch problems. These mismatches may appear at different interoperability levels (signature, behavioural, quality of service and semantic). In this article, we define an approach which supports composition and adaptation of software components based on model transformation by taking into account the four levels. Signature and behavioural levels are addressed by means of transition systems. Context-awareness and semanticbased techniques are used to tackle quality of service and semantic, respectively, but also both consider the signature level. We have implemented and validated our proposal for the design and application of realistic and complex systems. Here, we illustrate the need to support the variability of the adaptation process in a context-aware pervasive system through a real-world case study, where software components are implemented using Windows Workflow Foundation (WF). We apply our model transformation process to extract transition systems (CA-STS specifications) from WF components. These CA-STSs are used to tackle the composition and adaptation. Then, we generate a CASTS adaptor specification, which is transformed into its corresponding WF adaptor component with the purpose of interacting with all the WF components of the system, thereby avoiding mismatch problems.

HTML

XML

PDF

DOI: 10.3217/jucs-017-05-0742

Authors: Fréderic Loiret, Romain Rouvoy, Lionel Seinturier, Daniel Romero, Kévin Sénéchal, Aleš Plšek

Abstract: Software components are used in various application domains, and many component models and frameworks have been proposed to fulfill domain-specific requirements. The general trend followed by these approaches is to provide ad-hoc models and tools for capturing these requirements and for implementing their support within dedicated runtime platforms, limited to features of the targeted domain. The challenge is then to propose more flexible solutions, where components reuse is domain agnostic. In this article, we present a framework supporting compositional construction and development of applications that must meet various extra-functional/domain-specific requirements. The key points of our contribution are: i) We target development of component-oriented applications where extra-functional requirements are expressed as annotations on the units of composition in the application architecture. ii) These annotations are implemented as open and extensible component-based containers, achieving full separation of functional and extra-functional concerns. iii) Finally, the full machinery is implemented using the Aspect-Oriented Programming paradigm. We validate our approach with two case studies: the first is related to real-time and embedded applications, while the

HTML

XML

PDF

DOI: 10.3217/jucs-017-05-0684

Authors: Rohit Gheyi, Tiago Massoni, Paulo Borba

Abstract: A feature model (FM) defines the valid combinations of features, whose combinations correspond to a program in a Software Product Line (SPL). FMs may evolve, for instance, during refactoring activities. Developers may use a catalog of refactorings as support. However, the catalog is incomplete in principle. Additionally, it is non-trivial to propose correct refactorings. To our knowledge, no previous analysis technique for FMs is used for checking properties of general FM refactorings (a transformation that can be applied to a number of FMs) containing a representative number of features. We propose an efficient encoding of FMs in the Alloy formal specification language. Based on this encoding, we show how the Alloy Analyzer tool, which performs analysis on Alloy models, can be used to automatically check whether encoded general and specific FM refactorings are correct. Our approach can analyze general transformations automatically to a significant scale in a few seconds. In order to evaluate the analysis performance of our encoding, we evaluated in automatically generated FMs ranging from 500 to 2,000 features. Furthermore, we analyze the soundness of general transformations.

HTML

XML

PDF

DOI: 10.3217/jucs-017-05-0639

Authors: Mónica Pinto, Lidia Fuentes

Abstract: The quality attributes of a software system are, to a large extent, determined by the decisions taken early in the development process. Best practices in software engineering recommend the identification of important quality attributes during the requirements elicitation process, and the specification of software architectures to satisfy these requirements. Over the years the software engineering community has studied the relationship between quality attributes and the use of particular architectural styles and patterns. In this paper we study the relationship between quality attributes and Aspect-Oriented Software Architectures - which apply the principles of Aspect-Oriented Software Development (AOSD) at the architectural level. AOSD focuses on identifying, modeling and composing crosscutting concerns - i.e. concerns that are tangled and/or scattered with other concerns of the application. In this paper we propose to use AO-ADL, an aspect-oriented architectural description language, to specify quality attributes by means of parameterizable, and thus reusable, architectural patterns. We particularly focus on quality attributes that: (1) have major implications on software functionality, requiring the incorporation of explicit functionality at the architectural level; (2) are complex enough as to be modeled by a set of related concerns and the compositions among them, and (3) crosscut domain specific functionality and are related to more than one component in the architecture. We illustrate our approach for usability, a critical quality attribute that satisfies the previous constraints and that requires special attention at the requirements and the architecture design stages.

HTML

XML

PDF

DOI: 10.3217/jucs-016-17-2455

Authors: Lunjin Lu, Dae-Kyoo Kim, Yuanlin Zhu, Sangsig Kim

Abstract: This paper formalizes UML class diagrams and structural patterns as mathematical objects and provides a precise notion of conformance of a structural model specified as a class diagram to a structural pattern. We also present a conformance verification method which represents a class diagram as a logic program and a structural pattern as a query. The conformance of the class diagram to the structural pattern is verified by computing all the answers to the query by the logic program and checking the satisfaction of realization multiplicity constraints imposed by the pattern.

HTML

XML

PDF

DOI: 10.3217/jucs-016-17-2313

Authors: Miguel Laguna, José Marqués

Abstract: Software product lines have become a successful but challenging approach to software reuse. Some of the problems that hinder the adoption of this development paradigm are the conceptual gap between the variability and design models, as well as the complexity of the traceability management between them. Most current development methods use UML stereotypes or modify UML to face variability and traceability issues. Commercial tools focus mainly on code management, at a fine-grained level. However, the use of specialized techniques and tools represent additional barriers for the widespread introduction of product lines in software companies. In this paper, we propose an alternative based on the UML package merge mechanisms to reflect the structure of the variability models in product line package architecture, thus making the traceability of the configuration decisions straightforward. This package architecture and the configuration of the concrete products are automatically generated (using Model Driven Engineering techniques) from the variability models. As an additional advantage, the package merge mechanism can be directly implemented at code level using partial classes (present in languages such as C#). To support the proposal, we have developed a tool incorporated into MS Visual Studio. This tool permits the product line variability to be modeled and the required transformations to be automated, including the final compilation of concrete products. A case study of a successful experience is described in the article as an example of applying these techniques and tools. The proposed approach, a combination of UML techniques and conventional IDE tools, can make the development of product lines easier for an organization as it removes the need for specialized tools and personnel.

HTML

XML

PDF

DOI: 10.3217/jucs-016-15-2111

Authors: Ricardo Tesoriero, José A. Gallud Lázaro, María Lozano, Victor Penichet

Abstract: In order to develop context-aware applications for ubiquitous computing environments we have defined an MDA approach that defines three layers of models. The first layer captures the conceptual characteristics of the application. This layer defines three complementary points of view of the system that are used to build the task, space and social views of the system. The second layer defines the software characteristics of the application. It is composed by three new complementary points of view of the system that are used to build the referential space, the information flow and the entity context views of the system. Finally, the third layer defines the deployment environment of the system according to the views generated by the second layer.

HTML

XML

PDF

DOI: 10.3217/jucs-015-09-1970

Authors: Po-Huan Chiu, Chi-Chun Lo, Kuo-Ming Chao

Abstract: Object-oriented programming (OOP) is a mainstream paradigm for engineering design software tool development. An emerging requirement is the introduction of semantics to achieve heterogeneous information sharing, but many challenges exist. Examples include using object methods to manipulate an RDF data, automatically converting data into RDF format, and supporting various programming languages. In addition, limitations to description capabilities for relationships among object-oriented classes exceed those of RDF, thus hindering direct mapping between object-oriented and Semantic Web classes. Our proposed semantic object framework (SOF) combines object-oriented design and Semantic Web features. SOF utilizes embedded comments in source code to describe semantic relationships between classes and attributes. We use a mobile phone design case study to illustrate how the proposed system operates.

HTML

XML

PDF

DOI: 10.3217/jucs-014-21-3573

Authors: Rohit Gheyi, Tiago Massoni, Paulo Borba

Abstract: Software Product Lines (SPL) may be adopted by either bootstrapping existing software products into a SPL, or extending an existing SPL to encompass an additional software product. Program refactorings are usually applied for carrying out those tasks. The notion of SPL refactoring is an extension of the traditional definition of refactoring; it involves not only program refactorings, but also Feature Model (FM) refactorings, in order to improve configurability. However, FM refactorings are hard to define, due to the incompleteness of the refactoring catalogs developed as of today. In this paper, we propose a complete, sound catalog of algebraic laws, making up special FM refactorings that preserve configurability. This catalog is also defined as minimal, as one law cannot be derived from another one in the same catalog. In addition, a theory for FMs is presented, in the context of a theorem prover.

HTML

XML

PDF

DOI: 10.3217/jucs-014-13-2182

Authors: Javier Cámara, Gwen Salaün, Carlos Canal

Abstract: Reuse of software entities such as components or Web services raise composition issues since, most of the time, they present mismatches in their interfaces. These mismatches may appear at different interoperability levels: signature, behaviour, quality of service and semantics. The behavioural level is crucial and behavioural mismatches must all be corrected, although this is a difficult task. So far, most adaptation approaches which deal with behavioural mismatches work on a fixed description of components where all ports involved in their interfaces are known at design-time. Here, we focus on systems in which composition is affected by run-time behaviour of the system. This is the case in pervasive systems where a client interacts with a specific service by using new communication channels dynamically created. These are of special interest to allow private interaction between several entities. In this article, we define a behavioural model inspired by the ss-calculus to specify behavioural interfaces of components. Our model is particularly suitable for creating new channels dynamically, also taking concurrent behaviours into account. The dynamic nature of the systems we are dealing with obliges to apply adaptation at run-time, avoiding at the same time the costly generation of full descriptions of adaptors. The main contribution of this article is an adaptation engine that allows the dynamic creation of channels and applies at run-time a composition specification built at designtime. All the underlying formal foundations of our proposal have been implemented in a prototype tool that has been applied to system designs. Aspect-Oriented Programming has been studied as well, as a way to implement our engine for further application to real software components.

HTML

XML

PDF

DOI: 10.3217/jucs-014-13-2110

Authors: Stephen Kell

Abstract: Software adaptation techniques appear in many disparate areas of research literature, and under many guises. This paper enables a clear and uniform understanding of the related research, in three ways. Firstly, it surveys a broad range of relevant research, describing and contrasting the approaches of each using a uniform terminological and conceptual vocabulary. Secondly, it identifies and discusses three commonly advocated principles within this work: component models, first-class connection and loose coupling. Thirdly, it identifies and compares the various modularisation strategies employed by the surveyed work.

HTML

XML

PDF

DOI: 10.3217/jucs-014-08-1344

Authors: Elder Cirilo, Uirá Kulesza, Carlos Lucena

Abstract: In this paper, we present a model-based tool for product derivation. Our tool is centered on the definition of three models (feature, architecture and configuration models) which enable the automatic instantiation of software product lines (SPLs) or frameworks. The Eclipse platform and EMF technology are used as the base for the implementation of our tool. A set of specific Java annotations are also defined to allow generating automatically many of our models based on existing implementations of SPL architectures. We illustrated the use and validation of our tool in the preparation of the automatic derivation of the JUnit framework and a J2ME games product line.

HTML

XML

PDF

DOI: 10.3217/jucs-014-08-1314

Authors: Marcelo Alves, Paulo Pires, Flávia Delicato, Maria Luiza M. Campos

Abstract: Nowadays, the complexity of software applications has brought new challenges to developers, having to deal with a large number of computational requirements. Among these requirements, those known as crosscutting concerns transpass components boundaries, leading to maintainability and comprehension problems. This paper presents CrossMDA, a framework that encompasses a transformation process to integrate crosscutting concerns in model-oriented systems. It uses the concepts of horizontal separation of concerns from AOP to create independent business and aspect models, integrating those models through MDA transformations (vertical separation of concerns). CrossMDA comprises a development process, a set of services and support tools. The main advantages of this approach are to raise the abstraction level of aspect modeling, to promote the reuse of crosscutting concerns modeled as PIM elements, besides automating the process of mapping the relationship of crosscutting concerns and business models through the process of MDA transformations.

HTML

XML

PDF

DOI: 10.3217/jucs-014-08-1256

Authors: Kellyton dos Santos Brito, Vinícius Garcia, Eduardo De Almeida, Silvio Romero de Lemos Meira

Abstract: Nowadays software systems are essential to the environment of most organizations, and their maintenance is a key point to support business dynamics. Thus, reverse engineering legacy systems for knowledge reuse has become a major concern in software industry. This article, based on a survey about reverse engineering tools, discusses a set of functional and non-functional requirements for an effective tool for reverse engineering, and observes that current tools only partly support these requirements. In addition, we define new requirements, based on our group’s experience and industry feedback, and present the architecture and implementation of LIFT: a Legacy InFormation retrieval Tool, developed based on these demands. Furthermore, we discuss the compliance of LIFT with the defined requirements. Finally, we applied the LIFT in a reverse engineering project of a 210KLOC NATURAL/ADABAS system of a financial institution and analyzed its effectiveness and scalability, comparing data with previous similar projects performed by the same institution.

HTML

XML

PDF

DOI: 10.3217/jucs-014-08-1211

Authors: Marcelo Ramos, Rosângela A. D. Penteado

Abstract: The mining of generic software components from legacy systems can be used as an auxiliary technique to revitalize systems. This paper presents a software maintenance approach that uses such technique to revitalize one or more embedded legacy systems simultaneously and, in addition, create a core of reusable assets that can be used to support the development of new similar products. Software Product Line techniques are used to support the tasks of domain modelling and software component development. A real case study in the domain of Point of Sale (POS) terminals is presented and it illustrates the use of the proposed approach to revitalize three similar embedded legacy systems, simultaneously. It also shows how it is possible, through the created core of reusable assets, to deliver variations of these systems to meet the requirements of a wide family of POS terminals with different hardware configurations.

HTML

XML

PDF

DOI: 10.3217/jucs-013-07-0991

Authors: Davinia Hernández-Leo, Andreas Harrer, Juan Dodero, Juan Asensio-Pérez, Daniel Burgos

Abstract: IMS Learning Design (IMS LD) is an interoperable and standardized language that enables the computational representation of Units of Learning (UoLs). However, its adoption and extensive use in real practice largely depends on the extent to which teachers can design and author their own UoLs according to the requirements of their educational situations. Many of the proposed design processes for facilitating the creation of UoLs are based on the reuse of complete or non-complete learning design solutions at different levels of granularity. This paper introduces a comparison framework that conceptually analyzes and classifies reusable learning design solutions and processes that drive the creation of ready-to-run UoLs. The framework provides a comprehensible representation of such processes and units of reuse over two dimensions, namely granularity and completeness. It also offers a frame for discussing issues, such as the proper level of reuse, of existing and forthcoming proposals. Finally, it opens the path to other strands for future research such as providing language independence of learning designs or proposing approaches for the selection of the reusable solutions.

HTML

XML

PDF

DOI: 10.3217/jucs-013-06-0701

Authors: Jacques Robin, Jairson Vitorino, Armin Wolf

Abstract: Most automated reasoning tasks with prac tical applications can be automatically reformulated into a constraint solving task. A constraint programming platform can thus act as a unique, underlying engine to be reused for mu ltiple automated reasoning tasks in intelligent agents and systems. We identify six key requirements for such platform: expressive task modeling language, rapid solving method custom ization and combination, adaptive solving method, user-friendly solution explanation, efficient execution, and seamless integration within larger systems and practical applications. We then propose a novel, model-driven, component and rule-based architecture for such a platform that better satisfies as a whole this set of requirements than those of currently available platforms.

HTML

XML

PDF

DOI: 10.3217/jucs-012-12-1741

Authors: Pascal Poizat, Jean-Claude Royer

Abstract: Component Based Software Engineering has now emerged as a discipline for system development. After years of battle between component platforms, the need for means to abstract away from specific implementation details is now recognized. This paves the way for model driven approaches (such as the OMG MDA) but also for the more older Architectural Description Language (ADL) paradigm. In this paper we present Korrigan, a true ADL (in the [MT00] sense), which provides interesting features: fully formal behaviours and data types, expressive component gluing mechanisms through the use of temporal logic, yet ensuring the specification readability thanks to graphical notations.

HTML

XML

PDF

DOI: 10.3217/jucs-012-03-0236

Authors: Lidia Fuentes, Daniel Jiménez, Mónica Pinto

Abstract: In recent times, interest in Ambient Intelligence (or AmI) has increased considerably. One of the main challenges in the development of these systems is to improve their modularization in order to achieve a high degree of reusability, adaptability and extensibility. This will help us to deal with the heterogeneity and evolution of the environments in which AmI devices exit. An example would be to easily adapt existing applications when new communication technologies appear. Current approaches apply component technologies to achieve these goals, but more should be done. Our research focuses on applying aspect technologies to components in order to improve AmI application modularization. We present the benefits of aspect technologies with regard to reusability and adaptability, by showing the limitations of PCOM, a component-based AmI middleware platform. We will show a study comparing DAOPAmI, our own component and aspect-based AmI middleware platform and PCOM.

HTML

XML

PDF

DOI: 10.3217/jucs-011-10-1645

Authors: Fei Cao, Barrett Bryant, Rajeev Raje, Andrew Olson, Mikhail Auguston, Wei Zhao, Carol Burt

Abstract: Component-based software composition offers a development approach with reduced time-to-market and cost while achieving enhanced productivity, quality and maintainability. Existent work on the composition paradigm focuses on static composition, which is not sufficient in a distributed environment, in which both constituent components and the assembled distributed system are subject to dynamic adaptation. This paper presents two types of dynamic composition for distributed components: assertive and autonomous over a .NET based Web Services environment. Three case studies are provided to illustrate the use of assertive and autonomous composition.

HTML

XML

PDF

DOI: 10.3217/jucs-010-09-1302

Authors: José Sierra, Alfredo Fernández-Valmayor, Baltasar Fernández-Manjón, Antonio Navarro

Abstract: This paper proposes a document oriented paradigm to the development of content-intensive, document-based applications (e.g. educational and hypermedia applications, and knowledge based systems). According to this paradigm, the main aspects of this kind of applications can be described by means of documents. Afterwards, these documents are marked up using descriptive domain-specific markup languages and applications are produced by the automatic processing of these marked documents. We have used this paradigm to improve the maintenance and portability of content-intensive educational and hypermedia applications. ADDS (Approach to Document-based Development of Software) is an approach to software development based on the document oriented paradigm. A key feature of ADDS is that formulation of domain-specific markup languages is a dynamic and eminently pragmatic activity, and markup languages evolve according to the authoring needs of the different participants in the development process (domain experts and developers). The evolutionary nature of markup languages in ADDS leads to OADDS (Operationalization in ADDS), the proposed operationalization model for the incremental development of modular markup language processors. Finally, the document-oriented paradigm can also be applied in the construction of OADDS processors that are also described using marked documents. This paper presents our ADDS approach, including the operationalization model and its implementation as an object-oriented framework. The application of our document-oriented paradigm to the construction of OADDS processors is also presented.

HTML

XML

PDF

DOI: 10.3217/jucs-010-04-0473

Authors: Mercedes Amor, Lidia Fuentes, Mónica Pinto

Abstract: Developing multimedia applications entails understanding a variety of advanced technologies, in addition, multimedia programming poses a significant challenge in terms of handling a variety of hardware devices, multimedia formats or communication protocols. Therefore, break-through software engineering technologies should be applied to produce reference architectures able to support ever-changing requirements. In this paper, we first present the challenges that designers must face in multimedia programming, and how current frameworks address them, specially regarding the management of architectural evolution. We then show what breakthrough approaches or technologies can be used to produce more reusable, extensible and open multi-media systems. We focus on presenting the benefits of applying component-based software development and application framework technologies. We also illustrate how to componentize all multimedia functionalities and (re)use the resulting components as COTS in application frame-works. This approach helps to add multimedia capabilities to an application without requiring specific knowledge on multimedia.

HTML

XML

PDF

DOI: 10.3217/jucs-009-07-0659

Authors: Raimund Feldmann, Ralf Carbon

Abstract: Quality and process improvement programs usually require organizations to run a repository such as an experience base. However, setting up the schema of an experience base requires expert knowledge. But schema experts are not always available to support the setup of a new experience base. One promising solution is to capture their knowledge in patterns or building blocks. An initial collection of such building blocks is systematically documented in the PLEASERS (Product Line Approach for Software Engineering Repositories) library. In this article we describe the underlying conceptual model of the PLEASERS schema building blocks. Schema experts can use the introduced model to create sets of schema building blocks representing their knowledge.

HTML

XML

PDF

DOI: 10.3217/jucs-009-07-0627

Authors: Markus Grabert, Derek Bridge

Abstract: We present a software tool for examplet reuse. We define examplets to be goal-directed snippets of source code, often written for tutorial purposes, that show how to use program library facilities to achieve some task. Our tool allows users to specify both their goal (in free text) and their `situation (the source code on which they are working). The system combines text retrieval and spreading activation through a semantic net representation of the source code.

HTML

XML

PDF