For a long time efficient use of massively parallel computers has been hindered by dependencies introduced in software through low-level implementation practice. This paper presents a programming environment and langu...
详细信息
Last year at OOPSLA we presented a methodology, vertical profiling, for understanding the performance of object-oriented programs. The key insight behind this methodology is that modern programs run on top of many lay...
详细信息
Last year at OOPSLA we presented a methodology, vertical profiling, for understanding the performance of object-oriented programs. The key insight behind this methodology is that modern programs run on top of many layers (virtual machine, middleware, etc) and thus we need to collect and combine information from all layers in order to understand system performance. Although our methodology was able to explain previously unexplained performance phenomena, it was extremely labor intensive, In this paper we describe and evaluate techniques for automating two significant activities of vertical profiling: trace alignment and correlation. Trace alignment aligns traces obtained from separate runs so that one can reason across the traces. We are not aware of any prior approach that effectively and automatically aligns traces. Correlation sifts through hundreds of metrics to find ones that have a bearing on a performance anomaly of interest. In prior work we found that statistical correlation was only sometimes effective. We have identified highly-effective approaches for both activities. For aligning traces we explore dynamic time warping, and for correlation we explore eight correlators based on statistical correlation, distance measures, and piecewise linear segmentation. Although we explore these activities in the context of vertical profiling, both activities are widely applicable in the performance analysis area. Copyright 2005 ACM.
A practical application of object-oriented measures is to predict which classes are likely to contain a fault. This is contended to be meaningful because object-oriented measures are believed to be indicators of psych...
详细信息
ISBN:
(纸本)0769508073
A practical application of object-oriented measures is to predict which classes are likely to contain a fault. This is contended to be meaningful because object-oriented measures are believed to be indicators of psychological complexity, and classes that are more complex are likely to be faulty Recently, a cognitive theory has been proposed suggesting that there are threshold effects for many object-oriented measures. This means that object-oriented classes are easy to understand as long as their complexity is below a threshold. Above that threshold their understandability decreases rapidly, leading to an increased probability of a fault. This occurs, according to the theory, due to an overflow of short-term human memory. If this theory is confirmed, then it would provide a mechanism that would explain the introduction of faults into object-oriented systems, and would also provide some practical guidance on how to design object-oriented programs. In this paper we empirically test this theory on two C++ telecommunications systems. We test for threshold effects in a subset of the Chidamber and Kemerer (CK) suite of measures. The dependent variable was the incidence of faults that lead to field failures. Our results indicate that there are no threshold effects for any of the measures studied. This means that there is no value for the studied CK measures where the fault-proneness changes from being steady to rapidly increasing. The results are consistent across the two systems. Therefore, we can provide no support to the posited cognitive theory.
Application developers often apply the Monkey See/Monkey Do rule for framework-based application development, i.e., they use existing applications as a guide to understand how to implement a desired framework-provided...
详细信息
ISBN:
(纸本)9781595938657
Application developers often apply the Monkey See/Monkey Do rule for framework-based application development, i.e., they use existing applications as a guide to understand how to implement a desired framework-provided concept (e.g., a context menu in an Eclipse view). However, the code that implements the concept of interest might be scattered across and tangled with code implementing other concepts. To address this issue, we introduce a novel framework comprehension technique called FUDA (Framework API Understanding through Dynamic Analysis). The main idea of this technique is to extract the implementation recipes of a given framework-provided concept from dynamic traces with the help of a dynamic slicing approach integrated with clustering and data mining techniques. In this demonstration, we present the prototype implementation of FUDA as two Eclipse plug-ins, and use them to generate the implementation recipes for a number of concepts in Eclipse views and GEF editors by using only a few example applications.
A-NETL is a parallel object-oriented language intended to be used for managing small to massive parallelism with medium grain size. Its design goals are to support various styles of message passing, to treat data para...
详细信息
A-NETL is a parallel object-oriented language intended to be used for managing small to massive parallelism with medium grain size. Its design goals are to support various styles of message passing, to treat data parallel operations at the same cost as programming languages of the SIMD type, to provide several synchronization facilities for autonomous control, and to provide information for the efficient allocation of objects to nodes. Starting with these design principles, this paper then goes on to describe the syntax and semantics of the language and the major implementation issues, including the reduction of message communication cost, efficient implementation of statically and dynamically created massive objects, the realization of synchronization schemes, the object-to-node allocation scheme to minimize communication cost, and logical-time-based debugging for asynchronous operations.
This innovative practice full paper presents an empirical study aimed at evaluating the potential of ChatGPT, an advanced AI-driven chatbot, as a supplementary educational tool in undergraduate Computer Science and So...
详细信息
ISBN:
(纸本)9798350351507
This innovative practice full paper presents an empirical study aimed at evaluating the potential of ChatGPT, an advanced AI-driven chatbot, as a supplementary educational tool in undergraduate Computer Science and Software Engineering (CSSE) courses. The study, initiated in the summer of 2023, focused on assessing ChatGPT's capabilities in generating accurate and complete computer code, identifying and rectifying code defects (bugs), and its scalability in handling larger programs. To achieve this, we conducted a series of experiments with ChatGPT. In one experiment, we introduced bugs into small programs from introductory CSSE courses. ChatGPT was tasked with detecting these defects and providing recommendations for fixing them. We evaluated ChatGPT's effectiveness in bug detection, the quality of its recommendations, and the completeness of the proposed solutions. We sought answers to questions such as whether ChatGPT found all injected defects, provided appropriate recommendations, and delivered high-quality solutions based on criteria like code completeness, size, complexity, and readability. In another experiment, ChatGPT was asked to generate code for assignments from previous CSSE courses, including Intro to Computer Science and programming in C++, Intro to Python programming, and object-orientedprogramming and Data Structures using Java. We assessed the generated code's correctness and quality in comparison to student-written code. Similarly, in a third experiment, we evaluated ChatGPT's ability to generate larger programs using requirement specifications from an upper-division CSSE course on Agile Software Engineering. Analyzing both qualitative and quantitative data from these experiments during the summer, we determined that ChatGPT showed promise as an educational tool. Consequently, we developed a plan to integrate ChatGPT into select CSSE courses for the fall semester of 2023. Specifically, ChatGPT was integrated into two of our introductory CSSE cou
A number of software analysts may produce different, perhaps all of them correct, solutions from one specific software requirement document. This is because natural language understanding is complex and because each a...
详细信息
ISBN:
(纸本)9789898111524
A number of software analysts may produce different, perhaps all of them correct, solutions from one specific software requirement document. This is because natural language understanding is complex and because each analyst has distinct design experience. A methodology and approach that can be automated and that uses a proposed semi-natural language called 4WL used to accelerate the production of reliable accords between different stakeholders. The supporting software tool called GOOAL, Graphic objectoriented Analysis Laboratory automatically produces simple object models (UML diagrams) from English or Spanish statements with minimal user participation. These statements, faithfully describe the original problem description sentences. The models are generated analyzing each sentence of the intermediate 4W language version of the original sentence set. With this methodology and supporting software tool, students of objectoriented technology can visualize the design decisions being made by the system. This methodology and software tool has been used to support the learning process in objectoriented analysis and design courses. The original tool was developed to "understand" English and it was validated with design artefacts produced by several experts of the University of Colorado. The main results reported by the students, are related with the use of good design practices, a better understanding of UML language and a major interest in the pre programming process. Its technical contribution is the role posets technique.
The specification of system requirements can be construed as a set of tests which the design and subsequent implementation are expected to satisfy. Our approach is to adopt an architectural design methodology in which...
详细信息
The specification of system requirements can be construed as a set of tests which the design and subsequent implementation are expected to satisfy. Our approach is to adopt an architectural design methodology in which distributed systems are described, modelled and constructed in terms of their software structure. Descriptions of the constituent software components and their interconnection patterns provide a clear and concise level at which to specify, design and analyse systems, and can be used directly by construction tools to generate the system itself. The Architect's Assistant is intended to provide an environment for supporting this methodology.
An objectoriented, cross platform, C++ application has been successfully developed for the manipulation of production data associated with reservoir engineering and reservoir simulation data. The application supports...
详细信息
An objectoriented, cross platform, C++ application has been successfully developed for the manipulation of production data associated with reservoir engineering and reservoir simulation data. The application supports all the main categories of production data necessary for simulation including historical production and injection volumes, well deviation surveys and reservoir events such as completion data. This paper discusses how development of this and associated application has shown it is possible to efficiently build sophisticated cross platform products if the appropriate tools, suppliers and methodology are used.
This paper addresses compositional and incremental type checking for object-orientedprogramming languages. Recent work achieved incremental type checking for structurally typed functional languages through co-context...
详细信息
ISBN:
(纸本)9783959770354
This paper addresses compositional and incremental type checking for object-orientedprogramming languages. Recent work achieved incremental type checking for structurally typed functional languages through co-contextual typing rules, a constraint-based formulation that removes any context dependency for expression typings. However, that work does not cover key features of object-oriented languages: Subtype polymorphism, nominal typing, and implementation inheritance. Type checkers encode these features in the form of class tables, an additional form of typing context inhibiting incrementalization. In the present work, we demonstrate that an appropriate co-contextual notion to class tables exists, paving the way to efficient incremental type checkers for object-oriented languages. This yields a novel formulation of Igarashi et al.'s Featherweight Java (FJ) type system, where we replace class tables by the dual concept of class table requirements and class table operations by dual operations on class table requirements. We prove the equivalence of FJ's type system and our co-contextual formulation. Based on our formulation, we implemented an incremental FJ type checker and compared its performance against javac on a number of realistic example programs.
暂无评论