A variety of language features to modularize cross-cutting concerns have recently been discussed, e.g., open modules, annotation-based pointcuts, explicit join points, and quantified-typed events. All of these ideas a...
详细信息
ISBN:
(纸本)9783642369643;9783642369636
A variety of language features to modularize cross-cutting concerns have recently been discussed, e.g., open modules, annotation-based pointcuts, explicit join points, and quantified-typed events. All of these ideas are essentially a form of aspect-oriented interface between object-oriented and cross-cutting modules, but the representation of this interface differs. Previous works have studied maintenance benefits of AO programs compared to OO programs, by usually looking at a single AO interface. Other works have looked at several AO interfaces, but only on relatively small systems or systems with only one type of aspectual behavior. Thus, there is a need for a study that examines large, realistic systems for several AO interfaces to determine what problems arise and in which interface(s). The main contribution of this work is a rigorous empirical study that evaluates the effectiveness of these proposals for 4 different AO interfaces by applying them to 35 different releases of a software product line called Mobile-Media and 50 different releases of a Web application called Health Watcher. In total, over 400k lines of code were studied across all releases. Our comparative analysis using quantitative metrics proposed by Chidamber and Kemerer shows the strengths and weaknesses of these AO interface proposals. Our change impact analysis shows the design stability provided by each of these recent proposals for AO interfaces.
Even when implemented in a purely procedural programming language, properly designed programs possess elements of good design that are expressible through object-oriented constructs and concepts. For example, placing ...
详细信息
ISBN:
(纸本)9783642390388
Even when implemented in a purely procedural programming language, properly designed programs possess elements of good design that are expressible through object-oriented constructs and concepts. For example, placing structured types and the procedures operating on them together in the same module achieves a weak form of encapsulation that reduces inter-module coupling. This paper presents a novel technique, and a supporting tool AutoOO, that extracts such implicit design elements from C applications and uses them to build reengineered object-oriented programs. The technique is completely automatic: users only provide a source C program, and the tool produces an object-oriented application written in Eiffel with the same input/output behavior as the source. An extensive evaluation on 10 open-source programs (including the editor vim and the math library libgsl) demonstrates that our technique works on applications of significant size and builds reengineered programs exhibiting elements of good object-oriented design, such as low coupling and high cohesion of classes, and proper encapsulation. The reengineered programs also leverage advanced features such as inheritance, contracts, and exceptions to achieve a better usability and a clearer design. The tool AutoOO is freely available for download.
In this paper we present a study on micro patterns in different releases of two software systems developed with objectoriented technologies and Agile process. Micro patterns are design decisions in code that can be e...
详细信息
ISBN:
(纸本)9783642383144;9783642383137
In this paper we present a study on micro patterns in different releases of two software systems developed with objectoriented technologies and Agile process. Micro patterns are design decisions in code that can be easily automatically recognised. Gil and Maman introduced the concept to support providing objective assessment of design decisions [1]. They catalogued 27 micro patterns that capture a variety of programming practices in Java. Micro patterns can be a useful metrics in order to measure the quality of software by showing that certain categories of micro patterns are more fault prone than others, and that the classes that do not correspond to any category of micro patterns are more likely to be faulty. In our study we present some empirical results on two case studies of systems developed with Agile methodologies, and compare them to previous results obtained for non Agile systems. In particular we have verified that the distribution of micro patterns in a software system developed using Agile methodologies does not differ from the distribution studied in other systems, and that the micro patterns fault-proneness is about the same. We also analyzed how the distribution of micro patterns changes in different releases of the same software system. We demonstrate that there is a relationship between the number of faults and the classes that do not match with any micro patterns. We found that these classes are more likely to be fault-prone than the others even in software developed with Agile methodologies.
At present, use case has been used in many large-scale application systems and has achieved good results. At the same time, it has also showed a strong applicability and has become the mainstream technology in object-...
详细信息
ISBN:
(纸本)9781467351379
At present, use case has been used in many large-scale application systems and has achieved good results. At the same time, it has also showed a strong applicability and has become the mainstream technology in object-oriented software analysis and design. So far, however, there is not a standardized approach to capture use cases in a complex system. It is arbitrarily controlled by designers in most practical applications. For this reason, according to the concept and characteristics of use case, this paper discusses an approach based on business activity diagrams to capture use cases. Then, some related rules are established to capture high quality use cases from business activity diagrams. Finally, a practical case study is given to illustrate the application of the proposed approach.
Task parallelism is ubiquitous in modern applications for event-based, distributed, or reactive systems. In this type of programming, the ability to cancel a running task arises as a critical feature. Although there a...
详细信息
ISBN:
(纸本)9783642399541;9783642399558
Task parallelism is ubiquitous in modern applications for event-based, distributed, or reactive systems. In this type of programming, the ability to cancel a running task arises as a critical feature. Although there are a variety of cancellation techniques, a comprehensive account of their characteristics is missing. This paper provides a classification of task cancellation patterns, as well as a detailed analysis of their advantages and disadvantages. One promising approach is cooperative cancellation, where threads must be continuously prepared for external cancellation requests. Based on this pattern, we propose an extension of SCOOP, an object-oriented concurrency model.
Micropatterns and nanopatterns have been previously demonstrated to be useful techniques for object-oriented program comprehension. In this paper, we use a similar approach for identifying structurally similar fragmen...
详细信息
ISBN:
(纸本)9783319026541;9783319026534
Micropatterns and nanopatterns have been previously demonstrated to be useful techniques for object-oriented program comprehension. In this paper, we use a similar approach for identifying structurally similar fragments in grammars in a broad sense (contracts for commitment to structure), in particular parser specifications, metamodels and data models. Grammatical micropatterns bridge the gap between grammar metrics, which are easy to implement but hard to assign meaning to, and language design guidelines, which are inherently meaningful as stemming from current software language engineering practice but considerably harder to formalise.
programming environments based on an iconic, flowchart-based notation have been widely used in the context of introducing novices to programming. These tools were initially heavily based on the technology of structure...
详细信息
ISBN:
(纸本)9781467361101;9781467361118
programming environments based on an iconic, flowchart-based notation have been widely used in the context of introducing novices to programming. These tools were initially heavily based on the technology of structure editing, with the aim of alleviating the burden of focusing on the syntactic details of programming languages and giving the chance to focus on acquiring problem solving skills. The technology of program animation was also utilized, in order to allow for a better comprehension of programming structures and flow of control. Furthermore, the ability of generating syntactically correct source code from the flowchart was integrated into these tools. Recently, several advanced features were added in flowchart-based programming environments, such as support for collaborative activities and distributed pair programming and usage in mobile devices. In this paper, a thorough review of programming environments based on an iconic notation is carried out with a focus on the support provided for introducing novices to programming, as well as other important software engineering issues in a simplified and straightforward manner. Proposals for research on this field and opportunities for a better teaching and learning of software engineering are presented.
Mobile device has fewer resources compare to desktop computers. Mobile application development is in the need of appropriate strategies in view of resource utilizations. Although some other design strategies are requi...
详细信息
ISBN:
(纸本)9781479905614
Mobile device has fewer resources compare to desktop computers. Mobile application development is in the need of appropriate strategies in view of resource utilizations. Although some other design strategies are required for software development, programming paradigm is the core. The overall aim of this study is to formulate the programming paradigms whereby achieve the optimal resource utilizations by mobile applications. As a part of this objective, this paper aims to determine whether the improper use of programming paradigm concepts consume more memory and / or CPU time. Imperative programming paradigm concepts have been used as a sample for this study. Imperative programming concepts such as looping, branching and arrays have been experimented. The results of the experiments and case studies proved that, improper use of programming concepts lead to more memory consumptions and/or take more time to response. In conclusion use of appropriate paradigms in mobile application design possibly will optimize the response time and memory utilization.
Programmers often need to initialise circular structures of objects. Initialisation should be safe (so that programs can never suffer null pointer exceptions or otherwise observe uninitialised values) and modular (so ...
详细信息
ISBN:
(纸本)9783642390388
Programmers often need to initialise circular structures of objects. Initialisation should be safe (so that programs can never suffer null pointer exceptions or otherwise observe uninitialised values) and modular (so that each part of the circular structure can be written and compiled separately). Unfortunately, existing languages do not support modular circular initialisation: programmers in practical languages resort to Tony Hoare's "Billion Dollar Mistake": initialising variables with nulls, and then hoping to fix them up afterward. While recent research languages have offered some solutions, none fully support safe modular circular initialisation. We present placeholders, a straightforward extension to object-oriented languages that describes circular structures simply, directly, and modularly. In typed languages, placeholders can be described by placeholder types that ensure placeholders are used safely. We define an operational semantics for placeholders, a type system for placeholder types, and prove soundness. Incorporating placeholders into object-oriented languages should make programs simultaneously simpler to write, and easier to write correctly.
We argue that the limit of the propagation of the heap effects of a source code modification is determined by the aliasing structure of method parameters in a trace of the method calls that cross a boundary which part...
详细信息
ISBN:
(纸本)9783939897637
We argue that the limit of the propagation of the heap effects of a source code modification is determined by the aliasing structure of method parameters in a trace of the method calls that cross a boundary which partitions the heap. Further, that this aliasing structure is sufficient to uniquely determine the state of the part of the heap which has not been affected. And we give a definition of what it means for a part of the heap to be unaffected by a source code modification. This can be used to determine the correctness of a refactoring.
暂无评论