• Documents
  • Authors
  • Tables
  • Log in
  • Sign up
  • MetaCart
  • DMCA
  • Donate

CiteSeerX logo

Advanced Search Include Citations
Advanced Search Include Citations | Disambiguate

Refactoring object-oriented frameworks,” (1992)

by W Opdyke
Add To MetaCart

Tools

Sorted by:
Results 1 - 10 of 489
Next 10 →

Finding Refactorings via Change Metrics

by Serge Demeyer, Stéphane Ducasse, Oscar Nierstrasz - IN PROCEEDINGS OF OOPSLA ’2000 (INTERNATIONAL CONFERENCE ON OBJECT-ORIENTED PROGRAMMING SYSTEMS, LANGUAGES AND APPLICATIONS , 1999
"... ..."
Abstract - Cited by 174 (18 self) - Add to MetaCart
Abstract not found
(Show Context)

Citation Context

...class collaborations, because redistribution of functionality reveals how classes interact with each other. In object-oriented development, changes are accomplished by means of so-called refactorings =-=[Opdy92b]-=-, [Fowl99a]. Refactoring operations —such as provided by the Refactoring Browser [Robe97a]— reorganise a class hierarchy by shifting responsibilities between classes, and redistributing instance varia...

DMS: Program transformations for practical scalable software evolution

by Ira D. Baxter, Christopher Pidgeon, Michael Mehlich - in Proc. 26th Int. Conf. on Software Engineering , 2004
"... While a number of research systems have demonstrated the potential value of program transformations, very few of these systems have made it into practice. The core technology for such systems is well understood; what remains is integration and more importantly, the problem of handling the scale of t ..."
Abstract - Cited by 168 (5 self) - Add to MetaCart
While a number of research systems have demonstrated the potential value of program transformations, very few of these systems have made it into practice. The core technology for such systems is well understood; what remains is integration and more importantly, the problem of handling the scale of the applications to be processed. This paper describes DMS, a practical, commercial program analysis and transformation system, and sketches a variety of tasks to which it has been applied, from redocumenting to large-scale system migration. Its success derives partly from a vision of design maintenance and the construction of infrastructure that appears necessary to support that vision. DMS handles program scale by careful space management, computational scale via parallelism
(Show Context)

Citation Context

...y using previously captured design information was suggested in 1990 [6]. But program transformation as a serious tool for software evolution is largely unrealized in practice. Mechanical refactoring =-=[13]-=- was proposed in 1990 as a technique for restructuring programs and is recently popularized [9] as a methodology with suggestions for tool support. Tools for refactoring SmallTalk [14] and Java have s...

Towards an Engineering Discipline for GRAMMARWARE

by Paul Klint, Ralf Lämmel, Chris Verhoef , 2003
"... Grammarware comprises grammars and all grammar-dependent software. The term grammar is meant here in the sense of all established grammar formalisms and grammar notations including context-free grammars, class dictionaries, XML schemas as well as some forms of tree and graph grammars. The term gramm ..."
Abstract - Cited by 146 (7 self) - Add to MetaCart
Grammarware comprises grammars and all grammar-dependent software. The term grammar is meant here in the sense of all established grammar formalisms and grammar notations including context-free grammars, class dictionaries, XML schemas as well as some forms of tree and graph grammars. The term grammar-dependent software refers to all software that involves grammar knowledge in an essential manner. Archetypal examples of grammar-dependent software are parsers, program converters, and XML document processors. Despite the pervasive role of grammars in software systems, the engineering aspects of grammarware are insufficiently understood. We lay out an agenda that is meant to promote research on increasing the productivity of grammarware development and on improving the quality of grammarware. To this end, we identify the problems with the current grammarware practises, the barriers that currently hamper research, the promises of an engineering discipline for grammarware, its principles, and the research challenges that have to be addressed.
(Show Context)

Citation Context

...igrated XML streams. “↑” has not been studied in the narrow XML or grammar context. However, the overall problem is similar to Opdyke’s refactoring of class hierarchies in object-oriented prog=-=ramming [92]-=-. (Recall class dictionaries are essentially grammars.) 8 An emerging discipline The essence, the omnipresence, the promises and the ingredients of a comprehensive engineering discipline for grammarwa...

Reengineering class hierarchies using concept analysis

by Gregor Snelting, Frank Tip - In ACM Trans. Programming Languages and Systems , 1998
"... A new method is presented for analyzing and reengineering class hierarchies. In our approach, a class hierarchy is processed along with a set of applications that use it, and a fine-grained analysis of the access and subtype relationships between objects, variables and class members is performed. Th ..."
Abstract - Cited by 141 (6 self) - Add to MetaCart
A new method is presented for analyzing and reengineering class hierarchies. In our approach, a class hierarchy is processed along with a set of applications that use it, and a fine-grained analysis of the access and subtype relationships between objects, variables and class members is performed. The result of this analysis is again a class hierarchy, which is guaranteed to be behaviorally equivalent to the original hierarchy, but in which each object only contains the members that are required. Our method is semantically well-founded in concept analysis: the new class hierarchy is a minimal and maximally factorized concept lattice that reflects the access and subtype relationships between variables, objects and class members. The method is primarily intended as a tool for finding imperfections in the design of class hierarchies, and can be used as the basis for tools that largely automate the process of reengineering such hierarchies. The method can also be used as a space-optimizing source-to-source transformation that removes redundant fields from objects. A prototype implementation for Java has been constructed, and used to conduct several case studies. Our results demonstrate that the method can provide valuable insights into the usage of the class hierarchy in a specific context, and lead to useful restructuring proposals.
(Show Context)

Citation Context

...overview article [7] presents 18 dierent methods, many of them process-centered or dynamic analyses. The probably most well-known method for static restructuring was introduced by Opdyke and Johnson [=-=21, 20]-=-. They present a number of behavior-preserving transformations on class hierarchies, which they refer to as refactorings. The goal of refactoring is to improve design and enable reuse by \factoring ou...

The Craft of Functional Programming

by Simon Thompson , 1999
"... Abstract. Refactoring is the process of improving the design of existing programs without changing their functionality. These notes cover refactoring in functional languages, using Haskell as the medium, and introducing the HaRe tool for refactoring in Haskell. 1 ..."
Abstract - Cited by 122 (6 self) - Add to MetaCart
Abstract. Refactoring is the process of improving the design of existing programs without changing their functionality. These notes cover refactoring in functional languages, using Haskell as the medium, and introducing the HaRe tool for refactoring in Haskell. 1

Declarative Reasoning about the Structure of Object-Oriented Systems

by Roel Wuyts - In Proceedings of the TOOLS USA ’98 Conference
"... The structure of object-oriented systems typically forms a complicated, tangled web of interdependent classes. Understanding this implicit and hidden structure poses severe problems to developers and maintainers who want to use, extend or adapt those systems. This paper advocates the use of a logic ..."
Abstract - Cited by 116 (13 self) - Add to MetaCart
The structure of object-oriented systems typically forms a complicated, tangled web of interdependent classes. Understanding this implicit and hidden structure poses severe problems to developers and maintainers who want to use, extend or adapt those systems. This paper advocates the use of a logic meta-language to express and extract structural relationships in class-based object-oriented systems. As validation the logic meta-language SOUL was implemented and used to construct a declarative framework that allows reasoning about the structure of Smalltalk programs. The declarative framework's usefulness is illustrated by expressing di#erent high-level structural relationships such as those described by design patterns. 1:
(Show Context)

Citation Context

...ce is a common name for operations where parse trees are replaced by other parse trees. Thus new code is generated based on the result of a query. This could be used to support refactoring operations =-=[10]-=-, or for building sophisticated code porting tools. This will require serious extensions to the language. For example, a nd/replace statement to replace every direct access to an instance variable wit...

Tool support for objectoriented patterns.

by Gert Florijn, Marco Meijers, Pieter van Winsen - In Mehmet Aksit and Satoshi Matsuoka, editors, ECOOP ’97 — Object-Oriented Programming 11th European Conference, Jyvaskyla, Finland, , 1997
"... ..."
Abstract - Cited by 107 (0 self) - Add to MetaCart
Abstract not found

Evolving Object-Oriented Designs with Refactorings

by Lance Tokuda, Don Batory , 2001
"... Refactorings are behavior-preserving program transformations that automate design evolution in object-oriented applications. Three kinds of design evolution are: schema transformations, design pattern microarchitectures, and the hot-spot-driven-approach. This research shows that all three are automa ..."
Abstract - Cited by 100 (2 self) - Add to MetaCart
Refactorings are behavior-preserving program transformations that automate design evolution in object-oriented applications. Three kinds of design evolution are: schema transformations, design pattern microarchitectures, and the hot-spot-driven-approach. This research shows that all three are automatable with refactorings. A comprehensive list of refactorings for design evolution is provided and an analysis of supported schema transformations, design patterns, and hot-spot meta patterns is presented. Further, we evaluate whether refactoring technology can be transferred to the mainstream by restructuring non-trivial C++ applications. The applications that we examine were evolved manually by software engineers. We show that an equivalent evolution could be reproduced significantly faster and cheaper by applying a handful of general-purpose refactorings. In one application, over 14K lines of code were transformed automatically that otherwise would have been coded by hand. Our experiments identify benefits, limitations, and topics of further research related to the transfer of refactoring technology to a production environment.
(Show Context)

Citation Context

... object initialization if Derived is instantiated. 7. Program behavior must not depend on the size or layout of Derived. Figure 2.2: Inherit[Base, Derived] enabling conditions Opdyke for refactorings =-=[3]-=-. Opdyke claimed to identify a set of seven invariants which, if preserved, guaranteed that two Smalltalk or C++ programs would run identically. For example, his first invariant is that each class mus...

Using Origin Analysis to Detect Merging and Splitting of Source Code Entities

by Michael W. Godfrey, Lijie Zou , 2005
"... Merging and splitting source code entities is a common activity during the lifespan of a software system; as developers rethink the essential structure of a system or plan for a new evolutionary direction, so must they be able to reorganize the design artifacts at various abstraction levels as seems ..."
Abstract - Cited by 96 (3 self) - Add to MetaCart
Merging and splitting source code entities is a common activity during the lifespan of a software system; as developers rethink the essential structure of a system or plan for a new evolutionary direction, so must they be able to reorganize the design artifacts at various abstraction levels as seems appropriate. However, while the raw effects of such changes may be plainly evident in the new artifacts, the original context of the design changes is often lost. That is, it may be obvious which characters of which files have changed, but it may not be obvious where or why moving, renaming, merging, and/or splitting of design elements has occurred. In this paper, we discuss how we have extended origin analysis [1], [2] to aid in the detection of merging and splitting of files and functions in procedural code; in particular, we show how reasoning about how call relationships have changed can aid a developer in locating where merges and splits have occurred, thereby helping to recover some information about the context of the design change. We also describe a case study of these techniques (as implemented in the Beagle tool) using the PostgreSQL database system as the subject.

Binary Component Adaptation

by Ralph Keller, Urs Hölzle , 1998
"... Abstract. Binary component adaptation (BCA) allows components to be adapted and evolved in binary form and on-the-fly (during program loading). BCA rewrites component binaries before (or while) they are loaded, requires no source code access and guarantees release-to-release compatibility. That is, ..."
Abstract - Cited by 96 (1 self) - Add to MetaCart
Abstract. Binary component adaptation (BCA) allows components to be adapted and evolved in binary form and on-the-fly (during program loading). BCA rewrites component binaries before (or while) they are loaded, requires no source code access and guarantees release-to-release compatibility. That is, an adaptation is guaranteed to be compatible with a new binary release of the component as long as the new release itself is compatible with clients compiled using the earlier release. We describe our implementation of BCA for Java and demonstrate its usefulness by showing how it can solve a number of important integration and evolution problems. Even though our current implementation was designed for easy integration with Sun’s JDK 1.1 VM rather than for ultimate speed, measurements show that the load-time overhead introduced by BCA is small, in the range of one or two seconds. With its flexibility, relative simple implementation, and low overhead, binary component adaptation could significantly
Powered by: Apache Solr
  • About CiteSeerX
  • Submit and Index Documents
  • Privacy Policy
  • Help
  • Data
  • Source
  • Contact Us

Developed at and hosted by The College of Information Sciences and Technology

© 2007-2019 The Pennsylvania State University