Search

Software systems are widely used in people daily routines and responsibilities, therefore, systems need to be developed rapidly and efficiently. Domain specific languages (DSLs) are languages that are applied to a specific application domain. Since DSLs provide notations and constructs adapted to a particular domain, they offer gains in expressiveness and ease of use when compared with general-purpose languages (GPLs). Therefore, one of the most important steps in the Software Language Engineering is the evaluation of the languages produced, with the end-users, since the risk of building inappropriate languages, that often do not fit the end users, may decrease productivity. Although DSLs evaluation is one of the most important steps in development process, Software Language Engineers tend to relax the experimental validation of their products due to several reasons like costs (time, means, money, the number of people required, etc.) and required know-how associated with it. The lack of systematic approaches and guidelines to evaluate DSLs, and a comprehensive set of tools may explain this shortcoming in the current state of practice. The Usability Driven DSL development with USE-ME (USE-ME) approach, developed in NOVA-LINCS, "promotes the quality in use of DSLs by building a framework that leverages usability as a main concern". The feedback of the pilot studies was that despite the approach was "more or less easy" to understand it was not easy to model, since "there were too many steps to follow" and the framework did not provide a "guided cycle". So, in order to improve the system usability and the quality of the models produced with USE-ME, we developed a new version of the framework with validation rules implemented with Eclipse Validation Language (EVL) that guide, suggest and validate the Software Language Engineer actions throughout the development process. The validation rules were designed in such a way that the tool educates the user about the process, so that the user makes the best decision regarding his DSL evaluation. We performed two experiments, with different goals. The main goals of the first one was to analyse the effect of validation rules on the USE-ME framework, with respect to their impact on the System Usability Scale, and on the Model Correctness of USE-ME models. We analysed the results and we found evidences of improvements on the System Usability Scale, and on the Model Correctness of models, brought by the addition of the rules. The second experiment was conducted with a research team from Ege University, in Turkey. The main goal of this experiment was to perform a guided evaluation on a DSL related with Multi-Agent Systems, SEA-ML. Since the number of participants was low we cannot draw conclusions regarding this experiment. Despite the significant results from the first experiment further evaluation on the new version of the framework is necessary, this time, with more experienced users and with more complex exercises. With this new experiment, we can compare the results and improve the USE-ME framework.

Applying model-based testing to interactive systems enables the systematic testing of the system by automatically simulating user actions on the user interface. It reduces the cost of (expensive) user testing by identifying implementations errors without the involvement of human users, but raises a number of specific challenges, such as how to achieve good coverage of the actual use of the system during the testing process. This paper describes TOM, a model-based testing framework that uses a combination of tools and mutation testing techniques to maximize testing of user interface behaviors., ERDF - European Regional Development Fund(POCI-01-0145-FEDER-016826), Work financed by the ERDF (European Regional Development Fund) through the COMPETE 2020 Programme, and by National Funds through the Portuguese funding agency, FCT - Fundação para a Ciência e a Tecnologia, within project POCI-01-0145-FEDER-016826.

The need for high-performance computing together with the increasing trend from single processor to parallel computer architectures has leveraged the adoption of parallel computing. To benefit from parallel computing power, usually parallel algorithms are defined that can be mapped and executed on parallel computing platforms. In general, different alternative mappings can be defined each with different performance. For small computing platforms with a limited number of processing nodes, the mapping process can be carried out manually. However, for large-scale parallel computing platforms in which hundreds of thousands of processing nodes are applied, the number of possible mapping alternatives increases dramatically, and the mapping process becomes intractable for the human engineer. To assist the parallel computing engineer, we provide a systematic approach to derive feasible mapping alternatives of parallel algorithms to parallel computing platforms. The approach includes activities for modeling the parallel algorithm and parallel computing platform, generation of feasible mapping alternatives, generation of the deployment code, and finally the deployment of the generated code to the nodes. We evaluate our approach for deriving feasible mapping alternatives for four well-known parallel algorithms. The evaluation is based on both simulations and real executions of the generated mapping alternatives.

Context: To remain competitive, innovative and to grow, companies should use a value-based decision-making where decisions are the best for that company’s overall value creation. However, without tool support, the use of explicit value propositions and aggregation of different key stakeholders’ decisions during decision-making may be a challenge for many companies. Goal: The goal of this paper is to investigate the extent to which a Web-based tool for value-based decision-making can successfully support stakeholders’ decision-making process. Method: We conducted three case studies across four software projects, during six weeks, in the contexts of feature selection, test cases execution prioritization and user interfaces design selection. Prior to using the tool, stakeholders’ value propositions were elicited via focus-group meetings; later, during a post-mortem phase, data was gathered via observation, semi-structured interviews and structured questionnaires. Results: Participants reported an improvement of their decision-making process and quality of decisions; further, they also felt confident about using the tool, and that it can be useful to their work. Conclusions: Results suggested that the use of tool support by the stakeholders in the investigated company for value-based decision-making improved their decision-making process and the quality of decisions.

Finding software faults is a problematic activity in many systems. Existing approaches usually work close to the system implementation and require developers to perform different code analyses. Although these approaches are effective, the amount of information to be managed by developers is often overwhelming. This problem calls for complementary approaches able to work at higher levels of abstraction than code, helping developers to keep intellectual control over the system when analyzing faults. In this context, we present an expert-system approach, called FLABot, which assists developers in fault-localization tasks by reasoning about faults using software architecture models. We have evaluated a prototype of FLABot in two medium-size case studies, involving novice and non-novice developers. We compared time consumed, code browsed and faults found by these developers, with and without the support of FLABot, observing interesting effort reductions when applying FLABot. The results and lessons learned have shown that our approach is practical and reduces the efforts for finding individual faults. Fil: Soria, Alvaro. Consejo Nacional de Investigaciones Científicas y Técnicas. Centro Científico Tecnológico Tandil. Instituto Superior de Ingenieria del Software; Argentina Fil: Diaz Pace, Jorge Andres. Consejo Nacional de Investigaciones Científicas y Técnicas. Centro Científico Tecnológico Tandil. Instituto Superior de Ingenieria del Software; Argentina Fil: Campo, Marcelo Ricardo. Consejo Nacional de Investigaciones Científicas y Técnicas. Centro Científico Tecnológico Tandil. Instituto Superior de Ingenieria del Software; Argentina

Defining and managing teaching programs at university or other institutions is a complex task for which there is not much support in terms of methods and tools. This task becomes even more critical when the time comes to obtain certifications w.r.t. official standards. In this paper, we present an on-going project called TESMA whose objective is to provide an open-source tool dedicated to the specification and management (including certification) of teaching programs. This tool has been engineered using a development method called Messir for its requirements elicitations and introduces a domain-specific language dedicated to the teaching domain. This paper presents the current status of this project and the future activities planned.

Mapping parallel algorithms to parallel computing platforms requires several activities such as the analysis of the parallel algorithm, the definition of the logical configuration of the platform, the mapping of the algorithm to the logical configuration platform and the implementation of the source code. Applying this process from scratch for each parallel algorithm is usually time consuming and cumbersome. Moreover, for large platforms this overall process becomes intractable for the human engineer. To support systematic reuse we propose to adopt a model-driven product line engineering approach for mapping parallel algorithms to parallel computing platforms. Using model-driven transformation patterns we support the generation of logical configurations of the computing platform and the generation of the parallel source code that runs on the parallel computing platform nodes. The overall approach is illustrated for mapping an example parallel algorithm to parallel computing platforms.

Validerat; 20160219 (global_studentproject_submitter)

Yazılım mimarisi, bir sistemin ana yapısını gösterdiği ve her bir paydaşın ihtiyacını dikkate aldığı için yazılım geliştirme sürecinin temel taşlarından biridir. Yazılım geliştirme sürecinde mimariden yararlanabilmek için, hazırlanan mimarinin ve öngörülen tasarım kararlarının kodla uyumlu olması gerekmektedir. Ancak, projelerde koda dair değişen gereksinimler ve/veya uyarlamalar mimari ve kod arasında istenmeyen uyumsuzlukların oluşmasına yol açabilmektedir. Bu mimari ayrışma problemi, mimarinin tanımı ve ortaya çıkan kod arasındaki tutarsızlığı belirtmektedir. Projelerin başında tanımlanan tasarım amaçlarına ulaşmayı sağlayan ve kodla yazılım mimarisi arasındaki uyumsuzlukları bulmaya yarayan, literatürde bir takım çalışmalar öne sürülmüştür. Pratikte yazılım mimarisi, paydaşların ihtiyacını öne sürdüğü mimari bakış açılarıyla belgelenmektedir. Mimari bakış açıları ve kod arasındaki uyum nasıl olmalıysa, aynı şekilde her bir bakış açısı kendi içinde ve diğer bakış açılarıyla uyumlu olmalıdır. Ancak, varolan mimari uygunluğu yöntemleri öncelik olarak kod ile mimari arasındaki uyuma odaklanmış ve bakış açılarının kendi aralarındaki uyumsuzlukları dikkate almamıştır. Bu tezde, mimari bakış açılarının kendi aralarındaki uyumsuzluğu ele alan sistematik bir yöntem sunmaktayız. Bu yöntem ile mimari bakış açılarının kendi içinde ve diğer bakış açılarıyla olan uyumsuzlukları sistematik bir şekilde tespit edilebilmektedir. Bu amaç doğrultusunda, meta modelleri tanımlanan mimari bakış açılarını uygulamaya sokan bir araç geliştirdik. Bakış açıları arasındaki uyumsuzlukları bulan yöntemimizi Görünümler ve Ötesi yaklaşımı ile örneklendirdik. Sunulan yöntemi değerlendirmek için hata enjekte metodunu kullandık. Değerlendirmemizin sonuçları, bakış açılarının kendi içinde ve diğer bakış açılarıyla olan uyumsuzluk bulma durumunu, sunulan yöntem ile etkili bir şekilde tespit edilebildiğini göstermektedir. Software architecture is one of the key artefacts in the software development process since it provides the gross-level structure of the system and supports the stakeholder concerns. To benefit from the architecture it is important that the code is consistent with the architecture and the corresponding design decisions. Unfortunately, changing requirements and/or the adaptations to the code can lead to undesired inconsistencies among the architecture and the code. This so-called architectural drift problem is the discrepancy between the architecture description and the resulting implementation. Several approaches have been proposed to detect the inconsistencies between the software architecture and the code to ensure that the original design goals are maintained. In practice, software architecture is documented using a coherent set of architecture views, each of view addresses particular stakeholder concerns. Similar to the consistency with the code it is important that an architecture view is consistent within itself and with other related architecture views. Unfortunately, the existing architecture conformance analysis approaches have primarily focused on checking the inconsistencies between the architecture and code, and did not explicitly consider the consistency among views. In this thesis, we provide a systematic architecture conformance analysis approach that explicitly focuses on conformance analysis among architecture views. The approach is used for detecting the inconsistencies within and across architectural views. To this end, we define the meta-models of architecture viewpoints, present the conformance analysis approach, and provide the tool ArchViewChecker. We illustrate our approach for detecting inconsistencies using the Views and Beyond approach. We adopt a fault injection approach to evaluate the effectiveness of the approach. The results show that the approach is effective in detecting inconsistencies within views and across views. 228

Quality-attribute requirements describe constraints on the development and behavior of a software system, and their satisfaction is key for the success of a software project. Detecting and analyzing quality attributes in early development stages provides insights for system design, reduces risks, and ultimately improves the developers? understanding of the system. A common problem, however, is that quality-attribute information tends to be understated in requirements specifications and scattered across several documents. Thus, making the quality attributes first-class citizens becomes usually a time-consuming task for analysts. Recent developments have made it possible to mine concerns semi-automatically from textual documents. Leveraging on these ideas, we present a semiautomated approach to identify latent quality attributes that works in two stages. First, a mining tool extracts early aspects from use cases, and then these aspects are processed to derive candidate quality attributes. This derivation is based on an ontology of quality-attribute scenarios. We have built a prototype tool called QAMiner to implement our approach. The evaluation of this tool in two case studies from the literature has shown interesting results. As main contribution, we argue that our approach can help analysts to skim requirements documents and quickly produce a list of potential quality attributes for the system. Fil: Rago, Alejandro Miguel. Consejo Nacional de Investigaciones Científicas y Técnicas. Centro Científico Tecnológico Tandil. Instituto Superior de Ingenieria del Software; Argentina Fil: Diaz Pace, Jorge Andres. Consejo Nacional de Investigaciones Científicas y Técnicas. Centro Científico Tecnológico Tandil. Instituto Superior de Ingenieria del Software; Argentina Fil: Marcos, Claudia Andrea. Consejo Nacional de Investigaciones Científicas y Técnicas. Centro Científico Tecnológico Tandil. Instituto Superior de Ingenieria del Software; Argentina. Provincia de Buenos Aires. Gobernación. Comisión de Investigaciones Científicas; Argentina

In this paper, we are concerned with a special timetabling problem. It was posed to us by the administration of our university and stems from the adoption of the British-American system of university education in Germany. This change led to the concrete task of constructing a timetable that enables the undergraduate education of secondary school teachers within three years in the “normal case” and within four years in the case of exceptional combinations of subjects. We develop two relation-algebraic models of the timetabling problem and in each case algorithms for computing solutions. The latter easily can be implemented in the Kiel RelView tool showing that RelView can be used for timetabling.

We present MLSolver, a tool for solving the satisfiability and validity problems for modal fixpoint logics. The underlying technique is based on characterisations of satisfiability through infinite (cyclic) tableaux in which branches have an inner thread structure mirroring the regeneration of least and greatest fixpoint constructs in the infinite. Well-foundedness for unfoldings of least fixpoints is checked using deterministic parity automata. This reduces the satisfiability and validity problems to the problem of solving a parity game. MLSolver then uses a parity game solver in order to decide satisfiability and derives example models from the winning strategies in the parity game. Currently supported logics are the modal and linear-time μ-calculi, CTL*, and PDL (and therefore also CTL and LTL). MLSolver is designed to allow easy extensions in the form of further modal fixpoint logics.

This paper gives an overview of results of the project “Beyond Timed Automata” carried out in the Collaborative Research Center AVACS (Automatic Verification and Analysis of Complex Systems) of the Universities of Oldenburg, Freiburg, and Saarbrücken. We discuss how properties of high-level specifications of real-time systems combining the dimensions of process behaviour, data, and time can be automatically verified, exploiting recent advances in semantics, constraint-based model checking, and decision procedures for complex data.As specification language we consider CS-OZ-DC, which integrates concepts from Communicating Sequential Processes (CSP), Object-Z (OZ), and Duration Calculus (DC). Our approach to automatic verification of CSP-OZ-DC rests on a compositional semantics of this languages in terms of Phase-Event-Automata. These can be translated into Transition Constraint Systems which serve as an input language of an abstract refinement model checker called ARMC which can handle constraints covering both real-time and infinite data. This is demonstrated by a case study concerning emergency messages in the European Train Control System (ETCS). For CSP-OZ-DC we also discuss a UML profile and tool support.

Various tools exist to reverse engineer software source code and generate design information, such as UML projections. Each has specific strengths and weaknesses, however no standardised benchmark exists that can be used to evaluate and compare their performance and effectiveness in a systematic manner. To facilitate such comparison in this paper we introduce the Reverse Engineering to Design Benchmark (RED-BM), which consists of a comprehensive set of Java-based targets for reverse engineering and a formal set of performance measures with which tools and approaches can be analysed and ranked. When used to evaluate 12 industry standard tools performance figures range from 8.82\% to 100\% demonstrating the ability of the benchmark to differentiate between tools. To aid the comparison, analysis and further use of reverse engineering XMI output we have developed a parser which can interpret the XMI output format of the most commonly used reverse engineering applications, and is used in a number of tools.

Wireless Sensor Networks (WSN) are nowadays applied to a wide set of domains (e.g., security, health). WSN are networks of spatially distributed, radio-communicating, battery-powered, autonomous sensor nodes. WSN are characterized by scarcity of resources, hence an application running on them should carefully manage its resources. The most critical resource in WSN is the nodes’ battery.

To realize the increased need for computing performance the current trend is towards applying parallel computing in which the tasks are run in parallel on multiple nodes. On its turn we can observe the rapid increase of the scale of parallel computing platforms. This situation has led to a complexity of parallel application development that is not scalable and tractable anymore for manual processing, and therefore automated support is required to design and implement parallel applications. To this end, we present a model-driven transformation chain for supporting the automation of the lifecycle of parallel computing applications. The model-driven transformation chain adopts metamodels that are derived from architecture viewpoints. The transformation chain is defined as a logical sequence consisting of model-to-model transformations. We present the tool support that implements the metamodels and transformations.

The emerging imperatives of innovation economic development in Russia determine the content of conceptual and institutional constraints to the development of regional economic systems (RES). They consider the regional planning system as a leading priority in its inseparable unity with modern public administration tasks. However, the practice of development of long-term plans in the RF subjects proves that the innovation challenges of economic policy are not reflected properly in them or they are significantly distorted. The following reasons reduce the effectiveness of modernization processes in the RF subjects and hamper the appropriate reaction of RES on their impact: the lack of coordination between socio-economic and spatial regional plans, the imbalance of interaction between state authorities engaged in long-term planning, the lack of real prerequisites for the implementation of innovation initiatives in the regions. Systematization and analysis of long-term plans make it possible to substantiate the consistency of the spatial approach to regional planning expressed in the dominance of the transformational function that synchronizes the configuration and parameters of RES, and to establish ways to integrate spatial components in the system of regional planning through optimization of its tool support. The change in the content of the instrumentation support is based on the synthesis of the predominant basic characteristics of the existing tools used in isolated subsystems of regional planning of socio-economic and territorial development. The study has established a system of tool support for regional planning that adapts to the changes in both internal and external factors in the development of RES. Three main groups of tools: organizing, regulating, and coordinating are defined by their typing in accordance with the groups of management functions. The article proposes the modeling of combinations of tools that are subordinated to the choice of spatial and strategic initiatives in the development of a particular region

We present a novel approach to implement a graph transformation engine based on standard relational database management systems (RDBMSs). The essence of the approach is to create database views for each rules and to handle pattern matching by inner join operations while negative application conditions by left outer join operations. Furthermore, the model manipulation prescribed by the application of a graph transformation rule is also implemented using elementary data manipulation statements (such as insert, delete, update).

Variability management in software systems requires adequate tool support to cope with the ever increasing complexity of software systems. The paper presents a tool chain which can be used for variability management within almost all software development processes. The tools presented use extended feature models as the main model for describing variability and commonality, and provide user changeable customization of the software artifacts to be managed.

We present a tool which integrates the Unified Modeling Language with a processoriented technique for component system specification and design. We have transformed the definition of process inheritance into definitions of inheritance of UML diagrams. The definitions of UML diagrams inheritance have been built into the tool to guarantee component system development with correct inheritance of component behaviour.

In model-based development, quality properties such as consistency of security requirements are often verified prior to code generation. Changed models have to be re-verified before re-generation. If several alternative evolutions of a model are possible, each alternative has to be modeled and verified to find the best model for further development. We present a verification strategy to analyze whether evolution preserves given security properties. The UMLchange profile is used for specifying potential evolutions of a given model simultaneously. We present a tool that reads these annotations and computes a delta containing all possible evolution paths. The paths can be verified wrt. security properties, and for each successfully verified path a new model version is generated automatically.

This paper discusses challenges in contextual task analysis and the need of tools that support analysts to collect such information in context. Specifically we argue that the analysis of collaborative and distributed tasks can be supported by ambulatory assessment tools. We illustrate how contextual task analysis can be supported by TEMPEST, a platform originally created for experience sampling and more generally, longitudinal ambulatory assessment studies. We present a case study that illustrates the extent to which this tool meets the needs of real-world task analysis, describing the gains in efficiency it can provide but also directions for the development of tool support for task analysis.

Usability is one of the most relevant quality aspects in Web applications. A Web application is usable if it provides a friendly, direct and easy to understand interface. Many Usability Inspection Methods (UIMs) have been proposed as a cost effective way to enhance usability. However, many companies are not aware of these UIMs and consequently, are not using them. A secondary study can identify, evaluate and interpret all data that is relevant to the current knowledge available regarding UIMs that have been used to evaluate Web applications in the past few decades. Therefore, we have extended a systematic mapping study about Usability Evaluation Methods by analyzing 26 of its research papers from which we extracted and categorized UIMs. We provide practitioners and researches with the rationale to understand both the strengths and weaknesses of the emerging UIMs for the Web. Furthermore, we have summarized the relevant information of the UIMs, which suggested new ideas or theoretical basis regarding usability inspection in the Web domain. In addition, we present a new UIM and a tool for Web usability inspection starting from the results shown in this paper. Usabilidade é um dos fatores de maior relevância em Aplicações Web. Uma aplicação Web usável proporciona uma interface amigável, direta e fácil de entender. Vários métodos de inspeção de usabilidade (Usability Inspection Methods - UIMs) têm sido propostos como uma forma de baixo custo e alto benefício para a melhoria da usabilidade. No entanto, muitas empresas não os conhecem e, portanto não os utilizam. Um estudo secundário pode identificar, avaliar e interpretar dados relevantes sobre o conhecimento disponível relacionado a UIMs que têm sido usados para avaliar aplicações Web nas últimas décadas. Este artigo apresenta a extensão de um mapeamento sistemático sobre Métodos de Avaliação de Usabilidade, com a análise de 26 artigos dos quais UIMs foram extraídos e categorizados. Os resultados desta pesquisa oferecem, tanto à academia quanto à indústria, informações para entender as vantagens e desvantagens da utilização de cada um dos UIMs emergentes para a Web. Além disso, foi feito um resumo de cada método, para fornecer ideias de pesquisa e uma base teórica para inspeção de aplicações Web. Finalmente, com base nos resultados obtidos nesta pesquisa, são apresentadas uma técnica de inspeção de usabilidade, e uma ferramenta para apoiar a sua aplicação.

Date of Conference: June 17 - 21, 2013 In general, software architecture is documented using software architecture views to address the different stakeholder concerns. The current trend recognizes that the set of viewpoints should not be fixed but multiple viewpoints might be introduced instead to design and document the software architecture. To ensure the quality of the software architecture various software architecture evaluation approaches have been introduced. In addition several documentation guidelines have been provided to ensure the quality of the software architecture document. Unfortunately, the evaluation of the adopted viewpoints that are used to design and document the software architecture has not been considered explicitly. If the architectural viewpoints are not well-defined then implicitly this will have an impact on the quality of the design and the documentation of the software architecture. We present an evaluation framework for assessing existing or newly defined software architecture viewpoint languages. The approach is based on software language engineering techniques, and considers each viewpoint as a metamodel. The approach does not assume a particular architecture framework and can be applied to existing or newly defined viewpoint languages. We illustrate our approach for modeling and reviewing the first and second editions of the viewpoint languages of the Views and Beyond approach. Copyright © ACM.

peer-reviewed Parallelizing serial software systems in order to run in a High Performance Computing (HPC) environment presents many challenges to developers. In particular, the extant literature suggests the task of decomposing large-scale data applications is particularly complex and time-consuming. In order to take stock of the state of practice of data decomposition in HPC, we conducted a two-phased study. Firstly, using focus group methodology we conducted an exploratory study at a software laboratory with an established track record in HPC. Based on the findings of this first phase, we designed a survey to assess the state of practice among experts in this field around the world. Our study shows that approximately 75% of parallelized applications use some form of data decomposition. Furthermore, data decomposition was found to be the most challenging phase in the parallelization process, consuming approximately 40% of the total time. A key finding of our study is that experts do not use any of the available tools and formal representations, and in fact, are not aware of them. We discuss why existing tools have not been adopted in industry and based on our findings, provide a number of recommendations for future tool support.

Use of software tools to support business processes is both a possibility and necessity for both large and small enterprises of today. Given the variety of tools on the market, the question of how to choose the right tools for the process in question or analyze the suitability of the tools already employed arises. The paper presents an experience report of using a high-level business process model for analyzing software tools suitability at a large ICT organization that recently transitioned to scrum-based project methodology of software development. The paper gives overview of the modeling method used, describes the organizational context, presents a model built, and discusses preliminary findings based on the analysis of the model.

International audience; During the last decade, context-awareness and adaptation have been receiving significant attention in many research areas. For application developers, the heterogeneity of resource-constrained mobile terminals creates serious problems for the development of mobile applications able to run properly on a large number of different devices. Thus, resource awareness plays a crucial role when developing such applications. It identifies the capability of being aware of the resources offered by an execution environment, in order to decide whether that environment is suited to receive and execute the application. Within this line of research, we propose Chameleon, a framework that provides both an integrated development environment and a proper context-aware support to adaptable Java applications for limited devices. In this paper we present the novel hybrid (from static to dynamic) analysis approach that Chameleon uses for inspecting (adaptable) Java programs with respect to their resource consumption in a given execution environment. This analysis permits to quantitatively compare alternative versions of the same program. The analysis is based on a resource model for specifying resource provisions and consumptions, and a parametric transition system that performs the actual analysis

This thesis presents tools for Transactional Memory (TM) applications that cover multiple TM systems (Software, Hardware, and hybrid TM) and use information of all different layers of the TM software stack. Therefore, this thesis addresses a number of challenges to extract static information, information about the run time behavior, and expert-level knowledge to develop these new methods and strategies for the optimization of TM applications.

Date of Conference: September 29 – October 4, 2013 Conference name: International Conference on Model Driven Engineering Languages and Systems 16th International Conference, MODELS 2013 The trend from single processor to parallel computer architectures has increased the importance of parallel computing. To support parallel computing it is important to map parallel algorithms to a computing platform that consists of multiple parallel processing nodes. In general different alternative mappings can be defined that perform differently with respect to the quality requirements for power consumption, efficiency and memory usage. The mapping process can be carried out manually for platforms with a limited number of processing nodes. However, for exascale computing in which hundreds of thousands of processing nodes are applied, the mapping process soon becomes intractable. To assist the parallel computing engineer we provide a model-driven approach to analyze, model, and select feasible mappings. We describe the developed toolset that implements the corresponding approach together with the required metamodels and model transformations. We illustrate our approach for the well-known complete exchange algorithm in parallel computing. © 2013 Springer-Verlag.

Date of Conference: September 29, 2013 One of the important problems in parallel computing is the mapping of the parallel algorithm to the parallel computing platform. Hereby, for each parallel node the corresponding code for the parallel nodes must be implemented. For platforms with a limited number of processing nodes this can be done manually. However, in case the parallel computing platform consists of hundreds of thousands of processing nodes then the manual coding of the parallel algorithms becomes intractable and error-prone. Moreover, a change of the parallel computing platform requires considerable effort and time of coding. In this paper we present a model-driven approach for generating the code of selected parallel algorithms to be mapped on parallel computing platforms. We describe the required platform independent metamodel, and the model-to-model and the model-to-text transformation patterns. We illustrate our approach for the parallel matrix multiplication algorithm. Copyright © 2013 for the individual papers by the papers' authors.

We propose a methodological approach to prove that a system guarantees to establish a property eventually with probability one. Using Event-B as our modelling language, our correctness reasoning is a combination of termination proofs in terms of probabilistic convergence and standard invariant techniques. We illustrate our approach by formalising some non-trivial algorithms, including the Duelling Cowboys, Herman’s Probabilistic Self-Stabilization and Rabin’s Choice Coordination. We extend the supporting Rodin platform of Event-B to generate appropriate proof obligations for our reasoning, then subsequently (automatically/ interactively) discharge the obligations using the built-in provers of the Rodin platform., Technical Report / ETH Zurich, Department of Computer Science, 768

Due to copyright restrictions, the access to the full text of this article is only available via subscription. Each software architecture design is the result of a broad set of design decisions and their justifications, that is, the design rationale. Capturing the design rationale is important for a variety of reasons such as enhancing communication, reuse and maintenance. Unfortunately, it appears that there is still a lack of appropriate methods and tools for effectively capturing and managing the architecture design rationale. In this paper we present a feature-based rationale management approach and the corresponding tool environment ArchiRationale for supporting software architecture adaptation. The approach takes as input an existing architecture and captures the design rationale for adapting the architecture for a given quality concern. For this we define a feature model that includes the possible set of architectural tactics to realize the quality concern. The presented approach captures the rationale for deciding on feature selections and for selecting the corresponding architecture design alternatives. ArchiRationale customizes and integrates the Eclipse plugin tools XFeature, ArchStudio and XQuery to provide tool support for capturing, storing and accessing the design rationale. We illustrate the approach for adapting a software architecture for fault tolerance. Embedded Systems Institute ; Netherlands Ministry of Economic Affairs

It has been recognized that a certain level of formalization is needed to produce precise and well-defined use case models, thus tackling problematic issues such as the lack of a specific, semantic classification of use cases, the vagueness of the use case specifications written in free natural language (NL), and the limited tool support that makes use case driven analysis a time-consuming and error-prone activity. This paper presents a formal semantics for the basic use case model elements, including specific semantic types of use cases, specific types of basic and alternative flow actions, and specific functional roles actors can play. To maintain a high-degree of readability and understandability and to minimize ambiguity, the proposed approach provides a semi-formal, NL-based specification syntax, tailored to each semantic use case type, with a specific sequence of basic and alternative flow actions. The formalization is facilitated by utilizing elements of a novel methodology named Natural Language Syntax and Semantics Requirements Engineering.

Yazılım mimarisi tasarımında yaygın pratiklerden biri yazılım mimarisini çeşitli paydaş ilgilerine yönelik tasarlayabilmek için mimari görünümlerini kullanmaktır. Mimari görünümleri genellikle bu görünümleri oluşturmayı, yorumlamayı ve analiz etmeyi sağlayan kuralları tanımlayan mimari bakış açılarını temel alarak geliştirilir. Şimdiye kadar çoğu mimari bakış açısının esasen paydaşlar arasındaki iletişimi desteklemek ya da en iyi ihtimalle detaylı tasarım için bir plan sağlamak amacıyla kullanıldığı görülmektedir.Bu tezde mimari bakış açılarını alana özgü dil olarak tanımlamak için bir yazılım dil mühendisliği yaklaşımı sunuyoruz. Bu, mimari bakış açılarının formalliğini iyileştirirken bir yandan da araçlar tarafından yorumlanıp analiz edilebilen çalıştırılabilir görünüm modellerine öncülük ediyor. Mimari bakış açılarını alana özgü dil olarak tanımlama çalışmamızı Görünümler ve Ötesi yaklaşımı için gösterdik. Yaklaşımımız çeşitli görünümleri modellemeyi destekleyen Eclipse eklentisi SAVE-Bench yazılım aracı olarak geliştirildi. Araç aynı zamanda görünüm modellerinden otomatik mimari dökümantasyonu üretmeyi de destekliyor. A common practice in software architecture design is to apply so-called architectural views to design software architecture for the various stakeholder concerns. Architectural views are usually developed based on architectural viewpoints which define the conventions for constructing, interpreting and analyzing views. So far most architectural viewpoints seem to have been primarily used either to support the communication among stakeholders, or at the best to provide a blueprint for the detailed design.In this thesis, we provide a software language engineering approach to define viewpoints as domain specific languages. This enhances the formal precision of architectural viewpoints and leads to executable views that can be interpreted and analyzed by tools. We illustrate our approach for defining domain specific languages for the viewpoints of the Views and Beyond framework. The approach is implemented as an Eclipse plug-in, SAVE-Bench tool, which can be used to define different views based on the predefined software architecture viewpoints. The tool also supports automatic generation of architecture documentation from view models. 116

Face-to-face team meetings within organisations continue to play a critical role towards the collaboration of members in achieving their targets, despite the emergence of tools to support distributed online meetings. Numerous tools have been introduced in the markets to assist the participants with their processes in team meetings. However, the nature of the tool support was focused on specific processes within a meeting and the rate of adoption of developed tools into organisations is very low. The focus on developing an integrated tool support that includes all the potential processes within a meeting, and learning lessons whilst designing tool support to improve the state of adoption of these tools is largely unexplored. This qualitative study observed audio and video transcripts of a series of simulated team meetings from a meeting corpus and analysed the data using a grounded theory approach. The transcribed data were used to generate stories on team activities and potential tool support for them. The stories were used to develop a tool-kit framework and lesson on providing a tool support for team meetings. The framework consists of a list of potential hardware and software tools that could be introduced within a team meeting to support the team activities. The lessons learned were based on three actors of the tool-support system namely the people, process and technology. The results from the study have shown that it is possible to provide an integrated tool support for team meetings whilst the framework is grounded on the activities within the meeting. The lessons learned were based on the potential processes that would require tool support, participants' requirements and how technology could be introduced to provide assistance in team meetings, and would be useful for system designers that focus on tool support. Given the study used only simulated meetings, the results need to be verified with real meetings within organisations. Thus, the framework and the lessons learned can be refined to provide more insights for system designers in developing an integrated tool support for team meetings. Refereed/Peer-reviewed

Program queries can answer important software engineering questions that range from "which expressions are cast to this type?" over "does my program attempt to read from a closed file?" to "does my code follow the prescribed design?". In this paper, we present a comprehensive tool suite for querying Java programs. It consists of the logic program query language SOUL, the CAVA library of predicates for quantifying over an Eclipse workspace and the Eclipse plugin BARISTA for launching queries and inspecting their results. BARISTA allows other Eclipse plugins to peruse pro- gram query results which is facilitated by the symbiosis of SOUL with Java - setting SOUL apart from other program query lan- guages. This symbiosis enables the CAVA library to forego the predominant transcription to logic facts of the queried program. Instead, the library queries the actual AST nodes used by Eclipse itself, making it trivial for any Eclipse plugin to find the AST nodes that correspond to a query result. Moreover, such plugins do not have to worry about having queried stale program information. We illustrate the extensibility of our suite by implementing a tool for co-evolving source code and annotations using program queries.

Date of Conference: 20-24 June 2011 Conference name: Ninth Working IEEE/IFIP Conference on Software Architecture, 2011 In general, a common reference architecture can be derived for Software as a Service (SaaS). However, while designing particular applications one may derive various application design alternatives from the same reference SaaS architecture specification. To meet the required functional and nonfunctional requirements of different enterprise applications it is important to model the possible design so that a feasible alternative can be defined. In this paper, we propose a systematic approach and corresponding tool support for guiding the design of SaaS application architectures. The approach defines a SaaS reference architecture, a family feature model and a set of reference design rules. Based on the business requirements an application feature model is defined using the family feature model. Selected features are related to design decisions and a SaaS application architecture design is derived. © 2011 IEEE.

A considerable amount of effort in software development is dedicated to the user interaction layer.Given the complexity inherent to the development of this layer, it is important to be able to analyse the concepts and ideas being used in the development of a given user interface. This analysis should be performed as early as possible. Model- based user interface development provides a solution to this problem by providing developers with tools that enable both modeling, and reasoning about, user interfaces at different levels of abstraction. Of particular interest here, is the possibility of animating the models to generate actual user interfaces. This paper describes FlexiXML, a tool that performs the rendering and animation of user interfaces described in the UsiXML modeling language.