Relevant bibliographies by topics / Source code quality / Journal articles

Journal articles on the topic 'Source code quality'

To see the other types of publications on this topic, follow the link: Source code quality.
Author: Grafiati
Published: 14 March 2023

Create a spot-on reference in APA, MLA, Chicago, Harvard, and other styles

Select a source type:

Consult the top 50 journal articles for your research on the topic 'Source code quality.'

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.

Browse journal articles on a wide variety of disciplines and organise your bibliography correctly.

1

HusseinOdeh, Ayman. "SMSCQA: System for Measuring Source Code Quality Assurance." International Journal of Computer Applications 60, no. 8 (December 18, 2012): 35–39. http://dx.doi.org/10.5120/9714-4181.

Full text
APA, Harvard, Vancouver, ISO, and other styles
2

Taha, Ismail, and Kamel Elhadad. "SOFTWARE SOURCE CODE: A QUALITY ASSURANCE MEASUREMENT SYSTEM." International Conference on Aerospace Sciences and Aviation Technology 10, ASAT CONFERENCE (May 1, 2003): 1–13. http://dx.doi.org/10.21608/asat.2013.24704.

Full text
APA, Harvard, Vancouver, ISO, and other styles
3

Stamelos, Ioannis, Lefteris Angelis, Apostolos Oikonomou, and Georgios L. Bleris. "Code quality analysis in open source software development." Information Systems Journal 12, no. 1 (January 2002): 43–60. http://dx.doi.org/10.1046/j.1365-2575.2002.00117.x.

Full text
APA, Harvard, Vancouver, ISO, and other styles
4

Antoniol, G., M. Di Penta, G. Masone, and U. Villano. "Compiler Hacking for Source Code Analysis." Software Quality Journal 12, no. 4 (December 2004): 383–406. http://dx.doi.org/10.1023/b:sqjo.0000039794.29432.7e.

Full text
APA, Harvard, Vancouver, ISO, and other styles
5

Horváth, Ferenc, Tamás Gergely, Árpád Beszédes, Dávid Tengeri, Gergő Balogh, and Tibor Gyimóthy. "Code coverage differences of Java bytecode and source code instrumentation tools." Software Quality Journal 27, no. 1 (December 4, 2017): 79–123. http://dx.doi.org/10.1007/s11219-017-9389-z.

Full text
APA, Harvard, Vancouver, ISO, and other styles
6

Sokol, I., and O. Volkovskyi. "Program source codes conversion system." System technologies 6, no. 137 (December 10, 2021): 134–45. http://dx.doi.org/10.34185/1562-9945-6-137-2021-12.

Full text
Abstract:
The growing volume of technologies, the end of actively used development tools support, outdated API etc., entails the need of program codes conversion. In IT companies and not only, often begged the question of deprecated software support, which customers continue to use, or translation of current software to actual technologies. It is more rational for programmers to use the conversion and save most of code base, than rewriting all software by hand, even if manual adjustment is needed. At this moment, there are few high-quality code conversion systems. Largely, conversion systems work well only with similar programming languages. The task of program codes conversion is a deep and complex topic. Programmers are trying to improve translation technologies and facing with many challenges. This article discusses the basic principles of building a system for program codes conversion and some features of its practical implementation.
APA, Harvard, Vancouver, ISO, and other styles
7

Tyler, Neil. "Machine Learning to Improve Software Quality." New Electronics 53, no. 10 (May 26, 2020): 8. http://dx.doi.org/10.12968/s0047-9624(22)61253-7.

Full text
APA, Harvard, Vancouver, ISO, and other styles
8

Ruiz, Claudia, and William N. Robinson. "Measuring Open Source Quality." International Journal of Open Source Software and Processes 3, no. 3 (July 2011): 48–65. http://dx.doi.org/10.4018/jossp.2011070104.

Full text
Abstract:
There is an ample debate over the quality of Free/Libre Open Source Software (FLOSS) with mixed research results. The authors show that a reason for these mixed results is that quality is being defined, measured, and evaluated differently. They report the most popular approaches including software structure measures, process measures, and maturity assessment models. The way researchers have built their samples has also contributed to the mixed results with different project properties being considered and ignored. Because FLOSS projects evolve with each release, their quality does too, and it must be measured using metrics that take into account their communities’ commitment to quality rather than just the structure of the resulting code. Challenges exist in defining what constitutes a defect or bug, and the role of modularity in affecting FLOSS quality. The authors suggest three considerations for future research on FLOSS quality models: (1) defect resolution rate, (2) kind of software product, and (3) modularity—both technical and organizational.
APA, Harvard, Vancouver, ISO, and other styles
9

Odeh, Ayman. "Software Source Code: Theoretical Analyzing and Practical Reviewing Model." Turkish Journal of Computer and Mathematics Education (TURCOMAT) 12, no. 6 (April 5, 2021): 1554–62. http://dx.doi.org/10.17762/turcomat.v12i6.2694.

Full text
Abstract:
The high-quality software product is one of the most important goals of software engineering in general, source coding or implementation phase is one of the main steps of the software development process; when this phase is going in a good way and according to the source code quality standards and rules, the final product will be a high-quality product. This research focuses on the issues that can affect source code quality, such as errors, faults, defects, and failures; a practical system model will be provided (proposed) to predict some possible types of errors and defects and suggests some guidance and recommendations on source code error detection and analysis.
APA, Harvard, Vancouver, ISO, and other styles
10

Hanandeh, Feras, Ahmad A. Saifan, Mohammed Akour, Noor Khamis Al-Hussein, and Khadijah Zayed Shatnawi. "Evaluating Maintainability of Open Source Software." International Journal of Open Source Software and Processes 8, no. 1 (January 2017): 1–20. http://dx.doi.org/10.4018/ijossp.2017010101.

Full text
Abstract:
Maintainability is one of the most important quality attribute that affect the quality of software. There are four factors that affect the maintainability of software which are: analyzability, changeability, stability, and testability. Open source software (OSS) developed by collaborative work done by volunteers through around the world with different management styles. Open source code is updated and modified all the time from the first release. Therefore, there is a need to measure the quality and specifically the maintainability of such code. This paper discusses the maintainability for the three domains of the open source software. The domains are: education, business and game. Moreover, to observe the most effective metrics that directly affects the maintainability of software. Analysis of the results demonstrates that OSS in the education domain is the most maintainable code and cl_stat (number of executable statements) metric has the highest degree of influence on the calculation of maintenance in all three domains.
APA, Harvard, Vancouver, ISO, and other styles
11

Zhang, Chunyan, Junchao Wang, Qinglei Zhou, Ting Xu, Ke Tang, Hairen Gui, and Fudong Liu. "A Survey of Automatic Source Code Summarization." Symmetry 14, no. 3 (February 25, 2022): 471. http://dx.doi.org/10.3390/sym14030471.

Full text
Abstract:
Source code summarization refers to the natural language description of the source code’s function. It can help developers easily understand the semantics of the source code. We can think of the source code and the corresponding summarization as being symmetric. However, the existing source code summarization is mismatched with the source code, missing, or out of date. Manual source code summarization is inefficient and requires a lot of human efforts. To overcome such situations, many studies have been conducted on Automatic Source Code Summarization (ASCS). Given a set of source code, the ASCS techniques can automatically generate a summary described with natural language. In this paper, we give a review of the development of ASCS technology. Almost all ASCS technology involves the following stages: source code modeling, code summarization generation, and quality evaluation. We further categorize the existing ASCS techniques based on the above stages and analyze their advantages and shortcomings. We also draw a clear map on the development of the existing algorithms.
APA, Harvard, Vancouver, ISO, and other styles
12

Pantiuchina, Jevgenija, Bin Lin, Fiorella Zampetti, Massimiliano Di Penta, Michele Lanza, and Gabriele Bavota. "Why Do Developers Reject Refactorings in Open-Source Projects?" ACM Transactions on Software Engineering and Methodology 31, no. 2 (April 30, 2022): 1–23. http://dx.doi.org/10.1145/3487062.

Full text
Abstract:
Refactoring operations are behavior-preserving changes aimed at improving source code quality. While refactoring is largely considered a good practice, refactoring proposals in pull requests are often rejected after the code review. Understanding the reasons behind the rejection of refactoring contributions can shed light on how such contributions can be improved, essentially benefiting software quality. This article reports a study in which we manually coded rejection reasons inferred from 330 refactoring-related pull requests from 207 open-source Java projects. We surveyed 267 developers to assess their perceived prevalence of these identified rejection reasons, further complementing the reasons. Our study resulted in a comprehensive taxonomy consisting of 26 refactoring-related rejection reasons and 21 process-related rejection reasons. The taxonomy, accompanied with representative examples and highlighted implications, provides developers with valuable insights on how to ponder and polish their refactoring contributions, and indicates a number of directions researchers can pursue toward better refactoring recommenders.
APA, Harvard, Vancouver, ISO, and other styles
13

Garg, Pranav, and Srinivasan H. Sengamedu. "Synthesizing code quality rules from examples." Proceedings of the ACM on Programming Languages 6, OOPSLA2 (October 31, 2022): 1757–87. http://dx.doi.org/10.1145/3563350.

Full text
Abstract:
Static Analysis tools have rules for several code quality issues and these rules are created by experts manually. In this paper, we address the problem of automatic synthesis of code quality rules from examples. We formulate the rule synthesis problem as synthesizing first order logic formulas over graph representations of code. We present a new synthesis algorithm RhoSynth that is based on Integer Linear Programming-based graph alignment for identifying code elements of interest to the rule. We bootstrap RhoSynth by leveraging code changes made by developers as the source of positive and negative examples. We also address rule refinement in which the rules are incrementally improved with additional user-provided examples. We validate RhoSynth by synthesizing more than 30 Java code quality rules. These rules have been deployed as part of Amazon CodeGuru Reviewer and their precision exceeds 75% based on developer feedback collected during live code-reviews within Amazon. Through comparisons with recent baselines, we show that current state-of-the-art program synthesis approaches are unable to synthesize most of these rules.
APA, Harvard, Vancouver, ISO, and other styles
14

G, Vamsi Krishna. "Prediction of Source Code Quality Using Cyclomatic Complexity and Machine Learning." International Journal of Advanced Trends in Computer Science and Engineering 9, no. 4 (August 25, 2020): 4409–13. http://dx.doi.org/10.30534/ijatcse/2020/34942020.

Full text
APA, Harvard, Vancouver, ISO, and other styles
15

Saini,, Rita. "Prediction of Source Code Quality Using Cyclomatic Complexity and Machine Learning." International Journal of Advanced Trends in Computer Science and Engineering 9, no. 4 (August 25, 2020): 4414—— 4423. http://dx.doi.org/10.30534/ijatcse/2020/35942020.

Full text
APA, Harvard, Vancouver, ISO, and other styles
16

Kim, Doohwan, YooJin Jung, and Jang-Eui Hong. "Analysis of Refactoring Techniques and Tools for Source Code Quality Improvement." Convergence Society for SMB 6, no. 4 (December 31, 2016): 137–50. http://dx.doi.org/10.22156/cs4smb.2016.6.4.137.

Full text
APA, Harvard, Vancouver, ISO, and other styles
17

Hong, Jang-Eui. "Applying Practice Patterns to Improve Source Code Quality of Embedded Software." KIPS Transactions:PartA 12A, no. 7 (December 1, 2005): 589–96. http://dx.doi.org/10.3745/kipsta.2005.12a.7.589.

Full text
APA, Harvard, Vancouver, ISO, and other styles
18

Faragó, Csaba. "Variance of Source Code Quality Change Caused by Version Control Operations." Acta Cybernetica 22, no. 1 (2015): 35–56. http://dx.doi.org/10.14232/actacyb.22.1.2015.4.

Full text
APA, Harvard, Vancouver, ISO, and other styles
19

Syer, Mark D., Meiyappan Nagappan, Bram Adams, and Ahmed E. Hassan. "Studying the relationship between source code quality and mobile platform dependence." Software Quality Journal 23, no. 3 (May 20, 2014): 485–508. http://dx.doi.org/10.1007/s11219-014-9238-2.

Full text
APA, Harvard, Vancouver, ISO, and other styles
20

Huh, Sang Moo, and Woo Je Kim. "Locating Core Modules through the Association between Software Source Structure and Execution." Applied Sciences 11, no. 4 (February 13, 2021): 1685. http://dx.doi.org/10.3390/app11041685.

Full text
Abstract:
To improve software quality, the source code that composes software has to be improved, and improving the important code that largely affects the software quality should be a cost-effective method. Static analysis defines important codes as those that occupy important positions in the source network, while dynamic analysis defines important codes as those with high execution frequency. However, neither method analyzes the association between network structure and execution frequency, and both have their disadvantages. Thus, this study analyzed the association between source network structure and execution frequency to solve their disadvantages. The source function of Notepad++ was analyzed, and the function ranking was derived using the association between network structure and execution frequency. For verification, the Spearman correlation between the newly derived function ranking and the function ranking of the network and execution frequency obtained with the conventional method was measured. By measuring the Spearman correlation, the newly derived function ranking had strong correlations with execution frequency and included the network structure’s characteristics. Moreover, similar to the Pareto principle, the analysis showed that 20% of Notepad++’s functions could be categorized as important functions, largely affecting the software’s quality.
APA, Harvard, Vancouver, ISO, and other styles
21

Holzmann, Gerard J., and Margaret H. Smith. "Software model checking: extracting verification models from source code." Software Testing, Verification and Reliability 11, no. 2 (2001): 65–79. http://dx.doi.org/10.1002/stvr.228.

Full text
APA, Harvard, Vancouver, ISO, and other styles
22

Mulge, Md Yusuf, Md Sameerkhan, Abdul Ahad Afroz, and Darakhshinda Parween. "Impact and Consideration of Programming Constructs on JAVA and C# Source Code Readability." International Journal of Emerging Research in Management and Technology 6, no. 11 (June 13, 2018): 106. http://dx.doi.org/10.23956/ijermt.v6i11.53.

Full text
Abstract:
Software quality is a property that manipulates how easily a given piece of code can be read and understood. Since quality can affect understandability, reusability, maintainability etc. Programmers are very concerned about the readability of code. For the good decision of selecting languages, it is necessary to know about the quality of languages. Many software constructs may affect quality of code. In this paper we have selected some constructs that affect quality property and we calculated their quality in C# and java PL. At the end we have also compared results for both languages to make decision easy for programmers to choose best one from both. Short bits are taken from c and java and for their quality; five readability indexes are used to get results.
APA, Harvard, Vancouver, ISO, and other styles
23

Carvalho, Nuno, Alberto Simões, and José Almeida. "DMOSS: Open source software documentation assessment." Computer Science and Information Systems 11, no. 4 (2014): 1197–207. http://dx.doi.org/10.2298/csis131005027c.

Full text
Abstract:
Besides source code, the fundamental source of information about open source software lies in documentation, and other non source code files, like README, INSTALL, or How-To files, commonly available in the software ecosystem. These documents, written in natural language, provide valuable information during the software development stage, but also in future maintenance and evolution tasks. DMOSS3 is a toolkit designed to systematically assess the quality of non source code content found in software packages. The toolkit handles a package as an attribute tree, and performs several tree traverse algorithms through a set of plugins, specialized in retrieving specific metrics from text, gathering information about the software. These metrics are later used to infer knowledge about the software, and composed together to build reports that assess the quality of specific features. This paper discusses the motivations for this work, continues with a description of the toolkit implementation and design goals. This is followed by an example of its usage to process a software package, and the produced report.
APA, Harvard, Vancouver, ISO, and other styles
24

Pokrovskyi, A. M. "A tool to measure Fortran source code metrics using syntax analysis." PROBLEMS IN PROGRAMMING, no. 1 (March 2021): 026–35. http://dx.doi.org/10.15407/pp2021.01.026.

Full text
Abstract:
The rapid development of software quality measurement methods, the need in efficient and versatile reengineering automatization tools becomes increasingly bigger. This becomes even more apparent when the programming language and respective coding practices slowly develop alongside each other for a long period of time, while the legacy code base grows bigger and remains highly relevant. In this paper, a source code metrics measurement tool for Fortran program quality evaluation is developed. It is implemented as a code module for Photran integrated development environment and based on a set of syntax tree walking algorithms. The module utilizes the built-in Photran syntax analysis engine and the tree data structure which it builds from the source code. The developed tool is also compared to existing source code analysis instruments. The results show that the developed tool is most effective when used in combination with Photran’s built-in refactoring system, and that Photran’s application programming interface facilitates easy scaling of the existing infrastructure by introducing other code analysis methods.
APA, Harvard, Vancouver, ISO, and other styles
25

Gimatdinov, Damir Maratovich, Alexander Yurievich Gerasimov, Petr Alekseevich Privalov, Veronika Nikolaevna Butkevich, Natalya Andreevna Chernova, and Anna Antonovna Gorelova. "An Automated Framework for Testing Source Code Static Analysis Tools." Proceedings of the Institute for System Programming of the RAS 33, no. 3 (2021): 41–50. http://dx.doi.org/10.15514/ispras-2021-33(3)-3.

Full text
Abstract:
Automated testing frameworks are widely used for assuring quality of modern software in secure software development lifecycle. Sometimes it is needed to assure quality of specific software and, hence specific approach should be applied. In this paper, we present an approach and implementation details of automated testing framework suitable for acceptance testing of static source code analysis tools. The presented framework is used for continuous testing of static source code analyzers for C, C++ and Python programs.
APA, Harvard, Vancouver, ISO, and other styles
26

Wu, Sixue, Gerrit Blacquière, and Gert-Jan Adriaan van Groenestijn. "Shot repetition: An alternative seismic blending code in marine acquisition." GEOPHYSICS 83, no. 6 (November 1, 2018): P29—P37. http://dx.doi.org/10.1190/geo2017-0649.1.

Full text
Abstract:
In blended seismic acquisition, or simultaneous source seismic acquisition, source encoding is essential at the acquisition stage to allow for separation of the blended sources at the processing stage. In land seismic surveys, the vibroseis sources may be encoded with near-orthogonal sweeps for blending. In marine seismic surveys, the sweep type of source encoding is difficult because the main source type in marine seismic exploration is the air-gun array, which has an impulsive character. Another issue in marine streamer seismic data acquisition is that the spatial source sampling is generally coarse. This hinders the deblending performance of algorithms based on the random time delay blending code that inherently requires a dense source sampling because they exploit the signal coherency in the common-receiver domain. We have developed an alternative source code called shot repetition that exploits the impulsive character of the marine seismic source in blending. This source code consists of repeated spikes of ones and can be realized physically by activating a broadband impulsive source more than once at (nearly) the same location. Optimization of the shot-repetition type of blending code was done to improve the deblending performance. As a result of using shot repetition, the deblending process can be carried out in individual shot gathers. Therefore, our method has no need for a regular dense source sampling: It can cope with irregular sparse source sampling; it can help with real-time data quality control. In addition, the use of shot repetition is beneficial for reducing the background noise in the deblended data. We determine the feasibility of our method on numerical examples.
APA, Harvard, Vancouver, ISO, and other styles
27

Khatoon, Shaheen, Azhar Mahmood, Guohui Li, and Jianfeng Xu. "A Novel Integrated Framework to Increase Software Quality by Mining Source Code." Journal of Software Engineering 7, no. 3 (June 15, 2013): 86–105. http://dx.doi.org/10.3923/jse.2013.86.105.

Full text
APA, Harvard, Vancouver, ISO, and other styles
28

Faragó, Csaba, Péter Hegedűs, Ádám Zoltán Végh, and Rudolf Ferenc. "Connection Between Version Control Operations and Quality Change of the Source Code." Acta Cybernetica 21, no. 4 (2014): 585–607. http://dx.doi.org/10.14232/actacyb.21.4.2014.4.

Full text
APA, Harvard, Vancouver, ISO, and other styles
29

Łukasik, Mariusz, and Marek Miłosz. "Analysis of the impact of refactoring on code quality – comparative analysis of two cases." Journal of Computer Sciences Institute 5 (December 30, 2017): 200–203. http://dx.doi.org/10.35784/jcsi.621.

Full text
Abstract:
In agile methods, one of the techniques for improving code quality is refactoring. This is a process that employs a number of techniques, modifying the code without changing its functionality, aiming to improve its transparency and reduce vulnerability. You can measure the improvement of the code using different code quality metrics. The paper presents an analysis of the effect of refactoring on static code quality on the example of the open-source project Scuba. The quality of the code was measured at two different points of software development - right before and after refactoring the code. The three most popular sets of object code quality metrics and the Sonarqube tool were used for the measurement. The research clearly demonstrates the significant improvement of static code quality as a result of refactoring.
APA, Harvard, Vancouver, ISO, and other styles
30

Sharma, Divya, and Shikha Lohchab. "Search based Software Engineering of Software Metrics, Code Smells and Refactoring Techniques Using Optimization Algorithms." NeuroQuantology 20, no. 5 (May 2, 2022): 195–203. http://dx.doi.org/10.14704/nq.2022.20.5.nq22163.

Full text
Abstract:
Software refactoring is a technique for reorganising and improving the efficiency of existing software code. By refining the non-functional aspects of software, numerous refactoring methods are currently being employed to build more intelligible and less composite codes. By applying multiple systems to the source code, refactoring can improve code maintainability even further, preserving the behaviour of the code. Refactoring allows for the eradication of bugs and the expansion of the program's capabilities. This paper provides a comprehensive assessment of source code with foul odours, the influence on software quality of using certain refactoring methodologies to eradicate the foul smell. Between 2008 and 2010, a total of 76 studies from 42 journals, 20 conferences, and 14 additional sources in the year 2008 and 2022 were available. This study was graded on the number of unpleasant odours identified, refactoring strategies applied, and their impact on software metrics. The foul smells of "method of long," "envious feature “and” class of data" were discovered or corrected in the majority of inquiries. The odour of "envious feature" was detected in 39.66 per cent of nominated investigations. The majority of studies looked at the effects of restructuring on software intricacy and coupling measures. Surprisingly, instead of patented software, the majority of the investigations employed massive opensource datasets released in Java. Finally, this research makes suggestions for further into the refactoring research code.
APA, Harvard, Vancouver, ISO, and other styles
31

Luong, Tran Thanh, and Le My Canh. "JAVASCRIPT ASYNCHRONOUS PROGRAMMING." Hue University Journal of Science: Techniques and Technology 128, no. 2B (July 16, 2019): 5–16. http://dx.doi.org/10.26459/hueuni-jtt.v128i2b.5104.

Full text
Abstract:
JavaScript has become more and more popular in recent years because its wealthy features as being dynamic, interpreted and object-oriented with first-class functions. Furthermore, JavaScript is designed with event-driven and I/O non-blocking model that boosts the performance of overall application especially in the case of Node.js. To take advantage of these characteristics, many design patterns that implement asynchronous programming for JavaScript were proposed. However, choosing a right pattern and implementing a good asynchronous source code is a challenge and thus easily lead into less robust application and low quality source code. Extended from our previous works on exception handling code smells in JavaScript and exception handling code smells in JavaScript asynchronous programming with promise, this research aims at studying the impact of three JavaScript asynchronous programming patterns on quality of source code and application.
APA, Harvard, Vancouver, ISO, and other styles
32

Faisal, Shafiqul Islam, and Abi Muttaquin Bin Jalal Bayar. "Gamma Shielding Experiment Simulation utilizing MCNPX Code." Journal of Engineering Science 12, no. 2 (July 8, 2021): 11–21. http://dx.doi.org/10.3329/jes.v12i2.54627.

Full text
Abstract:
Experimental investigation requires materials, radiation sources, and test arrangements with a high monetary financial plan. Furthermore, radiation exposure involves people during the experiment. On the contrary, the simulation technique for examining radiation interactions is radio-logically safer, less timeconsuming, cost-effective, and applicable for all desired radiation sources. Through 48.86 mCi 662 keV Caesium-137 gamma-ray source; shielding experiment as well as simulation of it with MCNPX were performed for three shielding materials Lead, Copper, and Aluminum. These materials were placed in front of the gamma source and the emergent radiation was counted in a Geiger- Muller detector to understand the attenuation quality of these materials to each other. These courses of action were simulated utilizing the MCNPX code version 2.7.0 and the results likewise gave and looked at that of the experiment. There are huge similarities of shielding behavior between MCNPX simulation and experiments for the three absorbing materials. The modeled geometry of this MCNPX simulation could be used for future approaches of new designs and structures of radiation shielding, especially where no analogous experimental data exist Journal of Engineering Science 12(2), 2021, 11-21
APA, Harvard, Vancouver, ISO, and other styles
33

Sun, Xiaobing, Qiang Geng, David Lo, Yucong Duan, Xiangyue Liu, and Bin Li. "Code Comment Quality Analysis and Improvement Recommendation: An Automated Approach." International Journal of Software Engineering and Knowledge Engineering 26, no. 06 (August 2016): 981–1000. http://dx.doi.org/10.1142/s0218194016500339.

Full text
Abstract:
Program comprehension is one of the first and most frequently performed activities during software maintenance and evolution. In a program, there are not only source code, but also comments. Comments in a program is one of the main sources of information for program comprehension. If a program has good comments, it will be easier for developers to understand it. Unfortunately, for many software systems, due to developers’ poor coding style or hectic work schedule, it is often the case that a number of methods and classes are not written with good comments. This can make it difficult for developers to understand the methods and classes, when they are performing future software maintenance tasks. To deal with this problem, in this paper we propose an approach which assesses the quality of a code comment and generates suggestions to improve comment quality. A user study is conducted to assess the effectiveness of our approach and the results show that our comment quality assessments are similar to the assessments made by our user study participants, the suggestions provided by our approach are useful to improve comment quality, and our approach can improve the accuracy of the previous comment quality analysis approaches.
APA, Harvard, Vancouver, ISO, and other styles
34

Zhao, Youqian, and Andrew Curtis. "Relative source location using coda-wave interferometry: Method, code package, and application to mining-induced earthquakes." GEOPHYSICS 84, no. 3 (May 1, 2019): F73—F84. http://dx.doi.org/10.1190/geo2018-0601.1.

Full text
Abstract:
A wide range of applications requires the relative locations of sources of energy to be known accurately. Most conventional location methods are either subject to errors that depend strongly on inaccuracy in the model of propagation velocity used or demand a well-distributed network of surrounding seismic stations to produce reliable results. A new source location method based on coda-wave interferometry (CWI) is relatively insensitive to the number of seismic stations and to the source-to-station azimuthal coverage. Therefore, it opens new avenues for research, for applications in areas with unfavorable recording geometries, and for applications that require a complementary method. This method uses CWI to estimate distances between pairs of seismic events with a similar source mechanism recorded at the same station. These separation estimates are used to solve for the locations of clusters of events relative to one another within a probabilistic framework through optimization. It is even possible to find the relative locations of clusters of events with one single-channel station. Given these advantages, it is likely that one reason that the method is not used more widely is the lack of reliable code that implements this multistage method. Therefore, we have developed a well-commented MATLAB code that does so, and we evaluate examples of its applications. It can be used with seismic data from a single-station channel, and it enables data recorded by different channels and stations to be used simultaneously. It is therefore possible to combine data from permanent yet sparse networks and from temporary arrays closer to the source region. We use the code to apply the location method to a selected data set of the New Ollerton earthquakes in England to demonstrate the validity of the code. The worked example is provided within the package. A way to assess the quality of the location results is also provided.
APA, Harvard, Vancouver, ISO, and other styles
35

Zhang, Chunyan, Qinglei Zhou, Meng Qiao, Ke Tang, Lianqiu Xu, and Fudong Liu. "Re_Trans: Combined Retrieval and Transformer Model for Source Code Summarization." Entropy 24, no. 10 (September 27, 2022): 1372. http://dx.doi.org/10.3390/e24101372.

Full text
Abstract:
Source code summarization (SCS) is a natural language description of source code functionality. It can help developers understand programs and maintain software efficiently. Retrieval-based methods generate SCS by reorganizing terms selected from source code or use SCS of similar code snippets. Generative methods generate SCS via attentional encoder–decoder architecture. However, a generative method can generate SCS for any code, but sometimes the accuracy is still far from expectation (due to the lack of numerous high-quality training sets). A retrieval-based method is considered to have a higher accurac, but usually fails to generate SCS for a source code in the absence of a similar candidate in the database. In order to effectively combine the advantages of retrieval-based methods and generative methods, we propose a new method: Re_Trans. For a given code, we first utilize the retrieval-based method to obtain its most similar code with regard to sematic and corresponding SCS (S_RM). Then, we input the given code and similar code into the trained discriminator. If the discriminator outputs onr, we take S_RM as the result; otherwise, we utilize the generate model, transformer, to generate the given code’ SCS. Particularly, we use AST-augmented (AbstractSyntax Tree) and code sequence-augmented information to make the source code semantic extraction more complete . Furthermore, we build a new SCS retrieval library through the public dataset. We evaluate our method on a dataset of 2.1 million Java code-comment pairs, and experimental results show improvement over the state-of-the-art (SOTA) benchmarks, which demonstrates the effectiveness and efficiency of our method.
APA, Harvard, Vancouver, ISO, and other styles
36

Şanlıalp, İbrahim, Muhammed Maruf Öztürk, and Tuncay Yiğit. "Energy Efficiency Analysis of Code Refactoring Techniques for Green and Sustainable Software in Portable Devices." Electronics 11, no. 3 (February 1, 2022): 442. http://dx.doi.org/10.3390/electronics11030442.

Full text
Abstract:
Code refactoring is a time-consuming and effort-intensive process that is applied for making improvements to source codes. There exist several refactoring techniques to improve software quality. Some of them aim to reduce the energy consumption of the software. However, the combination of applied refactoring techniques is crucial to the success rate. In addition, to provide sustainable services on portable devices such as mobile phones and laptops, which rely on batteries, improving and optimizing the energy efficiency is important. This study focuses on examining the effect of code refactoring techniques on energy consumption. A total of 25 different source codes of applications programmed in the C# and Java languages are selected for the study, and combinations obtained from refactoring techniques are applied to these source codes. The combinations applied are analyzed using the maintainability index. Power consumption estimation tools are used to measure the energy consumption of the original and refactored codes. The results show that the combinations significantly improve the software’s energy efficiency. The results will provide a better understanding of the relationship between the energy efficiency of software and refactoring techniques. Moreover, they will help developers to improve their object-oriented code in terms of both energy efficiency and sustainability.
APA, Harvard, Vancouver, ISO, and other styles
37

Ismail, Ismail, and Jalisal Efendi. "Black-Box Testing : Analisis Kualitas Aplikasi Source Code Bank Programming." Jurnal JTIK (Jurnal Teknologi Informasi dan Komunikasi) 4, no. 2 (December 6, 2020): 1. http://dx.doi.org/10.35870/jtik.v5i1.148.

Full text
Abstract:
The Source Code Bank Programming application that the researchers built uses Borland Delphi which functions to support software learning activities and as a reference for software developers, especially the Delphi programming language. In the process of developing Source Code Bank Programming is still in the prototype stage and further development is still being carried out so that it can be competitively competitive in the world. It is necessary to do various evaluations of the quality of the application in order to match the expectations of the user, one of which is to analyze the quality of the application using the Black-Box Testing method. Testing the Black-Box Source Code Bank Programming uses 3 methods, namely; 1) Graph-based testing, 2) Equivalence Partitioning, and 3) Boundary Value Analysis. The research results show that graph testing, equivalence partitioning, and boundary value analysis will be able to help the process of making test cases and make testing simpler, There are errors in testing and are included in the defect-list, the test results also show that the fulfillment of user needs for public users with a value 0.90, user registers/member with a value of 1.00, students with a value of 0.90, lecturers with a value of 0.82 and admin with a value of 0.84 are classified as good because the degree of value in each user module is greater than 0.8.
APA, Harvard, Vancouver, ISO, and other styles
38

Milocco, A., and A. Trkov. "Modelling of the Production of Source Neutrons from Low-Voltage Accelerated Deuterons on Titanium-Tritium Targets." Science and Technology of Nuclear Installations 2008 (2008): 1–7. http://dx.doi.org/10.1155/2008/340282.

Full text
Abstract:
Fast quasi-monoenergetic neutrons can be produced by accelerating charged deuterons on tritium solid targets. Benchmark experiments were performed in many laboratories with intense D-T neutron sources. The aim is to validate the computational models and nuclear data for fusion applications. The detailed information on the neutron source term is highly important for the benchmark analyses. At present, the MCNP family of codes cannot explicitly model the D-T reaction for Deuterons in the KeV energy range. The physics for the D-T neutron production was modelled at ENEA (Italy) in the SOURCE and SRCDX subroutines to compile with the MCNP source code. Some improvements to the original subroutines were introduced. The differential cross-sections for the D-T reaction from the ENDF/B-VII library were built into the code. The relativistic approach was implemented for neutron kinematics. The new D-T neutron source model was applied to the MCNP5 simulation of the tungsten integral experiment performed at the OKTAVIAN facility. The uncertainty associated with the realistic D-T reactions was separated from the total uncertainty of the source term. The outcome of the benchmark analysis was an improvement in the quality of the computational model of the experiment.
APA, Harvard, Vancouver, ISO, and other styles
39

Hamdy, Abeer, and Abdelrahman E. Arabi. "Locating Faulty Source Code Files to Fix Bug Reports." International Journal of Open Source Software and Processes 13, no. 1 (January 1, 2022): 1–15. http://dx.doi.org/10.4018/ijossp.308791.

Full text
Abstract:
Open source software is usually released while it still contains bugs. In order to fix a reported bug during maintenance phase, the developer has to search the source code files to identify the faulty ones; this process is called bug localization (BL). Automating BL is a necessity to boost the developer's productivity and enhance the software quality. The paper proposes an information retrieval based approach for retrieving and ranking a list of suspicious faulty source files relevant to a submitted bug report (BR). The proposed approach leverages textual features of the BRs and source files, which are parts-of-speech tagging, lexical and semantic similarity between the source files and BRs, in addition to the source file change history. The effectiveness of the proposed approach was evaluated over three open-source software repositories. Experimental results showed the superiority of the proposed approach over eight previous approaches in terms of top@N and MAP metrics.
APA, Harvard, Vancouver, ISO, and other styles
40

Živkovič, Aleš, Uroš Goljat, and Marjan Heričko. "Improving the usability of the source code quality index with interchangeable metrics sets." Information Processing Letters 110, no. 6 (February 2010): 236–40. http://dx.doi.org/10.1016/j.ipl.2010.01.002.

Full text
APA, Harvard, Vancouver, ISO, and other styles
41

Saklani, Santosh. "SOFTWARE QUALITY PREDICTION USING MACHINE LEARNING TECHNIQUES AND SOURCE CODE METRICS: A REVIEW." International Journal of Advanced Research in Computer Science 13, no. 06 (December 20, 2022): 12–25. http://dx.doi.org/10.26483/ijarcs.v13i6.6918.

Full text
APA, Harvard, Vancouver, ISO, and other styles
42

Wen, Wanzhi, Jiawei Chu, Tian Zhao, Ruinian Zhang, Bao Zhi, and Chenqiang Shen. "Code2tree: A Method for Automatically Generating Code Comments." Scientific Programming 2022 (September 29, 2022): 1–9. http://dx.doi.org/10.1155/2022/6350686.

Full text
Abstract:
Source code comments can improve the efficiency of software development and maintenance. However, due to the heterogeneity of natural language and program language, the quality of code comments is not so high. So, this paper proposes a novel method Code2tree, which is based on the encoder-decoder model to automatically generate Java code comments. Code2tree firstly converts Java source code into abstract syntax tree (AST) sequences, and then the AST sequences are encoded by GRU encoder to solve the long sequence learning dependency problem. Finally, the attention mechanism is introduced in the decoding stage, and the quality of the code comment is improved by increasing the weight of the key information. We use the open dataset java-small to train the model and verify the effectiveness of Code2tree based on common-used indicators BLEU and F1-Score.
APA, Harvard, Vancouver, ISO, and other styles
43

Codabux, Zadia, Kazi Zakia Sultana, and Byron J. Williams. "The Relationship Between Code Smells and Traceable Patterns — Are They Measuring the Same Thing?" International Journal of Software Engineering and Knowledge Engineering 27, no. 09n10 (November 2017): 1529–47. http://dx.doi.org/10.1142/s0218194017400095.

Full text
Abstract:
It is important to maintain software quality as a software system evolves. Managing code smells in source code contributes towards quality software. While metrics have been used to pinpoint code smells in source code, we present an empirical study on the correlation of code smells with class-level (micro pattern) and method-level (nano-pattern) traceable code patterns. This study explores the relationship between code smells and class-level and method-level structural code constructs. We extracted micro patterns at the class level and nano-patterns at the method level from three versions of Apache Tomcat, three versions of Apache CXF and two J2EE web applications namely PersonalBlog and Roller from Stanford SecuriBench and then compared their distributions in code smell versus noncode smell classes and methods. We found that Immutable and Sink micro patterns are more frequent in classes having code smells compared to the noncode smell classes in the applications we analyzed. On the other hand, LocalReader and LocalWriter nano-patterns are more frequent in code smell methods compared to the noncode smell methods. We conclude that code smells are correlated with both micro and nano-patterns.
APA, Harvard, Vancouver, ISO, and other styles
44

Kapustin, D. A., V. V. Shvyrov, E. Yu Suvorova, and T. I. Shulyka. "PEP 8 Compliance Analysis for Python Open Source Projects." Programmnaya Ingeneria 14, no. 1 (January 19, 2023): 12–23. http://dx.doi.org/10.17587/prin.14.12-23.

Full text
Abstract:
he use of the Python language in large projects in combination with modern development methodologies entails a number of tasks for checking and standardizing program code in order to improve its quality. For the Python language, PEP 8 is the current standard. Verification procedures are performed by specialized software tools — linters that use static analysis methods. This paper investigates the main violations of the PEP 8 standard in Python open source projects. In addition, an analysis was made of the effectiveness of automatic formatting of program code using the Black and YAPF formatters.
APA, Harvard, Vancouver, ISO, and other styles
45

Hilton, Rod, and Ellen Gethner. "Predicting Code Hotspots in Open-Source Software from Object-Oriented Metrics Using Machine Learning." International Journal of Software Engineering and Knowledge Engineering 28, no. 03 (March 2018): 311–31. http://dx.doi.org/10.1142/s0218194018500110.

Full text
Abstract:
Software engineers are able to measure the quality of their code using a variety of metrics that can be derived directly from analyzing the source code. These internal quality metrics are valuable to engineers, but the organizations funding the software development effort find external quality metrics such as defect rates and time to develop features more valuable. Unfortunately, external quality metrics can only be calculated after costly software has been developed and deployed for end-users to utilize. Here, we present a method for mining data from freely available open source codebases written in Java to train a Random Forest classifier to predict which files are likely to be external quality hotspots based on their internal quality metrics with over 75% accuracy. We also used the trained model to predict hotspots for a Java project whose data was not used to train the classifier and achieved over 75% accuracy again, demonstrating the method’s general applicability to different projects.
APA, Harvard, Vancouver, ISO, and other styles
46

Ochodek, Miroslaw, Regina Hebig, Wilhelm Meding, Gert Frost, and Miroslaw Staron. "Recognizing lines of code violating company-specific coding guidelines using machine learning." Empirical Software Engineering 25, no. 1 (November 14, 2019): 220–65. http://dx.doi.org/10.1007/s10664-019-09769-8.

Full text
Abstract:
AbstractSoftware developers in big and medium-size companies are working with millions of lines of code in their codebases. Assuring the quality of this code has shifted from simple defect management to proactive assurance of internal code quality. Although static code analysis and code reviews have been at the forefront of research and practice in this area, code reviews are still an effort-intensive and interpretation-prone activity. The aim of this research is to support code reviews by automatically recognizing company-specific code guidelines violations in large-scale, industrial source code. In our action research project, we constructed a machine-learning-based tool for code analysis where software developers and architects in big and medium-sized companies can use a few examples of source code lines violating code/design guidelines (up to 700 lines of code) to train decision-tree classifiers to find similar violations in their codebases (up to 3 million lines of code). Our action research project consisted of (i) understanding the challenges of two large software development companies, (ii) applying the machine-learning-based tool to detect violations of Sun’s and Google’s coding conventions in the code of three large open source projects implemented in Java, (iii) evaluating the tool on evolving industrial codebase, and (iv) finding the best learning strategies to reduce the cost of training the classifiers. We were able to achieve the average accuracy of over 99% and the average F-score of 0.80 for open source projects when using ca. 40K lines for training the tool. We obtained a similar average F-score of 0.78 for the industrial code but this time using only up to 700 lines of code as a training dataset. Finally, we observed the tool performed visibly better for the rules requiring to understand a single line of code or the context of a few lines (often allowing to reach the F-score of 0.90 or higher). Based on these results, we could observe that this approach can provide modern software development companies with the ability to use examples to teach an algorithm to recognize violations of code/design guidelines and thus increase the number of reviews conducted before the product release. This, in turn, leads to the increased quality of the final software.
APA, Harvard, Vancouver, ISO, and other styles
47

Ouali, Sami. "Generating Software Product Line Model by Resolving Code Smells in the Products’ Source Code." International Journal of Software Engineering & Applications 12, no. 1 (January 31, 2021): 1–10. http://dx.doi.org/10.5121/ijsea.2021.12101.

Full text
Abstract:
Software Product Lines (SPLs) refer to some software engineering methods, tools and techniques for creating a collection of similar software systems from a shared set of software assets using a common means of production. This concept is recognized as a successful approach to reuse in software development. Its purpose is to reduce production costs by reusing existing features and managing the variability between the different products with respect of particular constraints. Software Product Line engineering is the production process in product lines and the development of a family of systems by reusing core assets. It exploits the commonalities between software products and preserves the ability to vary the functionalities and features between these products. The adopted strategy for building SPL can be a top-down or bottom-up. Depending from the selected strategy, it is possible to face an inappropriate implementation in the SPL Model or the derived products during this process. The code can contain code smells or code anomalies. Code smells are considered as problems in source code which can have an impact on the quality of the derived products of an SPL. The same problem can be present in many derived products from an SPL due to reuse or in the obtained product line when the bottom-up strategy is selected. A possible solution to this problem can be the refactoring which can improve the internal structure of source code without altering external behavior. This paper proposes an approach for building SPL from source code using the bottom-up strategy. Its purpose is to reduce code smells in the obtained SPL using refactoring source code. This approach proposes a possible solution using reverse engineering to obtain the feature model of the SPL.
APA, Harvard, Vancouver, ISO, and other styles
48

Izadkhah, Habib. "Transforming Source Code to Mathematical Relations for Performance Evaluation." Annales Universitatis Mariae Curie-Sklodowska, sectio AI – Informatica 15, no. 2 (September 1, 2015): 7. http://dx.doi.org/10.17951/ai.2015.15.2.7-13.

Full text
Abstract:
Assessing software quality attributes (such as performance, reliability, and security) from source code is of the utmost importance. The performance of a software system can be improved by its parallel and distributed execution. The aim of the parallel and distributed execution is to speed up by providing the maximum possible concurrency in executing the distributed segments. It is a well known fact that distributing a program cannot be always caused speeding up the execution of it; in some cases, this distribution can have negative effects on the running time of the program. Therefore, before distributing a source code, it should be specified whether its distribution could cause maximum possible concurrency or not. The existing methods and tools cannot achieve this aim from the source code. In this paper, we propose a mathematical relationship for object oriented programs that statically analyze the program by verifying the type of synchronous and asynchronous calls inside the source code. Then, we model the invocations of the software methods by Discrete Time Markov Chains (DTMC). Using the properties of DTMC and the proposed mathematical relationship, we will determine whether or not the source code can be distributed on homogeneous processors. The experimental results showed that we can specify whether the program is distributable or not, before deploying it on the distributed systems.
APA, Harvard, Vancouver, ISO, and other styles
49

Kurtukova, Anna, and Alexander Romanov. "Identification Author of Source Code by Machine Learning Methods." SPIIRAS Proceedings 18, no. 3 (June 4, 2019): 742–66. http://dx.doi.org/10.15622/sp.2019.18.3.741-765.

Full text
Abstract:
The paper is devoted to the analysis of the problem of determining the source code author , which is of interest to researchers in the field of information security, computer forensics, assessment of the quality of the educational process, protection of intellectual property. The paper presents a detailed analysis of modern solutions to the problem. The authors suggest two new identification techniques based on machine learning algorithms: support vector machine, fast correlation filter and informative features; the technique based on hybrid convolutional recurrent neural network. The experimental database includes samples of source codes written in Java, C ++, Python, PHP, JavaScript, C, C # and Ruby. The data was obtained using a web service for hosting IT-projects – Github. The total number of source codes exceeds 150 thousand samples. The average length of each of them is 850 characters. The case size is 542 authors. The experiments were conducted with source codes written in the most popular programming languages. Accuracy of the developed techniques for different numbers of authors was assessed using 10-fold cross-validation. An additional series of experiments was conducted with the number of authors from 2 to 50 for the most popular Java programming language. The graphs of the relationship between identification accuracy and case size are plotted. The analysis of result showed that the method based on hybrid neural network gives 97% accuracy, and it’s at the present time the best-known result. The technique based on the support vector machine made it possible to achieve 96% accuracy. The difference between the results of the hybrid neural network and the support vector machine was approximately 5%.
APA, Harvard, Vancouver, ISO, and other styles
50

Tkachuk, Andrii, and Bogdan Bulakh. "Usage of formalized knowledge about source code for refactoring actions in Swift." Technology audit and production reserves 6, no. 2(68) (November 17, 2022): 6–10. http://dx.doi.org/10.15587/2706-5448.2022.267160.

Full text
Abstract:
The object of research in the paper is the source code of a software product written in the Swift programming language. Most programs as a product of a certain project during the life cycle require changes and modifications, which is costly or impossible to implement in the case of poor code quality. One of the options for solving the problem of poor code quality is the timely application of refactoring principles. The existing problem is that implementation of high-level refactoring must be done manually by the developer without the use of automated tools as built-in solutions cannot fulfill the need due to the architectural complexity of the product. To reduce the number of errors made during refactoring, to simplify the process of performing routine actions, it is suggested to use a new software product for refactoring. It works with high-level user commands based on a formalized description of the source code together with a knowledge base containing a description of code entities and their properties (what specific actions can be performed with them). In the work, the refactoring of the source code was carried out using the example of the Swift programming language. The proposed approach of component architecture (knowledge base, software engine) further allows to expand the functionality of the software product to other programming languages. The work was directed to the development of a prototype of a software product using the proposed approach to check and compare the results with other refactoring tools. A command line utility has been developed that accepts a verbal command as an input and outputs the results of processing and analysis of the source code (search for complex structures in the code) or applies the proposed change. As a result of the conducted testing, it was established that the use of the proposed approach allows performing complex refactoring tasks with the help of a simple verbal formalized command. Accomplishing the same task using only the built-in refactoring tools requires significantly more time and effort or is impossible at all.
APA, Harvard, Vancouver, ISO, and other styles
You might also be interested in the bibliographies on the topic 'Source code quality' for other source types:
Dissertations / Theses
We offer discounts on all premium plans for authors whose works are included in thematic literature selections. Contact us to get a unique promo code!

To the bibliography