Spelling suggestions: "subject:"computer cience anda engineering"" "subject:"computer cience anda ingineering""
91 |
Language Evolution to Reduce Code CloningNovakovic, Marko January 2013 (has links)
Domain-specific languages can significantly speed up the development of software applications. However, it usually takes a few iterations of the language design before it achieves such power. At the same time, many domains tend to evolve quite often today, which implies that domain-specific languages have to evolve accordingly. Thus, being able to evolve a language in a painless manner is crucial. Unfortunately, current state-of-the-art research does not provide enough answers on how to efficiently evolve domain-specific languages.
We present an approach to evolving a language in order to reduce the amount of code cloning it introduces. The approach specifically targets those languages whose design causes users to create many duplicated code segments.
We target domain-specific languages as they tend to be more challenging to evolve due to their specifics, but the approach may be applicable to general purpose programming languages as well. The approach was tested on a real-world domain-specific language that is used in a financial domain. We proposed three improvements and current users helped us evaluate them. We found that the proposed improvements would reduce code cloning, which provides evidence that the approach can be used in a real-world environment.
Furthermore, this work provides a solid basis for further research in the area of application of code cloning detection results. In particular, code cloning detection results and the ideas we presented show potential to be extended and used to facilitate domain analysis.
|
92 |
A Mode-Based Pattern for Feature Requirements, and a Generic Feature InterfaceDietrich, David January 2013 (has links)
Feature-oriented requirements decompose a system's requirements into individual bundles of functionality called features, where each feature's behaviour can be expressed as a state-machine model. However, state machines are difficult to write; determining how to decompose behaviour into states is not obvious, different stakeholders will have different opinions on how to structure the state machine, and the state machines can easily become too complex.
This thesis proposes a pattern for decomposing and structuring the model of a feature's behavioural requirements, based on modes of operation (e.g., Active, Inactive, Failed) that are common to features in multiple domains. Interestingly, the highest-level modes of the pattern can serve as a generic behavioural interface for all features that adhere to the pattern. The thesis proposes also several pattern extensions that provide guidance on how to structure the Active and Inactive behaviour of the feature.
The pattern was applied to model the behavioural requirements of 21 automotive features that were specified in 7 production-grade requirements documents. The pattern was applicable to all 21 features, and the proposed generic feature interface was applicable to 50 out of 58 inter-feature references. A user study with 18 participants evaluated whether use of the pattern made it easier than otherwise to write state machines for features and whether feature state machines written with the help of the pattern are more readable than those written without the help of the pattern. The results of the study indicate that use of the pattern facilitates writing of feature state machines.
|
93 |
Fully Automated Translation of BoxTalk to PromelaKajarekar, Tejas January 2011 (has links)
Telecommunication systems are structured to enable incremental growth, so that new telecommunication features can be added to the set of existing features. With the addition of more features, certain existing features may exhibit unpredictable behaviour. This is known as the feature interaction problem, and it is very old problem in telecommunication systems. Jackson and Zave have proposed a technology, Distributed Feature Composition (DFC) to manage the feature interaction problem. DFC is a pipe-and-filter-like architecture where features are "filters" and communication channels connecting features are "pipes".
DFC does not prescribe how features are specified or programmed. Instead, Zave and Jackson have developed BoxTalk, a call-abstraction, domain-specific, high-level programming language for programming features. BoxTalk is based on the DFC protocol and it uses macros to combine common sequences of read and write actions, thus simplifying the details of the DFC protocol in feature models. BoxTalk features must adhere to the DFC protocol in order to be plugged into a DFC architecture (i.e., features must be "DFC compliant"). We want to use model checking to check whether a feature is DFC compliant. We express DFC compliance using a set of properties expressed as linear temporal logic formulas.
To use the model checker SPIN, BoxTalk features must be translated into Promela. Our automatic verification process comprises three steps:
1. Explicate BoxTalk features by expanding macros and introducing implicit details.
2. Mechanically translate explicated BoxTalk features into Promela models.
3. Verify the Promela models of features using the SPIN model checker.
We present a case study of BoxTalk features, describing the original features and how they are explicated and translated into Promela by our software, and how they are proven to be DFC compliant.
|
94 |
A Case Study of a Very Large OrganizationWerner, Colin Mark 20 December 2011 (has links)
Very Large Organization (VLO) is an organization that produces hardware and software, which together form products. VLO granted access to data pertaining to seven different products and their development projects. One particular product is of interest to VLO since it was not as successful as the other products. The focus of this thesis is to study the problematic product and compare it to the other six products in order to draw some conclusions regarding the problematic product. The goal of this study is to indicate areas of improvement, which can help VLO improve future products.
This thesis explores and answers the following research questions focused around the problematic product. Was the product indeed a failure? If so, what caused the product to fail? What indications that the product would fail were evident during the product’s development? What could VLO have done in order to prevent the product from becoming a failure? What can VLO learn from the failure? Are there data from the non-problematic products that indicate what VLO excels at?
This thesis analyzes the data from all seven products and their projects in order to answer the research questions. Analyzing the non-problematic products is important in order to draw comparisons to the problematic product. As a result of this research, this thesis uncovers a variety of issues with the problematic product and identifies six areas for possible improvement. These six areas are: hardware research and development, decoupling of software from hardware, requirements management, maximal use of resources, developer order and priority of vital features, and schedule alignment. This thesis concludes that even though none of these six problematic areas can be pinpointed as the singular root cause of the problematic product’s failure, addressing these problems will improve the likelihood of product success.
|
95 |
Génération automatique de bouchons pour le test structurel basée sur basée sur l'analyse du flot de contôleGriche, Karim-Cyril 11 July 2005 (has links) (PDF)
Lors du développement d'un logiciel, plusieurs phases de test sont mises en oeuvre. Dans cette thèse, nous nous intéressons particulièrement à deux d'entre elles : les test unitaire et le test d'intégration. Dans le test unitaire, les entités du logiciel sont testées individuellement. Elles sont ensuite intégrée au sein d'un agrégat qui est soumis à un test d'intégration. Lors de cette phase, on cherche traditionnellement à tester les interactions entre ces entités. Nous nous intéressons plus particulièrement dans cette thèse au test structurel unitaire. Lors de cette phase de test, si l'entité contient des app rers d'autres entités, elles sont remplacées par des bouchons simples qui facilitent le test. Ces bouchons ne sont pas exempts de défauts. En particulier, ils sont généralement pas représentatifs des entités qu'ils remplacent. Les taux de couverture obtenus pendant le test ne représentent donc pas l'utilisatin éelle de la fonction testée. Dans cette thèse, nous proposons d'étendre la phase de test unitaire aux agrégats de fonctions. Tous les bouchons nécessaires sont produits automatiquement à partir du code des fonctions appelées. Pour cela, on se base sur une analyse et un découpage du flot de ontrôle de la fonction appelée en approximations, ainsi que sur la détermination de l'environnement particulier de chaque appel. Cet environnement ontient les informations sur les conditions d'appel à la fonction et sur l'impact de cet appel sur le flot de contrôle de la fonction appelante. On crée inalement le bouchon spécifique à un appel par filtrage des approximations par le contexte d'appel. On sélectionne ensuite une approximation pour chaque objectif de génération. L'ensemble de cette technique a été implanté au sein d'un prototype basé sur l'outil de test Inka.
|
96 |
Distributed Aspects: better separation of crosscutting concerns in distributed software systemsBenavides Navarro, Luis Daniel 19 January 2009 (has links) (PDF)
This thesis shows that abstractions provided by current mainstream Object Oriented (OO) languages are not enough to address the modularization of distributed and concurrent algo- rithms, protocols, or architectures. In particular, we show that code implementing concurrent and distributed algorithms is scattered and tangled in the main implementation of JBoss Cache, a real industrial middleware application. We also show that not only code is tangled, but also conceptual algorithms are hidden behind object-based structures (i.e., they are not visible in the code). Additionally, we show that such code is resilient to modularization. Thus, we show that several cycles of re-engineering (we study the evolution of three different version of JBoss Cache) using the same set of OO abstractions do not improve on the modularization of distributed and concurrent code. From these findings we propose a novel Aspect Oriented programming language with explicit support for distribution and concurrency (AWED). The language uses aspects as main abstractions and propose a model for distributed aspects and remote pointcuts, extending sequential approaches with support for regular sequences of distributed events. The language also proposes advanced support for the manipulation of groups of host, and the fine-grained deterministic ordering of distributed events. To evaluate the proposal we perform several experiments in different domains: refactoring and evolution of replicated caches, development of automatic toll systems, and debugging and testing of distributed applications. Finally, using this general model for distribution we provide two additional contributions. First, we introduce Invasive Patterns, an extension to traditional communication patterns for distributed applications. Invasive Patterns present an aspect-based language to express protocols over distributed topologies considering different coordination strategies (Architec- tural programming). The implementation of this approach is leveraged by the distributed features of AWED and is realized by means of a transformation into it. Second, we add the deterministic manipulation of distributed messages to our model by means of causally ordered protocols.
|
97 |
A Mode-Based Pattern for Feature Requirements, and a Generic Feature InterfaceDietrich, David January 2013 (has links)
Feature-oriented requirements decompose a system's requirements into individual bundles of functionality called features, where each feature's behaviour can be expressed as a state-machine model. However, state machines are difficult to write; determining how to decompose behaviour into states is not obvious, different stakeholders will have different opinions on how to structure the state machine, and the state machines can easily become too complex.
This thesis proposes a pattern for decomposing and structuring the model of a feature's behavioural requirements, based on modes of operation (e.g., Active, Inactive, Failed) that are common to features in multiple domains. Interestingly, the highest-level modes of the pattern can serve as a generic behavioural interface for all features that adhere to the pattern. The thesis proposes also several pattern extensions that provide guidance on how to structure the Active and Inactive behaviour of the feature.
The pattern was applied to model the behavioural requirements of 21 automotive features that were specified in 7 production-grade requirements documents. The pattern was applicable to all 21 features, and the proposed generic feature interface was applicable to 50 out of 58 inter-feature references. A user study with 18 participants evaluated whether use of the pattern made it easier than otherwise to write state machines for features and whether feature state machines written with the help of the pattern are more readable than those written without the help of the pattern. The results of the study indicate that use of the pattern facilitates writing of feature state machines.
|
98 |
Fully Automated Translation of BoxTalk to PromelaKajarekar, Tejas January 2011 (has links)
Telecommunication systems are structured to enable incremental growth, so that new telecommunication features can be added to the set of existing features. With the addition of more features, certain existing features may exhibit unpredictable behaviour. This is known as the feature interaction problem, and it is very old problem in telecommunication systems. Jackson and Zave have proposed a technology, Distributed Feature Composition (DFC) to manage the feature interaction problem. DFC is a pipe-and-filter-like architecture where features are "filters" and communication channels connecting features are "pipes".
DFC does not prescribe how features are specified or programmed. Instead, Zave and Jackson have developed BoxTalk, a call-abstraction, domain-specific, high-level programming language for programming features. BoxTalk is based on the DFC protocol and it uses macros to combine common sequences of read and write actions, thus simplifying the details of the DFC protocol in feature models. BoxTalk features must adhere to the DFC protocol in order to be plugged into a DFC architecture (i.e., features must be "DFC compliant"). We want to use model checking to check whether a feature is DFC compliant. We express DFC compliance using a set of properties expressed as linear temporal logic formulas.
To use the model checker SPIN, BoxTalk features must be translated into Promela. Our automatic verification process comprises three steps:
1. Explicate BoxTalk features by expanding macros and introducing implicit details.
2. Mechanically translate explicated BoxTalk features into Promela models.
3. Verify the Promela models of features using the SPIN model checker.
We present a case study of BoxTalk features, describing the original features and how they are explicated and translated into Promela by our software, and how they are proven to be DFC compliant.
|
99 |
A Case Study of a Very Large OrganizationWerner, Colin Mark 20 December 2011 (has links)
Very Large Organization (VLO) is an organization that produces hardware and software, which together form products. VLO granted access to data pertaining to seven different products and their development projects. One particular product is of interest to VLO since it was not as successful as the other products. The focus of this thesis is to study the problematic product and compare it to the other six products in order to draw some conclusions regarding the problematic product. The goal of this study is to indicate areas of improvement, which can help VLO improve future products.
This thesis explores and answers the following research questions focused around the problematic product. Was the product indeed a failure? If so, what caused the product to fail? What indications that the product would fail were evident during the product’s development? What could VLO have done in order to prevent the product from becoming a failure? What can VLO learn from the failure? Are there data from the non-problematic products that indicate what VLO excels at?
This thesis analyzes the data from all seven products and their projects in order to answer the research questions. Analyzing the non-problematic products is important in order to draw comparisons to the problematic product. As a result of this research, this thesis uncovers a variety of issues with the problematic product and identifies six areas for possible improvement. These six areas are: hardware research and development, decoupling of software from hardware, requirements management, maximal use of resources, developer order and priority of vital features, and schedule alignment. This thesis concludes that even though none of these six problematic areas can be pinpointed as the singular root cause of the problematic product’s failure, addressing these problems will improve the likelihood of product success.
|
100 |
Understanding Programmers' Working Context by Mining Interaction HistoriesZou, Lijie January 2013 (has links)
Understanding how software developers do their work is an important first step to improving their productivity. Previous research has generally focused either on laboratory experiments or coarsely-grained industrial case studies; however, studies that seek a finegrained understanding of industrial programmers working within a realistic context remain limited. In this work, we propose to use interaction histories — that is, finely detailed
records of developers’ interactions with their IDE — as our main source of information for understanding programmer’s work habits. We develop techniques to capture, mine, and analyze interaction histories, and we present two industrial case studies to show how this approach can help to better understand industrial programmers’ work at a detailed level: we explore how the basic characteristics of software maintenance task structures can be better understood, how latent dependence between program artifacts can be detected at interaction time, and show how patterns of interaction coupling can be identified. We also examine the link between programmer interactions and some of the contextual factors of software development, such as the nature of the task being performed, the design of the software system, and the expertise of the developers. In particular, we explore how task boundaries can be automatically detected from interaction histories, how system design
and developer expertise may affect interaction coupling, and whether newcomer and expert developers differ in their interaction history patterns. These findings can help us to better reason about the multidimensional nature of software development, to detect potential problems concerning task, design, expertise, and other contextual factors, and to build smarter tools that exploit the inherent patterns within programmer interactions and provide improved support for task-aware and expertise-aware software development.
|
Page generated in 0.1273 seconds