Ralph Johnson - Academia.edu (original) (raw)

Papers by Ralph Johnson

Lecture Notes in Computer Science, 2012

Researchers use file-based Version Control System (VCS) as the primary source of code evolution d... more Researchers use file-based Version Control System (VCS) as the primary source of code evolution data. VCSs are widely used by developers, thus, researchers get easy access to historical data of many projects. Although it is convenient, research based on VCS data is incomplete and imprecise. Moreover, answering questions that correlate code changes with other activities (e.g., test runs, refactoring) is impossible. Our tool, CodingTracker, non-intrusively records fine-grained and diverse data during code development. CodingTracker collected data from 24 developers: 1,652 hours of development, 23,002 committed files, and 314,085 testcase runs. This allows us to answer: How much code evolution data is not stored in VCS? How much do developers intersperse refactorings and edits in the same commit? How frequently do developers fix failing tests by changing the test itself? How many changes are committed to VCS without being tested? What is the temporal and spacial locality of changes?

Identifying repetitive code changes benefits developers, tool builders, and researchers. Tool bui... more Identifying repetitive code changes benefits developers, tool builders, and researchers. Tool builders can automate the popular code changes, thus improving the productivity of developers. Researchers can better understand the practice of code evolution, advancing existing code assistance tools and benefiting developers even further. Unfortunately, existing research either predominantly uses coarse-grained Version Control System (VCS) snapshots as the primary source of code evolution data or considers only a small subset of program transformations of a single kind-refactorings. We present the first approach that identifies previously unknown frequent code change patterns from a fine-grained sequence of code changes. Our novel algorithm effectively handles challenges that distinguish continuous code change pattern mining from the existing data mining techniques. We evaluated our algorithm on 1,520 hours of code development collected from 23 developers, and showed that it is effective, useful, and scales to large amounts of data. We analyzed some of the mined code change patterns and discovered ten popular kinds of high-level program transformations. More than half of our 420 survey participants acknowledged that eight out of ten transformations are relevant to their programming activities.

Despite the enormous success that manual and automated refactoring has enjoyed during the last de... more Despite the enormous success that manual and automated refactoring has enjoyed during the last decade, we know little about the practice of refactoring. Understanding the refactoring practice is important for developers, refactoring tool builders, and researchers. Many previous approaches to study refactorings are based on comparing code snapshots, which is imprecise, incomplete, and does not allow answering research questions that involve time or compare manual and automated refactoring. We present the first extended empirical study that considers both manual and automated refactoring. This study is enabled by our algorithm, which infers refactorings from continuous changes. We implemented and applied this algorithm to the code evolution data collected from 23 developers working in their natural environment for 1,520 hours. Using a corpus of 5,371 refactorings, we reveal several new facts about manual and automated refactorings. For example, more than a half of the refactorings were performed manually. The popularity of automated and manual refactorings differs. More than one third of the refactorings performed by developers are clustered. For some refactoring kinds, up to 64% of performed refactorings do not reach the Version Control System.

Identifying repetitive code changes benefits developers, tool builders, and researchers. Tool bui... more Identifying repetitive code changes benefits developers, tool builders, and researchers. Tool builders can automate the popular code changes, thus improving the productivity of developers. Researchers would better understand the practice of code evolution, advancing existing code assistance tools even further. Developers would particularly benefit if such tools can learn and support repetitive code changes that are in progress. Unfortunately, the existing tools that aim at detecting frequent code change patterns predominantly focus on analyzing the static source code of an application rather than dynamic code changes, and thus, they can not learn from the changes on-the-fly. We present the first approach that identifies previously unknown frequent code change patterns from a continuous sequence of code changes. Our novel algorithm effectively handles two major challenges that distinguish continuous code change pattern mining from the existing data mining techniques: overlapping transactions and transactions containing multiple instances of the same item kind. We evaluated our algorithm on 1,520 hours of code development collected from 23 developers, and showed that it is effective, useful, and scales to big amounts of data. We analyzed some of the mined code change patterns and discovered ten popular kinds of high level program transformations.

Preprocessors complicate refactoring because refactoring tools must manipulate unpreprocessed cod... more Preprocessors complicate refactoring because refactoring tools must manipulate unpreprocessed code. Working forward from Garrido's work on refactoring preprocessed C [1], we propose a general means by which preprocessor directives can be represented in a syntax tree for an arbitrary language. The representation is simple but general, based on the notions of token-whitetext affixes and substitution tokens. Moreover, we suggest that a preprocessing infrastructure can be completely independent of the language being preprocessed, allowing a single preprocessor to be reused among several refactoring tools and allowing numerous preprocessors to be plugged into a single refactoring tool.

In the multicore era, sequential programs need to be refactored for parallelism. The next version... more In the multicore era, sequential programs need to be refactored for parallelism. The next version of Java provides ParallelArray, an array data structure that supports parallel operations over the array elements. For example, one can apply a procedure to each element, or reduce all elements to a new element in parallel. Refactoring an array to a Paral-lelArray requires (i) analyzing whether the loop iterations are safe for parallel execution, and (ii) replacing loops with the equivalent parallel operations. When done manually, these tasks are non-trivial and time-consuming. We present ReLooper, an Eclipse-based refactoring tool, that performs these tasks automatically. Experience with refactoring real programs shows that ReLooper is useful: it reduces the burden of analyzing and rewriting parallel loops, and it is fast enough to be used interactively.

The documentation for a framework must meet several requirements. These requirements can all be m... more The documentation for a framework must meet several requirements. These requirements can all be met by structuring the documentation as a set of patterns, sometimes called a "pattern language". Patterns can describe the purpose of a framework, can let application programmers use a fmework without having to understand in detail how it works, and can teach many of the design details embodied in the frame work. This paper shows how to use patterns to document a framework, and includes a set ofpatterns forHotDmw as an example. Christopher Alexander, an architect, developed the idea of a "pattern language" to enable people to design their own homes and communities [Alexander et. al.]. A pattern language is a set of patterns, each of which describes how to solve a particular kind of problem. His pattern language starts at a very large scale, explaining how the world should be broken into nations and nations into smaller regions, and goes on to explain how to arrange roads, parking, shopping, places to work, homes, and places of worship. The patterns focus on finer and finer levels of detail, passing though a discussion of how to arrange rooms in a house, and finally describing the type of material to use for walls, how to decorate rooms, and how to provide lighting. Alexander's pattern language is supposed to be a document that non-architects can use to design their own communities and homes. No specialized training is needed to use it. It focuses on common design problems that non-architects will encounter, like how to build bedrooms and row houses, rather than uncommon ones, like how to build concert halls and cathedrals.

Sigplan Notices, Oct 1, 1996

Frameworks and domain-specific visual languages are two different reuse techniques, the first tar... more Frameworks and domain-specific visual languages are two different reuse techniques, the first targeted at expert programmers, the second at domain experts. In fact, these techniques are closely related. This paper shows how to develop a domain-specific visual language by first developing a white-box framework for the domain, then turning it into a black-box framework, and finally building a graphical front end for it. We used this technique in a compiler to specify run-time systems. Research: reuse, components, and frameworks

2009 ICSE Workshop on Software Engineering for Secure Systems, 2009

A security-oriented program transformation maps programs to security-augmented programs, i.e. it ... more A security-oriented program transformation maps programs to security-augmented programs, i.e. it introduces a security solution to make programs more secure. Our previous work defined security-oriented program transformations [6], introduced a catalog of program transformations [8], and showed how program transformations could be applied to systematically eradicate various types of data injection attacks [9]. This paper shows how securityoriented program transformations could be used to improve the security of a system's perimeter by introducing authentication, authorization and input validation components. The program transformation examples in this paper are JAVA specific, but the transformations could be implemented to use other authentication and authorization frameworks.

2015 IEEE/ACM 37th IEEE International Conference on Software Engineering, 2015

Modern integrated development environments (IDEs) make many software engineering tasks easier by ... more Modern integrated development environments (IDEs) make many software engineering tasks easier by providing automated programming support such as code completion and navigation. However, such support-and therefore IDEs as a whole-operate on one revision of the code at a time, and leave handling of code history to external tools or plugins, such as EGit for Eclipse. For example, when a method is removed from a class, developers can no longer find the method through code completion. This forces developers to manually switch across different revisions or resort to using external tools when they need to learn about previous code revisions. We propose a novel approach of adding a temporal dimension to IDEs, enabling code completion and navigation to operate on multiple revisions of code at a time. We previously introduced the idea of temporal code completion and navigation, and presented a vision for how that idea may be realized. This paper realizes that vision by implementing and evaluating a prototype tool called Tempura. We describe our algorithm for processing and indexing historical code information from repositories for Tempura, and demonstrate Tempura's scalability with three large Eclipse projects. We also evaluate Tempura's usability through a controlled user study. The study participants learned about the code history with more accuracy when using Tempura compared to EGit. Although the sample size was not large enough to provide strong statistical significance, the results show a promising outlook for our approach.

ACM SIGPLAN Notices, 1996

Frameworks and domain-specific visual languages are two different reuse techniques, the first tar... more Frameworks and domain-specific visual languages are two different reuse techniques, the first targeted at expert programmers, the second at domain experts. In fact, these techniques are closely related. This paper shows how to develop a domain-specific visual language by first developing a white-box framework for the domain, then turning it into a black-box framework, and finally building a graphical front end for it. We used this technique in a compiler to specify run-time systems.

ACM SIGPLAN Notices, 2001

Many object-oriented information systems share an architectural style that emphasizes flexibility... more Many object-oriented information systems share an architectural style that emphasizes flexibility and run-time adaptability. Business rules are stored externally to the program such as in a database or XML files instead of in code. The object model that the user cares about is part of the database, and the object model of the code is just an interpreter of the users' object model. We call these systems "Adaptive Object-Models", because the users' object model is interpreted at runtime and can be changed with immediate (but controlled) effects on the system interpreting it. The real power in Adaptive Object-Models is that they have a definition of a domain model and rules for its integrity and can be configured by domain experts external to the execution of the program. This paper describes the Adaptive Object-Model architecture along with its strengths and weaknesses. It illustrates the Adaptive Object-Model architectural style by describing a framework for Medical...

2009 IEEE/ACM International Conference on Automated Software Engineering, 2009

ACM SIGPLAN Fortran Forum, 2010

Proceedings 1991 International Workshop on Object Orientation in Operating Systems

We present a method for designing operating systems as an object-oriented framework of generalize... more We present a method for designing operating systems as an object-oriented framework of generalized, abstract components. The framework is specialized into further subframeworks to implement subqystems of the operating system. Each subframework introduces constraints and relationships between the abstract classes of the components. The constraints are inherited by the instantiations of the framework. Choices is an object-oriented operating system designed and implemented using frameworks. In this paper, we explain the application of our design approach to Choices. We describe the following subsystems and their subframeworks: virtual memory, persistent storage, process management, message passing and device management subframeworks. We discuss the advantages and disadvantages of using frameworks to design and implement object-oriented systems. This work was supported in part by NSF grant CISE-1-5-30O35 and by NASA grants NSG l47l and NAG 1-163.

Software Architecture, 2002

We have noticed a common architecture in many systems that emphasize flexibility and run-time con... more We have noticed a common architecture in many systems that emphasize flexibility and run-time configuration. In these systems, business rules are stored externally to the program such as in a database or XML files. The object model that the user cares about is part of the database, and the object model of the code is just an interpreter of the users' object model. We call these systems "Adaptive Object-Models", because the users' object model is interpreted at runtime and can be changed with immediate (but controlled) effects on the system interpreting it. The real power in Adaptive Object-Models is that the definition of a domain model and rules for its integrity can be configured by domain experts external to the execution of the program. These systems are important when flexibility and dynamic runtime configuration is needed, but their architectures have yet to be described in detail. This paper describes the Adaptive Object-Model architecture style along with its strengths and weaknesses. It illustrates the Adaptive Object-Model architectural style by outlining examples of production systems.

Conference proceedings on Object-oriented programming systems, languages and applications, 1988

TS (Typed Smalltalk) is a portable optimizing compiler that produces native machine code for a ty... more TS (Typed Smalltalk) is a portable optimizing compiler that produces native machine code for a typed variant of Smalltalk, making Smalltalk programs much faster. This paper describes the structure of TS, the kinds of optimizations that it performs, the constraints that it places upon Smalltalk, the constraints placed upon it by an interactive programming environment, and its performance.

Proceedings of the 24th ACM SIGPLAN conference companion on Object oriented programming systems languages and applications, 2009

In the multicore era, sequential programs need to be refactored for parallelism. The next version... more In the multicore era, sequential programs need to be refactored for parallelism. The next version of Java provides ParallelArray, an array datastructure that supports parallel operations over the array elements. For example, one can apply a procedure to each element, or reduce all elements to a new element in parallel. Refactoring an array to a ParallelArray requires (i) analyzing whether the loop iterations are safe for parallel execution, and (ii) replacing loops with the equivalent parallel operations. When done manually, these tasks are non-trivial and time-consuming. This demo presents RELOOPER, an Eclipse-based refactoring tool, that performs these tasks automatically. Preliminary experience with refactoring real programs shows that RELOOPER is useful.

Lecture Notes in Computer Science, 2012

Researchers use file-based Version Control System (VCS) as the primary source of code evolution d... more Researchers use file-based Version Control System (VCS) as the primary source of code evolution data. VCSs are widely used by developers, thus, researchers get easy access to historical data of many projects. Although it is convenient, research based on VCS data is incomplete and imprecise. Moreover, answering questions that correlate code changes with other activities (e.g., test runs, refactoring) is impossible. Our tool, CodingTracker, non-intrusively records fine-grained and diverse data during code development. CodingTracker collected data from 24 developers: 1,652 hours of development, 23,002 committed files, and 314,085 testcase runs. This allows us to answer: How much code evolution data is not stored in VCS? How much do developers intersperse refactorings and edits in the same commit? How frequently do developers fix failing tests by changing the test itself? How many changes are committed to VCS without being tested? What is the temporal and spacial locality of changes?

Identifying repetitive code changes benefits developers, tool builders, and researchers. Tool bui... more Identifying repetitive code changes benefits developers, tool builders, and researchers. Tool builders can automate the popular code changes, thus improving the productivity of developers. Researchers can better understand the practice of code evolution, advancing existing code assistance tools and benefiting developers even further. Unfortunately, existing research either predominantly uses coarse-grained Version Control System (VCS) snapshots as the primary source of code evolution data or considers only a small subset of program transformations of a single kind-refactorings. We present the first approach that identifies previously unknown frequent code change patterns from a fine-grained sequence of code changes. Our novel algorithm effectively handles challenges that distinguish continuous code change pattern mining from the existing data mining techniques. We evaluated our algorithm on 1,520 hours of code development collected from 23 developers, and showed that it is effective, useful, and scales to large amounts of data. We analyzed some of the mined code change patterns and discovered ten popular kinds of high-level program transformations. More than half of our 420 survey participants acknowledged that eight out of ten transformations are relevant to their programming activities.

Despite the enormous success that manual and automated refactoring has enjoyed during the last de... more Despite the enormous success that manual and automated refactoring has enjoyed during the last decade, we know little about the practice of refactoring. Understanding the refactoring practice is important for developers, refactoring tool builders, and researchers. Many previous approaches to study refactorings are based on comparing code snapshots, which is imprecise, incomplete, and does not allow answering research questions that involve time or compare manual and automated refactoring. We present the first extended empirical study that considers both manual and automated refactoring. This study is enabled by our algorithm, which infers refactorings from continuous changes. We implemented and applied this algorithm to the code evolution data collected from 23 developers working in their natural environment for 1,520 hours. Using a corpus of 5,371 refactorings, we reveal several new facts about manual and automated refactorings. For example, more than a half of the refactorings were performed manually. The popularity of automated and manual refactorings differs. More than one third of the refactorings performed by developers are clustered. For some refactoring kinds, up to 64% of performed refactorings do not reach the Version Control System.

Identifying repetitive code changes benefits developers, tool builders, and researchers. Tool bui... more Identifying repetitive code changes benefits developers, tool builders, and researchers. Tool builders can automate the popular code changes, thus improving the productivity of developers. Researchers would better understand the practice of code evolution, advancing existing code assistance tools even further. Developers would particularly benefit if such tools can learn and support repetitive code changes that are in progress. Unfortunately, the existing tools that aim at detecting frequent code change patterns predominantly focus on analyzing the static source code of an application rather than dynamic code changes, and thus, they can not learn from the changes on-the-fly. We present the first approach that identifies previously unknown frequent code change patterns from a continuous sequence of code changes. Our novel algorithm effectively handles two major challenges that distinguish continuous code change pattern mining from the existing data mining techniques: overlapping transactions and transactions containing multiple instances of the same item kind. We evaluated our algorithm on 1,520 hours of code development collected from 23 developers, and showed that it is effective, useful, and scales to big amounts of data. We analyzed some of the mined code change patterns and discovered ten popular kinds of high level program transformations.

Preprocessors complicate refactoring because refactoring tools must manipulate unpreprocessed cod... more Preprocessors complicate refactoring because refactoring tools must manipulate unpreprocessed code. Working forward from Garrido's work on refactoring preprocessed C [1], we propose a general means by which preprocessor directives can be represented in a syntax tree for an arbitrary language. The representation is simple but general, based on the notions of token-whitetext affixes and substitution tokens. Moreover, we suggest that a preprocessing infrastructure can be completely independent of the language being preprocessed, allowing a single preprocessor to be reused among several refactoring tools and allowing numerous preprocessors to be plugged into a single refactoring tool.

In the multicore era, sequential programs need to be refactored for parallelism. The next version... more In the multicore era, sequential programs need to be refactored for parallelism. The next version of Java provides ParallelArray, an array data structure that supports parallel operations over the array elements. For example, one can apply a procedure to each element, or reduce all elements to a new element in parallel. Refactoring an array to a Paral-lelArray requires (i) analyzing whether the loop iterations are safe for parallel execution, and (ii) replacing loops with the equivalent parallel operations. When done manually, these tasks are non-trivial and time-consuming. We present ReLooper, an Eclipse-based refactoring tool, that performs these tasks automatically. Experience with refactoring real programs shows that ReLooper is useful: it reduces the burden of analyzing and rewriting parallel loops, and it is fast enough to be used interactively.

The documentation for a framework must meet several requirements. These requirements can all be m... more The documentation for a framework must meet several requirements. These requirements can all be met by structuring the documentation as a set of patterns, sometimes called a "pattern language". Patterns can describe the purpose of a framework, can let application programmers use a fmework without having to understand in detail how it works, and can teach many of the design details embodied in the frame work. This paper shows how to use patterns to document a framework, and includes a set ofpatterns forHotDmw as an example. Christopher Alexander, an architect, developed the idea of a "pattern language" to enable people to design their own homes and communities [Alexander et. al.]. A pattern language is a set of patterns, each of which describes how to solve a particular kind of problem. His pattern language starts at a very large scale, explaining how the world should be broken into nations and nations into smaller regions, and goes on to explain how to arrange roads, parking, shopping, places to work, homes, and places of worship. The patterns focus on finer and finer levels of detail, passing though a discussion of how to arrange rooms in a house, and finally describing the type of material to use for walls, how to decorate rooms, and how to provide lighting. Alexander's pattern language is supposed to be a document that non-architects can use to design their own communities and homes. No specialized training is needed to use it. It focuses on common design problems that non-architects will encounter, like how to build bedrooms and row houses, rather than uncommon ones, like how to build concert halls and cathedrals.

Sigplan Notices, Oct 1, 1996

Frameworks and domain-specific visual languages are two different reuse techniques, the first tar... more Frameworks and domain-specific visual languages are two different reuse techniques, the first targeted at expert programmers, the second at domain experts. In fact, these techniques are closely related. This paper shows how to develop a domain-specific visual language by first developing a white-box framework for the domain, then turning it into a black-box framework, and finally building a graphical front end for it. We used this technique in a compiler to specify run-time systems. Research: reuse, components, and frameworks

2009 ICSE Workshop on Software Engineering for Secure Systems, 2009

A security-oriented program transformation maps programs to security-augmented programs, i.e. it ... more A security-oriented program transformation maps programs to security-augmented programs, i.e. it introduces a security solution to make programs more secure. Our previous work defined security-oriented program transformations [6], introduced a catalog of program transformations [8], and showed how program transformations could be applied to systematically eradicate various types of data injection attacks [9]. This paper shows how securityoriented program transformations could be used to improve the security of a system's perimeter by introducing authentication, authorization and input validation components. The program transformation examples in this paper are JAVA specific, but the transformations could be implemented to use other authentication and authorization frameworks.

2015 IEEE/ACM 37th IEEE International Conference on Software Engineering, 2015

Modern integrated development environments (IDEs) make many software engineering tasks easier by ... more Modern integrated development environments (IDEs) make many software engineering tasks easier by providing automated programming support such as code completion and navigation. However, such support-and therefore IDEs as a whole-operate on one revision of the code at a time, and leave handling of code history to external tools or plugins, such as EGit for Eclipse. For example, when a method is removed from a class, developers can no longer find the method through code completion. This forces developers to manually switch across different revisions or resort to using external tools when they need to learn about previous code revisions. We propose a novel approach of adding a temporal dimension to IDEs, enabling code completion and navigation to operate on multiple revisions of code at a time. We previously introduced the idea of temporal code completion and navigation, and presented a vision for how that idea may be realized. This paper realizes that vision by implementing and evaluating a prototype tool called Tempura. We describe our algorithm for processing and indexing historical code information from repositories for Tempura, and demonstrate Tempura's scalability with three large Eclipse projects. We also evaluate Tempura's usability through a controlled user study. The study participants learned about the code history with more accuracy when using Tempura compared to EGit. Although the sample size was not large enough to provide strong statistical significance, the results show a promising outlook for our approach.

ACM SIGPLAN Notices, 1996

Frameworks and domain-specific visual languages are two different reuse techniques, the first tar... more Frameworks and domain-specific visual languages are two different reuse techniques, the first targeted at expert programmers, the second at domain experts. In fact, these techniques are closely related. This paper shows how to develop a domain-specific visual language by first developing a white-box framework for the domain, then turning it into a black-box framework, and finally building a graphical front end for it. We used this technique in a compiler to specify run-time systems.

ACM SIGPLAN Notices, 2001

Many object-oriented information systems share an architectural style that emphasizes flexibility... more Many object-oriented information systems share an architectural style that emphasizes flexibility and run-time adaptability. Business rules are stored externally to the program such as in a database or XML files instead of in code. The object model that the user cares about is part of the database, and the object model of the code is just an interpreter of the users' object model. We call these systems "Adaptive Object-Models", because the users' object model is interpreted at runtime and can be changed with immediate (but controlled) effects on the system interpreting it. The real power in Adaptive Object-Models is that they have a definition of a domain model and rules for its integrity and can be configured by domain experts external to the execution of the program. This paper describes the Adaptive Object-Model architecture along with its strengths and weaknesses. It illustrates the Adaptive Object-Model architectural style by describing a framework for Medical...

2009 IEEE/ACM International Conference on Automated Software Engineering, 2009

ACM SIGPLAN Fortran Forum, 2010

Proceedings 1991 International Workshop on Object Orientation in Operating Systems

We present a method for designing operating systems as an object-oriented framework of generalize... more We present a method for designing operating systems as an object-oriented framework of generalized, abstract components. The framework is specialized into further subframeworks to implement subqystems of the operating system. Each subframework introduces constraints and relationships between the abstract classes of the components. The constraints are inherited by the instantiations of the framework. Choices is an object-oriented operating system designed and implemented using frameworks. In this paper, we explain the application of our design approach to Choices. We describe the following subsystems and their subframeworks: virtual memory, persistent storage, process management, message passing and device management subframeworks. We discuss the advantages and disadvantages of using frameworks to design and implement object-oriented systems. This work was supported in part by NSF grant CISE-1-5-30O35 and by NASA grants NSG l47l and NAG 1-163.

Software Architecture, 2002

We have noticed a common architecture in many systems that emphasize flexibility and run-time con... more We have noticed a common architecture in many systems that emphasize flexibility and run-time configuration. In these systems, business rules are stored externally to the program such as in a database or XML files. The object model that the user cares about is part of the database, and the object model of the code is just an interpreter of the users' object model. We call these systems "Adaptive Object-Models", because the users' object model is interpreted at runtime and can be changed with immediate (but controlled) effects on the system interpreting it. The real power in Adaptive Object-Models is that the definition of a domain model and rules for its integrity can be configured by domain experts external to the execution of the program. These systems are important when flexibility and dynamic runtime configuration is needed, but their architectures have yet to be described in detail. This paper describes the Adaptive Object-Model architecture style along with its strengths and weaknesses. It illustrates the Adaptive Object-Model architectural style by outlining examples of production systems.

Conference proceedings on Object-oriented programming systems, languages and applications, 1988

TS (Typed Smalltalk) is a portable optimizing compiler that produces native machine code for a ty... more TS (Typed Smalltalk) is a portable optimizing compiler that produces native machine code for a typed variant of Smalltalk, making Smalltalk programs much faster. This paper describes the structure of TS, the kinds of optimizations that it performs, the constraints that it places upon Smalltalk, the constraints placed upon it by an interactive programming environment, and its performance.

Proceedings of the 24th ACM SIGPLAN conference companion on Object oriented programming systems languages and applications, 2009

In the multicore era, sequential programs need to be refactored for parallelism. The next version... more In the multicore era, sequential programs need to be refactored for parallelism. The next version of Java provides ParallelArray, an array datastructure that supports parallel operations over the array elements. For example, one can apply a procedure to each element, or reduce all elements to a new element in parallel. Refactoring an array to a ParallelArray requires (i) analyzing whether the loop iterations are safe for parallel execution, and (ii) replacing loops with the equivalent parallel operations. When done manually, these tasks are non-trivial and time-consuming. This demo presents RELOOPER, an Eclipse-based refactoring tool, that performs these tasks automatically. Preliminary experience with refactoring real programs shows that RELOOPER is useful.