Filters








2,518 Hits in 5.5 sec

Safira

Melina Mongiovi
2011 Proceedings of the ACM international conference companion on Object oriented programming systems languages and applications companion - SPLASH '11  
We use Safira to evaluate mutation testing and refactoring tools. We have detected 17 bugs in MuJava, and 27 bugs in refactorings implemented by Eclipse and JRRT.  ...  We propose a tool (Safira) capable of determining if a transformation is behavior preserving through test generation for entities impacted by transformation.  ...  We implemented an Eclipse plug-in -the user selects a refactoring to apply. Then the plug-in reports whether the transformation preserves behavior or not. Soares et al.  ... 
doi:10.1145/2048147.2048213 dblp:conf/oopsla/Mongiovi11 fatcat:zuibvpd5zfgg5bo6qbnpfa35aa

Towards safe refactoring for intelligent parallelization of Java 8 streams

Yiming Tang, Raffi Khatchadourian, Mehdi Bagherzadeh, Syed Ahmed
2018 Proceedings of the 40th International Conference on Software Engineering Companion Proceeedings - ICSE '18  
In this poster, we present our ongoing work and preliminary results towards an automated refactoring approach that assists developers in writing optimal stream code.  ...  The Java 8 Stream API sets forth a promising new programming model that incorporates functional-like, MapReduce-style features into a mainstream programming language.  ...  CONCLUSION & FUTURE WORK We have outlined our work-in-progress towards an automated refactoring approach that "intelligently" optimizes Java 8 stream code.  ... 
doi:10.1145/3183440.3195098 dblp:conf/icse/TangKBA18 fatcat:marf6gqxorcmvh2nwxtgt7lp7y

Correct Refactoring of Concurrent Java Code [chapter]

Max Schäfer, Julian Dolby, Manu Sridharan, Emina Torlak, Frank Tip
2010 Lecture Notes in Computer Science  
Automated refactorings as implemented in modern IDEs for Java usually make no special provisions for concurrent code. Thus, refactored programs may exhibit unexpected new concurrent behaviors.  ...  We analyze the types of such behavioral changes caused by current refactoring engines and develop techniques to make them behavior-preserving, ranging from simple techniques to deal with concurrency-related  ...  Acknowledgements We would like to thank Danny Dig for helpful discussions regarding Concurrencer, Stephen Fink and Dave Grove for valuable pointers to related work, and the anonymous reviewers for their  ... 
doi:10.1007/978-3-642-14107-2_11 fatcat:fwh4jiienfgevem5f3iunbastu

Comparing approaches to analyze refactoring activity on software repositories

Gustavo Soares, Rohit Gheyi, Emerson Murphy-Hill, Brittany Johnson
2013 Journal of Systems and Software  
a refactoring, in terms of behavioral preservation.  ...  They have used different approaches to evaluate refactoring activities.  ...  This work was partially supported by the National Institute of Science and Technology for Software Engineering (INES), funded by CNPq grants 573964/2008-4, 304470/2010-4, and 480160/2011-2.  ... 
doi:10.1016/j.jss.2012.10.040 fatcat:7tc7b77nnnhozicas3od2ipl7a

Making refactoring safer through impact analysis

Melina Mongiovi, Rohit Gheyi, Gustavo Soares, Leopoldo Teixeira, Paulo Borba
2014 Science of Computer Programming  
Moreover, most refactoring implementations contain a number of bugs since it is difficult to establish all conditions required for a transformation to be behavior preserving.  ...  In this article, we propose a tool (SafeRefactorImpact) that analyzes the transformation and generates tests only for the methods impacted by a transformation identified by our change impact analyzer (  ...  Since the tool analyzes the Java bytecode and the AspectJ compiler translates an AspectJ program to Java bytecode, we do not specify laws for AspectJ constructs.  ... 
doi:10.1016/j.scico.2013.11.001 fatcat:ipykrk6olfg43kqlkv2je3t7mq

Identifying overly strong conditions in refactoring implementations

Gustavo Soares, Melina Mongiovi, Rohit Gheyi
2011 2011 27th IEEE International Conference on Software Maintenance (ICSM)  
We propose an approach for identifying overly strong conditions in refactoring implementations. We automatically generate a number of programs as test inputs for refactoring implementations.  ...  We evaluated our approach in 10 kinds of refactorings for Java implemented by three tools: Eclipse and Netbeans, and the JastAdd Refactoring Tool (JRRT).  ...  OVERVIEW In this section, we present an overview of JDolly [12] , a Java program generator, and Safe Refactor [5] . A. JDolly JDolly exhaustively generates a number of Java programs.  ... 
doi:10.1109/icsm.2011.6080784 dblp:conf/icsm/SoaresMG11 fatcat:l522ja4u5jdctfpdva2chg4d2e

On Preserving the Behavior in Software Refactoring: A Systematic Mapping Study [article]

Eman Abdullah AlOmar and Mohamed Wiem Mkaouer and Christian Newman and Ali Ouni
2021 arXiv   pre-print
Objective: This paper identifies behavior preservation approaches in the research literature.  ...  As the concept of behavior preservation is fundamental for refactoring, several studies, using formal verification, language transformation and dynamic analysis, have been proposed to monitor the execution  ...  The implementation of this approach is based on the rewrite logic executable semantics of Java refactorings in Maude language.  ... 
arXiv:2106.13900v2 fatcat:xr7hr7ddzbchlcskg5lre4afoa

Towards purity-guided refactoring in Java

Jiachen Yang, Keisuke Hotta, Yoshiki Higo, Shinji Kusumoto
2015 2015 IEEE International Conference on Software Maintenance and Evolution (ICSME)  
As a case study of our approach, we applied memorization refactoring on several open-source software in Java.  ...  Refactoring source code requires preserving a certain level of semantic behaviors, which are difficult to be checked by IDEs.  ...  In the future, we will develop more refactoring approaches, for example, one converts a singlethreaded sequential program to a thread-pool based multithreading program or an event-driven asynchronized  ... 
doi:10.1109/icsm.2015.7332506 dblp:conf/icsm/YangHHK15 fatcat:6hxoiy4jqjffteyitnhffkznku

Program Slicing for Refactoring: Static Slicer using Dynamic Analyser

Amogh Katti, Sujatha Terdal
2010 International Journal of Computer Applications  
Many slicing algorithms exist in the literature; they first convert the program into some alternative representation and then apply some correctness preserving transformations on it to produce slice and  ...  It exploits the behavior preservation requirement of refactoring and uses the data collected during testing, which we perform prior to refactoring, for slicing.  ...  We proposed our slicing approach that exploits of behavior preservation requirement of refactoring. We used the data collected during testing prior to refactoring to analyze dependencies.  ... 
doi:10.5120/1387-1869 fatcat:hg2ck5zhrbeu5nu7vaowlybvkm

RefaFlex: safer refactorings for reflective Java programs

Andreas Thies, Eric Bodden
2012 Proceedings of the 2012 International Symposium on Software Testing and Analysis - ISSTA 2012  
In this paper we propose RefaFlex, a novel and more defensive approach towards the refactoring of reflective (Java) programs.  ...  RefaFlex uses a dynamic program analysis to log reflective calls during test runs and then uses this information to proactively prevent the programmer from executing refactorings that could otherwise alter  ...  We wish to thank Marcus Frenkel, Mira Mezini, Andreas Sewe, Jan Sinschek, and Friedrich Steimann for their comments, which greatly helped us improve an initial draft of this paper.  ... 
doi:10.1145/2338965.2336754 dblp:conf/issta/ThiesB12 fatcat:xelesc5tmfdjxdcx3dqjpqun7e

Scaling testing of refactoring engines

Melina Mongiovi
2016 Proceedings of the 38th International Conference on Software Engineering Companion - ICSE '16  
Therefore, refactoring engines may apply incorrect transformations in which the resulting program does not compile, preserve behavior, or follow the refactoring definitions.  ...  Defining and implementing refactorings is a nontrivial task since it is difficult to define preconditions to guarantee that the transformation preserves the program behavior.  ...  In our previous work [13] , we used an approach similar to the approach proposed by Jagannath et al.  ... 
doi:10.1145/2889160.2891038 dblp:conf/icse/Mongiovi16 fatcat:mmib7xlvlva4tggw7qxfroqj2u

Scaling testing of refactoring engines

Melina Mongiovi
2016 Companion Proceedings of the 2016 ACM SIGPLAN International Conference on Systems, Programming, Languages and Applications: Software for Humanity - SPLASH Companion 2016  
Therefore, refactoring engines may apply incorrect transformations in which the resulting program does not compile, preserve behavior, or follow the refactoring definitions.  ...  Defining and implementing refactorings is a nontrivial task since it is difficult to define preconditions to guarantee that the transformation preserves the program behavior.  ...  In our previous work [13] , we used an approach similar to the approach proposed by Jagannath et al.  ... 
doi:10.1145/2984043.2984048 dblp:conf/oopsla/Mongiovi16 fatcat:hmaj2ctpmfhqfpa5ugick4gxoy

Towards improving interface modularity in legacy Java software through automated refactoring

Raffi Khatchadourian, Olivia Moore, Hidehiko Masuhara
2016 Companion Proceedings of the 15th International Conference on Modularity - MODULARITY Companion 2016  
We argue that both these benefits improve software modularity, and discuss our ongoing work in developing an automated refactoring tool that would assist developers in taking advantage of the enhanced  ...  Java classes are then free to extend a different class, and a separate abstract class is no longer needed; developers considering implementing an interface need only examine the interface itself.  ...  Our tool must perform a semantics-preserving source-to-source transformation of existing Java programs in an efficient, error-free, and omission-free way.  ... 
doi:10.1145/2892664.2892681 dblp:conf/aosd/KhatchadourianM16 fatcat:s3bdv5d3nfff5gcjvklsux5gtm

Refactoring for reentrancy

Jan Wloka, Manu Sridharan, Frank Tip
2009 Proceedings of the 7th joint meeting of the European software engineering conference and the ACM SIGSOFT symposium on The foundations of software engineering on European software engineering conference and foundations of software engineering symposium - ESEC/FSE '09  
We present a mostly-automated refactoring that makes such programs reentrant by replacing global state with thread-local state and performing each execution in a fresh thread.  ...  We implemented this refactoring in Reentrancer, a practical Eclipsebased tool. Reentrancer successfully eliminated observed reentrancy problems in five single-threaded Java benchmarks.  ...  This leads to an approach of correctness before performance when moving software to multicores (also espoused elsewhere [6] ): the refactoring produces an obviously reentrant program (i.e., one with no  ... 
doi:10.1145/1595696.1595723 dblp:conf/sigsoft/WlokaST09 fatcat:crfa3ih73bdehepbiznzqff5ou

Model-driven Java code refactoring

Sohaib Hamioud, Fadila Atil
2015 Computer Science and Information Systems  
The presented approach is applied to the refactoring of Java code using a prototypical implementation based on the Eclipse Modeling Framework, a language workbench, a Java metamodel and a set of OMG standards  ...  Refactoring is an important technique for restructuring code to improve its design and increase programmer productivity and code reuse.  ...  Schäfer' approach addresses the preservation of program behavior as a dependence edge preservation problem [23] , [24] , and uses constraints to control accessibility adjustments [26] .  ... 
doi:10.2298/csis141025015h fatcat:rlcw245n4zbctiswcrtrocwcmu
« Previous Showing results 1 — 15 out of 2,518 results