Academic literature on the topic 'Support Code Refactorings'
Create a spot-on reference in APA, MLA, Chicago, Harvard, and other styles
Consult the lists of relevant articles, books, theses, conference reports, and other scholarly sources on the topic 'Support Code Refactorings.'
Next to every source in the list of references, there is an 'Add to bibliography' button. Press on it, and we will generate automatically the bibliographic reference to the chosen work in the citation style you need: APA, MLA, Harvard, Chicago, Vancouver, etc.
You can also download the full text of the academic publication as pdf and read online its abstract whenever available in the metadata.
Journal articles on the topic "Support Code Refactorings"
1
Hamioud, Sohaib, and Fadila Atil. "Model-driven Java code refactoring." Computer Science and Information Systems 12, no. 2 (2015): 375–403. http://dx.doi.org/10.2298/csis141025015h.
Full textAbstract:
Refactoring is an important technique for restructuring code to improve its design and increase programmer productivity and code reuse. Performing refactorings manually, however, is tedious, time consuming and error-prone. Thus, providing an automated support for them is necessary. Unfortunately even in our days, such automation is still not easily achieved and requires formal specifications of the refactoring process. Moreover, extensibility and tool development automation are factors that should be taken into consideration when designing and implementing automated refactorings. In this paper, we introduce a model-driven approach where refactoring features, such as code representation, analysis and transformation adopt models as first-class artifacts. We aim at exploring the value of model transformation and code generation when formalizing refactorings and developing tool support. 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.
2
THOMPSON, SIMON, and HUIQING LI. "Refactoring tools for functional languages." Journal of Functional Programming 23, no. 3 (May 2013): 293–350. http://dx.doi.org/10.1017/s0956796813000117.
Full textAbstract:
AbstractRefactoring is the process of changing the design of a program without changing what it does. Typical refactorings, such as function extraction and generalisation, are intended to make a program more amenable to extension, more comprehensible and so on. Refactorings differ from other sorts of program transformation in being applied to source code, rather than to a ‘core’ language within a compiler, and also in having an effect across a code base, rather than to a single function definition, say. Because of this, there is a need to give automated support to the process. This paper reflects on our experience of building tools to refactor functional programs written in Haskell (HaRe) and Erlang (Wrangler). We begin by discussing what refactoring means for functional programming languages, first in theory, and then in the context of a larger example. Next, we address system design and details of system implementation as well as contrasting the style of refactoring and tooling for Haskell and Erlang. Building both tools led to reflections about what particular refactorings mean, as well as requiring analyses of various kinds, and we discuss both of these. We also discuss various extensions to the core tools, including integrating the tools with test frameworks; facilities for detecting and eliminating code clones; and facilities to make the systems extensible by users. We then reflect on our work by drawing some general conclusions, some of which apply particularly to functional languages, while many others are of general value.
3
VAN HORN, DAVID, and MATTHEW MIGHT. "Systematic abstraction of abstract machines." Journal of Functional Programming 22, no. 4-5 (August 15, 2012): 705–46. http://dx.doi.org/10.1017/s0956796812000238.
Full textAbstract:
AbstractWe describe a derivational approach to abstract interpretation that yields novel and transparently sound static analyses when applied to well-established abstract machines for higher-order and imperative programming languages. To demonstrate the technique and support our claim, we transform the CEK machine of Felleisen and Friedman (Proc. of the 14th ACM SIGACT-SIGPLAN Symp. Prin. Program. Langs, 1987, pp. 314–325), a lazy variant of Krivine's machine (Higher-Order Symb. Comput. Vol 20, 2007, pp. 199–207), and the stack-inspecting CM machine of Clements and Felleisen (ACM Trans. Program. Lang. Syst. Vol 26, 2004, pp. 1029–1052) into abstract interpretations of themselves. The resulting analyses bound temporal ordering of program events; predict return-flow and stack-inspection behavior; and approximate the flow and evaluation of by-need parameters. For all of these machines, we find that a series of well-known concrete machine refactorings, plus a technique of store-allocated continuations, leads to machines that abstract into static analyses simply by bounding their stores. These machines are parameterized by allocation functions that tune performance and precision and substantially expand the space of analyses that this framework can represent. We demonstrate that the technique scales up uniformly to allow static analysis of realistic language features, including tail calls, conditionals, mutation, exceptions, first-class continuations, and even garbage collection. In order to close the gap between formalism and implementation, we provide translations of the mathematics as running Haskell code for the initial development of our method.
4
Szőke, Gábor. "Automating the Refactoring Process." Acta Cybernetica 23, no. 2 (2017): 715–35. http://dx.doi.org/10.14232/actacyb.23.2.2017.16.
Full textAbstract:
To decrease software maintenance cost, software development companies use static source code analysis techniques. Static analysis tools are capable of finding potential bugs, anti-patterns, coding rule violations, and they can also enforce coding style standards. Although there are several available static analyzers to choose from, they only support issue detection. The elimination of the issues is still performed manually by developers. Here, we propose a process that supports the automatic elimination of coding issues in Java. We introduce a tool that uses a third-party static analyzer as input and enables developers to automatically fix the detected issues for them. Our tool uses a special technique, called reverse AST-search, to locate source code elements in a syntax tree, just based on location information. Our tool was evaluated and tested in a two-year project with six software development companies where thousands of code smells were identified and fixed in five systems that have altogether over five million lines of code.
5
Mei, Xin Yun, and Jian Bin Liu. "A Refactoring Framework of Program Model Based on Procedure Blueprint." Applied Mechanics and Materials 198-199 (September 2012): 490–94. http://dx.doi.org/10.4028/www.scientific.net/amm.198-199.490.
Full textAbstract:
Refactoring has been studied for a long time, especially model refactoring has become the hot spot of research in recent years. However, the difference between source-based refactoring and model-based refactoring makes it hard to keep consistent between the target code and model refactoring operations. To resolve the problem, this paper presents a refactoring framework of program model based on Procedure Blueprint and gives the prototyping tool system of program model refactoring. Through seamless connection source code established by procedure blueprint to program model，the formalized framework unified the refactoring of source-based and program model based. The refactoring framework supports the visualization representation of program model and the validation for behavior preservation of graphics transformation, which reduces the complexity of refactoring analysis and software maintenance costs.
6
Sagar, Priyadarshni Suresh, Eman Abdulah AlOmar, Mohamed Wiem Mkaouer, Ali Ouni, and Christian D. Newman. "Comparing Commit Messages and Source Code Metrics for the Prediction Refactoring Activities." Algorithms 14, no. 10 (September 30, 2021): 289. http://dx.doi.org/10.3390/a14100289.
Full textAbstract:
Understanding how developers refactor their code is critical to support the design improvement process of software. This paper investigates to what extent code metrics are good indicators for predicting refactoring activity in the source code. In order to perform this, we formulated the prediction of refactoring operation types as a multi-class classification problem. Our solution relies on measuring metrics extracted from committed code changes in order to extract the corresponding features (i.e., metric variations) that better represent each class (i.e., refactoring type) in order to automatically predict, for a given commit, the method-level type of refactoring being applied, namely Move Method, Rename Method, Extract Method, Inline Method, Pull-up Method, and Push-down Method. We compared various classifiers, in terms of their prediction performance, using a dataset of 5004 commits and extracted 800 Java projects. Our main findings show that the random forest model trained with code metrics resulted in the best average accuracy of 75%. However, we detected a variation in the results per class, which means that some refactoring types are harder to detect than others.
7
Ferenzini Martins Sirqueira, Tassio, Allan Henrique Moreira Brandl, Evandro Jose Pereira Pedro, Ramon de Souza Silva, and Marco Antonio Pereira Araujo. "Code Smell Analyzer: A Tool To Teaching Support Of Refactoring Techniques Source Code." IEEE Latin America Transactions 14, no. 2 (February 2016): 877–84. http://dx.doi.org/10.1109/tla.2016.7437235.
Full text
8
Ivanov, R. A., and T. F. Valeev. "Automatic Refactoring of Java Code Using the Stream API." Vestnik NSU. Series: Information Technologies 17, no. 2 (2019): 49–60. http://dx.doi.org/10.25205/1818-7900-2019-17-2-49-60.
Full textAbstract:
For a long time, functional Java programming was not possible. However, lambda expressions appeared in version 8 of the Java language. Due to the support of standard library classes (Stream, Optional, etc.) in Java, it became possible to describe transformations over data in a functional style. Java is a rather old language with a large imperative code base written in it. In order to take advantage of the new approach, it is necessary to perform a non-trivial refactoring, which can be very tedious and error prone when applied manually. Fortunately, for a sufficiently large number of situations, this refactoring can be safely performed automatically. Using IntelliJ Idea as a platform software tool was developed that allows you to find places where it is possible to automatically convert an imperative code to an equivalent code that uses Stream API, as well as an automatic fix that allows you to make a replacement. Refactoring uses IntelliJ Idea framework to analyze Java code, and integrates into the IDE itself. One of the main criteria for the correct operation of the algorithm is the security of this transformation. The user cannot trust the tool if the transformation can change the semantics of the code. This article discusses various constraints that are imposed on code patterns so that transformation without distortion of semantics is possible. Refactoring has been tested in various libraries to verify the semantics are preserved by checking the test results before and after applying refactoring. This article will not describe the impact of using the Stream API on the performance of the application.
9
Tkachuk, Andrii, and Bogdan Bulakh. "Research of possibilities of default refactoring actions in Swift language." Technology audit and production reserves 5, no. 2(67) (October 24, 2022): 6–10. http://dx.doi.org/10.15587/2706-5448.2022.266061.
Full textAbstract:
The object of research in the paper is a built-in refactoring mechanism in the Swift programming language. Swift has gained a lot of popularity recently, which is why there are many new challenges associated with the need to support and modify the source code written in this programming language. The problem is that the more powerful refactoring mechanism that can be applied to Swift is proprietary and cannot be used by other software. Moreover, even closed-source refactoring software tools are not capable of performing more complex queries. To explore the possibilities of expanding the built-in refactoring, it is suggested to investigate the software implementation of the sourcekit component of the Swift programming language, which is responsible for working with «raw» source code, and to implement new refactoring action in practice. To implement the research plan, one refactoring activity that was not present in the refactoring utilities (adding an implementation of the Equatable protocol) was chosen. Its implementation was developed using the components and resources provided within the sourcekit component. To check the correctness and compliance with the development conditions, several tests were created and conducted. It has been discovered that both refactoring mechanisms supported by the Swift programming language have a limited context and a limited scope and application. That is why the possibility of expanding the functionality should not be based on the local level of code processing, but on the upper level, where it is possible to combine several source files, which often happens in projects. The work was directed to the development of the own refactoring action to analyze and obtain a perfect representation of the advantages and disadvantages of the existing component. As a result, a new approach to refactoring was proposed, which will allow solving the problems described above.
10
Ying, Ming, and James Miller. "ART-Improving Execution Time for Flash Applications." International Journal of Systems and Service-Oriented Engineering 2, no. 1 (January 2011): 1–20. http://dx.doi.org/10.4018/jssoe.2011010101.
Full textAbstract:
Rich Internet Applications (RIA) require fast execution time and allow richer, faster, and more interactive experiences. Flash is a common technology for building RIAs. Flash programmers usually specialize in graphic design rather than programming. In addition, the tight schedule of projects makes the Flash programmers ignore non-functional characteristics such as the efficiency of their systems; yet, to enhance Flash users’ experiences, writing efficient ActionScript code is a key requirement. Flash programmers require automated support to assist with this key requirement. This paper proposes a refactoring system called ART (ActionScript Refactoring Tool) to provide automatic support for Flash programmers by rewriting their ActionScript code to make their applications faster.
Dissertations / Theses on the topic "Support Code Refactorings"
1
Newman, Christian D. "A SOURCE CODE TRANSFORMATION LANGUAGE TO SUPPORT SOFTWARE EVOLUTION." Kent State University / OhioLINK, 2017. http://rave.ohiolink.edu/etdc/view?acc_num=kent1500560236029486.
Full text
2
Rama, Girish Maskeri. "Program Analyses to Support Memory-saving Refactorings in Java Programs." Thesis, 2017. https://etd.iisc.ac.in/handle/2005/4686.
Full textAbstract:
Software commonly consumes unexpectedly high amounts of memory, frequently due to programming idioms that are used to make software more reliable, maintainable and understandable. In the case of modern object-oriented systems this problem is partly due to creation of large numbers of co-existing isomorphic objects. Intuitively, two objects are isomorphic if they are of the same type, have identical values in corresponding primitive fields, and are such that corresponding reference fields themselves point to isomorphic objects. In other words, the portions of memory rooted at the two objects are isomorphic shape-wise as well as values-wise. A significant reduction in heap usage can therefore be achieved if the code is refactored to de-duplicate or share objects whenever possible instead of always creating distinct but possibly isomorphic objects. Such a refactoring, which employs a cache to keep track of objects created so far and to share them, is termed as object-sharing refactoring. In practice, object-sharing refactoring is commonly used, as it has the potential to reduce memory utilization significantly. However, manual refactoring is tedious and error prone.
To support object-sharing refactoring we have (1) designed and implemented an approach to estimate memory-savings potential due to this refactoring, (2) espoused the idea of full initialization points of objects, and a static analysis to identify these points, and (3) proposed a
scalable refinement-based points-to analysis for verifying the safety of object-sharing refactoring, but which has general applicability to several other verification tasks as well.
1) We present a dynamic analysis technique for estimating for all the allocation sites in a program, for a given input, the reduction in heap memory usage (in bytes, or as a percentage) to be obtained by employing object sharing at each site. The quantitative estimates produced by our technique of a user-observable benefit (i.e., actual memory savings) make it easier for developers to select sites to refactor. Experimentation with our estimation tool on real Java programs indicate that nearly all applications have potential for reduction of memory usage by object sharing, with a mean savings of 12.62% per benchmark.
(2) We define a novel concept termed full-initialization points (FIPs) to characterize the points in the program where objects allocated at any chosen allocation site become fully initialized. We present a novel and conservative static analysis to detect FIPs for a given allocation site. By introducing code to cache and share objects at the FIPs suggested by our analysis, object-sharing refactoring was able to obtain a mean memory savings of 11.4% on a set of real Java benchmarks.
(3) A standard points-to analysis approach, namely, the object sensitivity approach, uses an equal level of precision to represent symbolic objects allocated at all allocation sites in a program. This approach does not scale to large programs unless low levels of precision are used. We propose a novel, program-slicing based approach to improve the precision of object sensitivity analysis to answer user queries more precisely. Our slicing technique differs from most standard techniques for context-sensitive slicing of Java programs, which are based on system dependence graphs and which do not scale readily to larger programs. Our evaluation reveals that for a given time budget (6 hours per benchmark), our approach gives more precise results than the most precise results possible under the baseline object sensitivity analysis on nine of the 10 DaCapo benchmarks. Our approach exhibits 28% greater precision over the baseline object sensitivity approach in identifying allocation sites where object-sharing refactoring can be performed.
Book chapters on the topic "Support Code Refactorings"
1
Higo, Yoshiki, Toshihiro Kamiya, Shinji Kusumoto, and Katsuro Inoue. "Refactoring Support Based on Code Clone Analysis." In Product Focused Software Process Improvement, 220–33. Berlin, Heidelberg: Springer Berlin Heidelberg, 2004. http://dx.doi.org/10.1007/978-3-540-24659-6_16.
Full text
2
Steinhöfel, Dominic. "Ever Change a Running System: Structured Software Reengineering Using Automatically Proven-Correct Transformation Rules." In Ernst Denert Award for Software Engineering 2020, 197–226. Cham: Springer International Publishing, 2022. http://dx.doi.org/10.1007/978-3-030-83128-8_10.
Full textAbstract:
AbstractLegacy systems are business-critical software systems whose failure can have a significant impact on the business. Yet, their maintenance and adaption to changed requirements consume a considerable amount of the total software development costs. Frequently, domain experts and developers involved in the original development are not available anymore, making it difficult to adapt a legacy system without introducing bugs or unwanted behavior. This results in a dilemma: businesses are reluctant to change a working system, while at the same time struggling with its high maintenance costs. We propose the concept of Structured Software Reengineering replacing the ad hoc forward engineering part of a reengineering process with the application of behavior-preserving, proven-correct transformations improving nonfunctional program properties. Such transformations preserve valuable business logic while improving properties such as maintainability, performance, or portability to new platforms. Manually encoding and proving such transformations for industrial programming languages, for example, in interactive proof assistants, is a major challenge requiring deep expert knowledge. Existing frameworks for automatically proving transformation rules have limited expressiveness and are restricted to particular target applications such as compilation or peep-hole optimizations. We present Abstract Execution, a specification and verification framework for statement-based program transformation rules on JAVA programs building on symbolic execution. Abstract Execution supports universal quantification over statements or expressions and addresses properties about the (big-step) behavior of programs. Since this class of properties is useful for a plethora of applications, Abstract Execution bridges the gap between expressiveness and automation. In many cases, fully automatic proofs are in possible. We explain REFINITY, a workbench for modeling and proving statement-level JAVA transformation rules, and discuss our applications of Abstract Execution to code refactoring, cost analysis of program transformations, and transformations reshaping programs for the application of parallel design patterns.
3
Ying, Ming, and James Miller. "ART-Improving Execution Time for Flash Applications." In Mobile and Web Innovations in Systems and Service-Oriented Engineering, 1–22. IGI Global, 2013. http://dx.doi.org/10.4018/978-1-4666-2470-2.ch001.
Full textAbstract:
Rich Internet Applications (RIA) require fast execution time and allow richer, faster, and more interactive experiences. Flash is a common technology for building RIAs. Flash programmers usually specialize in graphic design rather than programming. In addition, the tight schedule of projects makes the Flash programmers ignore non-functional characteristics such as the efficiency of their systems; yet, to enhance Flash users’ experiences, writing efficient ActionScript code is a key requirement. Flash programmers require automated support to assist with this key requirement. This paper proposes a refactoring system called ART (ActionScript Refactoring Tool) to provide automatic support for Flash programmers by rewriting their ActionScript code to make their applications faster.
4
Rech, Jörg. "Handling of Software Quality Defects in Agile Software Development." In Software Applications, 242–65. IGI Global, 2009. http://dx.doi.org/10.4018/978-1-60566-060-8.ch020.
Full textAbstract:
Software quality assurance is concerned with the efficient and effective development of large, reliable, and high-quality software systems. In agile software development and maintenance, refactoring is an important phase for the continuous improvement of a software system by removing quality defects like code smells. As time is a crucial factor in agile development, not all quality defects can be removed in one refactoring phase (especially in one iteration). Documentation of quality defects that are found during automated or manual discovery activities (e.g., pair programming) is necessary to avoid wasting time by rediscovering them in later phases. Unfortunately, the documentation and handling of existing quality defects and refactoring activities is a common problem in software maintenance. To recall the rationales why changes were carried out, information has to be extracted from either proprietary documentations or software versioning systems. In this chapter, we describe a process for the recurring and sustainable discovery, handling, and treatment of quality defects in software systems. An annotation language is presented that is used to store information about quality defects found in source code and that represents the defect and treatment history of a part of a software system. The process and annotation language can not only be used to support quality defect discovery processes, but is also applicable in testing and inspection processes.
5
Tappenden, A. F., T. Huynh, J. Miller, A. Geras, and M. Smith. "Agile Development of Secure Web-Based Applications." In Integrated Approaches in Information Technology and Web Engineering, 257–77. IGI Global, 2009. http://dx.doi.org/10.4018/978-1-60566-418-7.ch017.
Full textAbstract:
This article outlines a four-point strategy for the development of secure Web-based applications within an agile development framework and introduces strategies to mitigate security risks that are commonly present in Web-based applications. The proposed strategy includes the representation of security requirements as test cases supported by the open source tool FIT, the deployment of a highly testable architecture allowing for security testing of the application at all levels, the outlining of an extensive security testing strategy supported by the open source unit-testing framework HTTPUnit, and the introduction of the novel technique of security refactoring that transforms insecure working code into a functionally-equivalent secure code. Today, many Web-based applications are not secure, and limited literature exists concerning the use of agile methods within this domain. It is the intention of this article to further discussions and research regarding the use of an agile methodology for the development of secure Web-based applications.
Conference papers on the topic "Support Code Refactorings"
1
Brito, Rodrigo, and Marco Tulio Valente. "RAID: Tool Support for Refactoring-Aware Code Reviews." In Congresso Brasileiro de Software: Teoria e Prática. Sociedade Brasileira de Computação - SBC, 2022. http://dx.doi.org/10.5753/cbsoft_estendido.2022.224945.
Full textAbstract:
Code review is a key development practice that contributes to improve software quality and to foster knowledge sharing among developers. However, code review usually takes time and demands detailed and time-consuming analysis of textual diffs. Particularly, detecting refactorings during code reviews is not a trivial task, since they are not explicitly represented in diffs. For example, a Move Function refactoring is represented by deleted (-) and added lines (+) of code which can be located in different and distant source code files. To tackle this problem, we introduce RAID, a refactoring-aware and intelligent diff tool. Besides proposing an architecture for RAID, we implemented a Chrome browser plug-in that supports our solution. Then, we conducted a field experiment with eight professional developers who used RAID for three months. We concluded that RAID can reduce the cognitive effort required for detecting and reviewing refactorings in textual diff. Besides documenting refactorings in diffs, RAID reduces the number of lines required for reviewing such operations. For example, the median number of lines to be reviewed decreases from 14.5 to 2 lines in the case of move refactorings and from 113 to 55 lines in the case of extractions.
2
Rama, Girish Maskeri, and Raghavan Komondoor. "A dynamic analysis to support object-sharing code refactorings." In ASE '14: ACM/IEEE International Conference on Automated Software Engineering. New York, NY, USA: ACM, 2014. http://dx.doi.org/10.1145/2642937.2642992.
Full text
3
Bibiano, Ana Carla, and Alessandro Garcia. "On the Characterization, Detection and Impact of Batch Refactoring in Practice." In XI Congresso Brasileiro de Software: Teoria e Prática. Sociedade Brasileira de Computação - SBC, 2020. http://dx.doi.org/10.5753/cbsoft_estendido.2020.14626.
Full textAbstract:
Up to 60% of the refactorings in software projects are constituted of a set of interrelated transformations, the so-called batches (or composite refactoring), rather than single transformations applied in isolation. However, a systematic characterization of batch characterization is missing, which hampers the elaboration of proper tooling support and empirical studies of how (batch) refactoring is applied in practice. This paper summarizes the research performed under the context of a Master's dissertation, which aimed at taming the aforementioned problems. To the best of our knowledge, our research is the first work published that provides a conceptual foundation, detection support and an large impact analysis of batch refactoring on code maintainability. To this end, we performed two complementary empirical studies as well as designed a first heuristic aimed at explicitly detecting batch refactorings. Our first study consisted of a literature review that synthesizes the otherwise scattered, partial conceptualization of batch refactoring mentioned in 29 studies with different purposes. We identified and defined seven batch characteristics such as the scope and typology of batches, plus seven types of batch effect on software maintainability, including code smell removal. All batches' characteristics and possible impacts were systematized in a conceptual framework, which assists, for instance, the proper design of batch refactoring studies and batch detection heuristics. We defined a new heuristic for batch detection, which made it possible to conduct a large study involving 4,607 batches discovered in 57 open and closed software projects. Amongst various findings, we reveal that most batches in practice occur entirely within one commit (93%), affect multiple methods (90%). Surprisingly, batches mostly end up introducing (51%) or not removing (38%) code smells. These findings contradict previous investigations limited to the impact analysis of each transformation in isolation. Our findings also enabled us to reveal beneficial or harmful patterns of batches that respectively induces the introduction or removal of certain code smells. These patterns: (i) were not previously documented even in Fowler's refactoring catalog, and (ii) provide concrete guidance for both researchers, tool designers, and practitioners.
4
Rama, Girish Maskeri, and Raghavan Komondoor. "Detecting Full Initialization Points of Objects to Support Code Refactorings." In 2017 24th Asia-Pacific Software Engineering Conference (APSEC). IEEE, 2017. http://dx.doi.org/10.1109/apsec.2017.17.
Full text
5
Chen, Zhiyuan, Maneesh Mohanavilasam, Young-Woo Kwon, and Myoungkyu Song. "Tool Support for Managing Clone Refactorings to Facilitate Code Review in Evolving Software." In 2017 IEEE 41st Annual Computer Software and Applications Conference (COMPSAC). IEEE, 2017. http://dx.doi.org/10.1109/compsac.2017.242.
Full text
6
Albuquerque, Danyllo, Everton Guimaraes, Mirko Perkusich, Hyggo Almeida, and Angelo Perkusich. "ConCAD: A Tool for Interactive Detection of Code Anomalies." In Workshop de Visualização, Evolução e Manutenção de Software. Sociedade Brasileira de Computação - SBC, 2022. http://dx.doi.org/10.5753/vem.2022.226597.
Full textAbstract:
Code anomalies are indicators of software design can potentially decrease software maintainability and they are associated with an explicit set of refactoring actions. However, Detection of code anomalies is traditionally supported by Non-Interactive Detection (NID) techniques. These techniques encourage developers to reveal anomalies in later revisions or versions of a program, implying in counter-productive or even prohibitive refactoring actions. In this context we created ConCAD as an eclipse plug-in that enable Interactive Detection (ID) of code anomalies. This tool provide developers’ support to reveal anomalies when code fragments are still being edited, encouraging early and continuous detection of code anomalies.
7
Li, Huiqing, and Simon Thompson. "Refactoring Support for Modularity Maintenance in Erlang." In 2010 10th IEEE Working Conference on Source Code Analysis and Manipulation (SCAM). IEEE, 2010. http://dx.doi.org/10.1109/scam.2010.17.
Full text
8
Brito, Rodrigo, and Marco Tulio Valente. "RAID: Tool Support for Refactoring-Aware Code Reviews." In 2021 IEEE/ACM 29th International Conference on Program Comprehension (ICPC). IEEE, 2021. http://dx.doi.org/10.1109/icpc52881.2021.00033.
Full text
9
Schink, Hagen. "sql-schema-comparer: Support of multi-language refactoring with relational databases." In 2013 IEEE 13th International Working Conference on Source Code Analysis and Manipulation (SCAM). IEEE, 2013. http://dx.doi.org/10.1109/scam.2013.6648199.
Full text
10
Chirila, Ciprianbogdan. "REUSE MODELS FOR GENERATIVE E-LEARNING CONTENT DEDICATED TO COMPUTER SCIENCE DISCIPLINES." In eLSE 2016. Carol I National Defence University Publishing House, 2016. http://dx.doi.org/10.12753/2066-026x-16-179.
Full textAbstract:
Nowadays the e-learning domain has different development directions. Learning management systems (LMS) tend to integrate standardized content like: Shareable Content Object Reference Model (SCORM), Aviation Industry Computer Based Training Committee(AICC), etc. In products like Storyline 2 and Studio'13 the focus is set on the development of content based on slides. They start from Microsoft PowerPoint slides and enhance it with several facilities like: narrations, annotations, motion paths, screen recordings, videos, iterations, conditional interactions, simulations, language support. Another focus of these products is set on content publishing to various platforms like iPads, Android tablets etc. The Captivate e-learning content authoring tool contains facilities like: to create content for iPads and tablets with responsive design, storyboards based on slides, multiple choice templates, text, image and video galleries, sync with the cloud, e-mailing facilities of the just created story boards, the content is expressed as a Flash clips and HTML5 web pages played on most of the browsers. xAPI is a flexible specification allowing to track informal learning, social learning and real world experiences. The recording format is a very generic one in the form of actor, verb and object memorized in a learning record store (LRS). SCORM (Shareable Content Object Reference Model) is a set of standards for e-learning software in order to increase integration of e-learning content. Generative learning objects (GLO) are reusable pedagogical templates to be filled with content obtained in several ways. One efficient way for e-learning content generation is to use meta-programming on generative models. In this paper we present several generative models to be reused in authoring computer science (CS) e-learning content. The first model we propose is a CS text problem composer embedding features like: composition rules for generating learning objects, linked lists problems generation, modelling problems being built around the composition concept. A second model is a code refactorer based on several refactoring rules like: changing variable names, changing code indentations, changing loop instructions etc in order to be used by first year students to recognize different algorithms. A third model is a code tamperer based on several code tempering rules used to affect the sensitive sections, operators, variables, etc of an algorithm where students will have to identify the inserted faults. In this model we include a source code block randomizer component based on abstract syntax tree (AST) subtree swaps and other rules. A source code line randomizer can be included in the same context based on swapping sensitive lines in an algorithm selected manually or automatically. A fourth model is demonstrator based on several concepts like: to give as input an algorithm, to give as output the visualization of the data structure changes during the algorithm run.