High-coverage testing is challenging. Modern object-oriented programs present additional challenges for testing. One key difficulty is the generation of proper method sequences to construct desired objects as method p...
详细信息
ISBN:
(纸本)9781450309400
High-coverage testing is challenging. Modern object-oriented programs present additional challenges for testing. One key difficulty is the generation of proper method sequences to construct desired objects as method parameters. In this paper, we cast the problem as an instance of program synthesis that automatically generates candidate programs to satisfy a user-specified intent. In our setting, candidate programs are method sequences, and desired object states specify an intent. Automatic generation of desired method sequences is difficult due to its large search space sequences often involve methods from multiple classes and require specific primitive values. This paper introduces a novel approach, called Seeker, to intelligently navigate the large search space. Seeker synergistically combines static and dynamic analyses: (1) dynamic analysis generates method sequences to cover branches;(2) static analysis uses dynamic analysis information for not-covered branches to generate candidate sequences;and (3) dynamic analysis explores and eliminates statically generated sequences. For evaluation, we have implemented Seeker and demonstrate its effectiveness on four subject applications totalling 28K LOC. We show that Seeker achieves higher branch coverage and def-use coverage than existing state-of-the-art approaches. We also show that Seeker detects 34 new defects missed by existing tools.
In this paper we present the experience gained and lessons learned when the IT department at Statoil ASA, a large Oil and Gas company in Norway, applied Domain-Driven design techniques in combination with agile softwa...
详细信息
ISBN:
(纸本)9781595938657
In this paper we present the experience gained and lessons learned when the IT department at Statoil ASA, a large Oil and Gas company in Norway, applied Domain-Driven design techniques in combination with agile software development practices to assess the software architecture of our next generation oil trading and supply chain application. Our hypothesis was that the use of objectoriented techniques, Domain-Driven design and a proper objectrelational mapping tool would significantly improve the performance and reduce the code base compared with current legacy systems. The legacy system is based on several Oracle databases serving a variety of clients written in Java, Gupta Centura Team Developer and HTML. The databases have a layer of business logic written in PL/SQL offering various system services to the clients. To validate our new objectoriented software architecture, we re-implemented one of the most computationally heavy and data intensive services using Test First and Domain-Driven design techniques. The resulting software was then tested on a set of servers with a representative subset of data from the production environment. We found that using these techniques improved our software architecture with respect to performance as well as code quality when running on top of our Oracle databases. We also tested the switch to an object database from Versant and achieved additional performance gains.
Monitoring-orientedprogramming (MOP1) [21, 18, 22, 19] is a formal framework for software development and analysis, in which the developer specifies desired properties using definable specification formalisms, along ...
详细信息
A description is given of a prototype persistent-object system, called DOOM (Data-orientedobject Manager), which was designed to explore issues in language-level persistence for object-oriented application platforms....
详细信息
ISBN:
(纸本)0818608420
A description is given of a prototype persistent-object system, called DOOM (Data-orientedobject Manager), which was designed to explore issues in language-level persistence for object-oriented application platforms. Language-level persitence presumes that the abstraction constructs for dealing with persistent data should be a well-integrated part of the underlying object-oriented language, rather than a separate language altogether. In its first iteration (DOOM-I), the language aspects of persistence were investigated, and a design which allowed the exchange of persistent objects between Commonobjects (an object-oriented extension to Common Lisp) and objective-C**2 (an object-oriented extension to C) was implemented. The system features a tight coupling between the languages' run-time support and a relational storage manager. In a second iteration (DOOM-II), the coupling between the database and the language was loosened, and more characteristics of the database were exposed to the applications programmer. The change was a result of disappointment on the part of trial users at the performance obtainable without caching of objects at the level of the language run-time system, and the desire to better support multiuser systems.
The usefulness and synergetic advantages of combining logic- and object-orientedprogramming in a declarative framework are explored. Rather than present another specific combination of logic and objectprogramming, t...
详细信息
ISBN:
(纸本)0818608420
The usefulness and synergetic advantages of combining logic- and object-orientedprogramming in a declarative framework are explored. Rather than present another specific combination of logic and objectprogramming, the authors discuss different kinds of extensions.
Persistent object stores require a way to automatically upgrade persistent objects, to change their code and storage representation. Automatic upgrades are a challenge for such systems. Upgrades must be performed in a...
详细信息
Persistent object stores require a way to automatically upgrade persistent objects, to change their code and storage representation. Automatic upgrades are a challenge for such systems. Upgrades must be performed in a way that is efficient both in space and time, and that does not stop application access to the store. In addition, however, the approach must be modular: it must allow programmers to reason locally about the correctness of their upgrades similar to the way they would reason about regular code. This paper provides solutions to both problems. The paper first defines upgrade modularity conditions that any upgrade system must satisfy to support local reasoning about upgrades. The paper then describes a new approach for executing upgrades efficiently while satisfying the upgrade modularity conditions. The approach exploits object encapsulation properties in a novel way. The paper also describes a prototype implementation and shows that our upgrade system imposes only a small overhead on application performance.
One of the key concepts available in many object-orientedprogramminglanguages is that of type-inheritance, which permits new types to be derived from, and inherit the capabilities of, old types. This paper describes...
详细信息
Understanding and analyzing multi-threaded program performance and scalability is far from trivial, which severely complicates parallel software development and optimization. In this paper, we present bottle graphs, a...
详细信息
ISBN:
(纸本)9781450323741
Understanding and analyzing multi-threaded program performance and scalability is far from trivial, which severely complicates parallel software development and optimization. In this paper, we present bottle graphs, a powerful analysis tool that visualizes multi-threaded program performance, in regards to both per-thread parallelism and execution time. Each thread is represented as a box, with its height equal to the share of that thread in the total program execution time, its width equal to its parallelism, and its area equal to its total running time. The boxes of all threads are stacked upon each other, leading to a stack with height equal to the total program execution time. Bottle graphs show exactly how scalable each thread is, and thus guide optimization towards those threads that have a smaller parallel component (narrower), and a larger share of the total execution time (taller), i.e. to the 'neck' of the bottle. Using light-weight OS modules, we calculate bottle graphs for unmodified multi-threaded programs running on real processors with an average overhead of 0.68%. To demonstrate their utility, we do an extensive analysis of 12 Java benchmarks running on top of the Jikes JVM, which introduces many JVM service threads. We not only reveal and explain scalability limitations of several well-known Java benchmarks;we also analyze the reasons why the garbage collector itself does not scale, and in fact performs optimally with two collector threads for all benchmarks, regardless of the number of application threads. Finally, we compare the scalability of Jikes versus the OpenJDK JVM. We demonstrate how useful and intuitive bottle graphs are as a tool to analyze scalability and help optimize multi-threaded applications.
暂无评论