Mohsen Vakilian

University of Illinois, Urbana-Champaign, Urbana, Illinois, United States

Are you Mohsen Vakilian?

Claim your profile

Publications (15)0.71 Total impact

  • Mohsen Vakilian, Ralph E. Johnson
    05/2014;
  • [Show abstract] [Hide abstract]
    ABSTRACT: Recent studies suggest that programmers greatly underuse refactoring tools, especially for complex refactorings. Complex refactorings tend to be tedious and error-prone to perform by hand. To promote the use of refactoring tools for complex changes, we propose a new paradigm for automating refactorings called compositional refactoring. The key idea is to perform small, predictable changes using a tool and manually compose them into complex changes. This paradigm trades off some level of automation by higher predictability and control. We show that this paradigm is natural, because our analysis of programmers' use of the Eclipse refactoring tool in the wild shows that they frequently batch and compose automated refactorings. We then show that programmers are receptive to this new paradigm through a survey of 100 respondents. Finally, we show that the compositional paradigm is effective through a controlled study of 13 professional programmers, comparing this paradigm to the existing wizard-based one.
    Proceedings of the 27th European conference on Object-Oriented Programming; 07/2013
  • [Show abstract] [Hide abstract]
    ABSTRACT: 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 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 in time. On average, 30% of the performed refactorings do not reach the Version Control System.
    Proceedings of the 27th European conference on Object-Oriented Programming; 07/2013
  • Mohsen Vakilian
    [Show abstract] [Hide abstract]
    ABSTRACT: The classical PCP theorem is arguably the most important achievement of classical complexity theory in the past quarter century. In recent years, researchers in quantum computational complexity have tried to identify approaches and develop tools that ...
    ACM SIGACT News 06/2013; 44(2):10-12.
  • [Show abstract] [Hide abstract]
    ABSTRACT: 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?
    Proceedings of the 26th European conference on Object-Oriented Programming; 06/2012
  • [Show abstract] [Hide abstract]
    ABSTRACT: Though refactoring tools have been available for more than a decade, research has shown that programmers underutilize such tools. However, little is known about why programmers do not take advantage of these tools. We have conducted a field study on programmers in their natural settings working on their code. As a result, we collected a set of interaction data from about 1268 hours of programming using our minimally intrusive data collectors. Our quantitative data show that programmers prefer lightweight methods of invoking refactorings, usually perform small changes using the refactoring tool, proceed with an automated refactoring even when it may change the behavior of the program, and rarely preview the automated refactorings. We also interviewed nine of our participants to provide deeper insight about the patterns that we observed in the behavioral data. We found that programmers use predictable automated refactorings even if they have rare bugs or change the behavior of the program. This paper reports some of the factors that affect the use of automated refactorings such as invocation method, awareness, naming, trust, and predictability and the major mismatches between programmers' expectations and automated refactorings. The results of this work contribute to producing more effective tools for refactoring complex software.
    Proceedings - International Conference on Software Engineering 01/2012;
  • Source
    [Show abstract] [Hide abstract]
    ABSTRACT: Developing concurrent software is error prone. Others have cataloged common bug patterns in concurrent Java programs. But, there are no tools for detecting complex concurrency bug patterns accurately, and concurrent programs are full of similar bugs. We have been developing a tool called Keshmesh for detecting complex concurrency bug patterns in Java programs statically. Keshmesh is the first tool that accurately detects a few of the top concurrency bug patterns of the SEI CERT catalog [3] and suggests automated fixers for some of them. Keshmesh is fast enough to be used interactively, produces few false alarms and helps Java programmers to quickly find and fix common concurrency bug patterns in their programs.
    Companion to the 26th Annual ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications, OOPSLA 2011, part of SPLASH 2011, Portland, OR, USA, October 22 - 27, 2011; 01/2011
  • Source
    [Show abstract] [Hide abstract]
    ABSTRACT: Even though modern Integrated Development Environments (IDEs) support many refactorings, studies suggest that automated refactorings are used infrequently, and few developers use anything beyond Rename and Extract refactorings. Little is known about why automated refactorings are seldom used. We present a list of challenging questions whose answers are crucial for understanding the usability issues of refactoring tools. This paper argues that the existing data sources - Eclipse UDC, Eclipse refactoring histories, version control histories, etc. - are inadequate for answering these questions. Finally, we introduce our tools to collect richer usage data that will enable us to answer some of the open research questions about the usability of refactoring tools. Findings from our data will foster the design of the next generation of refactoring tools.
    01/2011;
  • Source
    [Show abstract] [Hide abstract]
    ABSTRACT: Effect systems are important for reasoning about the side effects of a program. Although effect systems have been around for decades, they have not been widely adopted in practice because of the large number of annotations that they require. A tool that infers effects automatically can make effect systems practical. We present an effect inference algorithm and an Eclipse plug-in, DPJizer, which alleviate the burden of writing effect annotations for a language called Deterministic Parallel Java (DPJ). The key novel feature of the algorithm is the ability to infer effects on nested heap regions. Besides DPJ, we also illustrate how the algorithm can be used for a different effect system based on object ownership. Our experience shows that DPJizer is both useful and effective: (i) inferring effect annotations automatically saves significant programming burden; and (ii) inferred effects are more precise than those written manually, and are fine-grained enough to enable the compiler to prove determinism of the program. NSF grant 07-02724 NSF grant 07-20772 NSF grant 08-33128 NSF grant 08-33188 Microsoft and Intel through UPCRC Illinois published or submitted for publication is peer reviewed
    01/2009;
  • Source
    [Show abstract] [Hide abstract]
    ABSTRACT: Today's shared-memory parallel programming models are complex and error-prone. While many parallel programs are intended to be deterministic, unanticipated thread interl eav- ings can lead to subtle bugs and nondeterministic semantics. In this paper, we demonstrate that a practical type and ef- fect system can simplify parallel programming by guarantee- ing deterministic semanticswith modular, compile-time type checking even in a rich, concurrent object-oriented language such as Java. We describe an object-oriented type and effect system that provides several new capabilities over previous systems for expressing deterministic parallel algorithms . We also describe a language called Deterministic Parallel Java (DPJ) that incorporates the new type system features, and we show that a core subset of DPJ is sound. We describe an experimental validation showing that DPJ can express a wide range of realistic parallel programs; that the new type syst em features are useful for such programs; and that the parallel programs exhibit good performance gains (coming close to or beating equivalent, nondeterministic multithreaded pro- grams where those are available).
    Proceedings of the 24th Annual ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications, OOPSLA 2009, October 25-29, 2009, Orlando, Florida, USA; 01/2009
  • Source
    [Show abstract] [Hide abstract]
    ABSTRACT: In this paper we propose an approach to derive the formal semantics of WS-BPEL processes compositionally using Reo and constraint automata. We map each WS-BPEL process into a Reo circuit and then construct the corresponding constraint automaton which shows the behavior of the process. The constraint automaton can be used for analyzing the process behavior. Our work covers the core part of the WS-BPEL language including basic and structured activities, correlation sets, variables, and links.
    Web Services and Formal Methods, 4th International Workshop, WS-FM 2007, Brisbane, Australia, September 28-29, 2007. Proceedings; 01/2007
  • Source
    [Show abstract] [Hide abstract]
    ABSTRACT: In the multicores era, parallel programming will become mainstream. However, the dominant model of concur-rency is based on threads that share memory. Program-ming in this model is too error prone due to nondeter-ministic thread interleaving. A deterministic-by-default model like the one used in Deterministic Parallel Java (DPJ) can make parallel programming synonymous with programming. DPJ's type system guarantees that a par-allel program is deterministic. In order to benefit from the advantages of a deterministic parallel model, the DPJ programmer needs to write anno-tations that specify the shared data and the side-effects of methods. Manually writing such annotations is tedious. We developed an Eclipse plugin, DPJizer, that alleviates the burden of writing such annotations. Given a program annotated with shared-data information, DPJizer infers the side-effects as method effect summaries. Preliminary ex-perience with inferring effect annotations in real programs shows that DPJizer is useful and effective: DPJizer correctly inferred all annotations, and DPJizer is more precise than a human.
  • Source
    [Show abstract] [Hide abstract]
    ABSTRACT: Today's shared-memory parallel programming models are complex and error-prone.While many parallel programs are intended to be deterministic, unanticipated thread interleavings can lead to subtle bugs and nondeterministic semantics. In this paper, we demonstrate that a practical type and effect system can simplify parallel programming by guaranteeing deterministic semantics with modular, compile-time type checking even in a rich, concurrent object-oriented language such as Java. We describe an object-oriented type and effect system that provides several new capabilities over previous systems for expressing deterministic parallel algorithms.We also describe a language called Deterministic Parallel Java (DPJ) that incorporates the new type system features, and we show that a core subset of DPJ is sound. We describe an experimental validation showing thatDPJ can express a wide range of realistic parallel programs; that the new type system features are useful for such programs; and that the parallel programs exhibit good performance gains (coming close to or beating equivalent, nondeterministic multithreaded programs where those are available).
    ACM SIGPLAN Notices 44(10):97-116. · 0.71 Impact Factor
  • [Show abstract] [Hide abstract]
    ABSTRACT: 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.
  • Source
    [Show abstract] [Hide abstract]
    ABSTRACT: We describe a type and effect system for ensuring deterministic se-mantics in a concurrent object-oriented language. Our system pro-vides several new capabilities over previous work, including sup-port for linear arrays (important in parallel update traversals), flex-ible effect specifications and subtyping (important for, e.g., tree-based algorithms), dynamic partitioning into subarrays (important for divide-and-conquer algorithms), and a novel invocation effect for handling higher-level commutative operations such as set in-sert. We informally describe the key type system features, formally define a core subset of our system, and explain the steps leading to the key soundness result, i.e., that the type and effect annotations allow us to reason soundly about parallel noninterference between sections of code. Finally, we describe our experience with using the system to express realistic parallel algorithms, which validates the importance of the new type system features.