Facelets

Block-based programming has been overwhelmingly successful in revitalizing introductory computing education and in facilitating end-user development. However, poor code quality makes block-based programs hard to understand, modify, and reuse, thus hurting the educational and productivity effectiveness of blocks. There is great potential benefit in empowering programmers in this domain to systematically improve the code quality of their projects. Refactoring--improving code quality while preserving its semantics--has been widely adopted in traditional software development. In this work, we introduce refactoring to Scratch. We define four new Scratch refactorings: Extract Custom Block, Extract Parent Sprite, Extract Constant, and Reduce Variable Scope. To automate the application of these refactorings, we enhance the Scratch programming environment with powerful program analysis and transformation routines. To evaluate the utility of these refactorings, we apply them to remove the code smells detected in a representative dataset of 448 Scratch projects. We also conduct a between-subjects user study with 24 participants to assess how our refactoring tools impact programmers. Our results show that refactoring improves the subjects' code quality metrics, while our refactoring tools help motivate programmers to improve code quality.

Mutation testing is an effective testing technique to detect faults and improve code quality. However, few practitioners have adopted mutation testing into practice, which raises several questions: Are tests capable of killing mutants useful? What is the main hindrance to adopting mutation testing in practice? Can practitioners really integrate mutation testing into real-world agile development processes? In this paper, we present two major contributions. First, based on our analysis and knowledge of Ruby, we devised eight new mutation operators for Ruby. Second, we applied mutation testing to an industrial Ruby project at Medidata and reported the lessons learned from the study. We confirmed that mutation-adequate tests are useful and could improve code quality from the perspective of practitioners and found long mutation execution time hinders the agile process. In addition, we used an enterprise-level Amazon cloud-computing technique to reduce the computational cost of running mutants. Considering the availability of a mutation testing tool with our suggested features, we argue that mutation testing can be used in practice.

Achieving comprehensive code quality and ensuring software reliability are critical goals in modern software engineering. This paper delves into advanced strategies that encompass both technical and organizational practices, aiming to enhance code quality and boost software reliability. Key strategies include the implementation of rigorous code review processes, adoption of automated testing frameworks, and the utilization of static and dynamic code analysis tools. Firstly, rigorous code review processes are fundamental for maintaining high standards of code quality. By fostering a collaborative environment where peer reviews are routine, teams can catch potential issues early, ensure adherence to coding standards, and promote knowledge sharing. This practice not only improves code quality but also enhances team cohesion and expertise. Secondly, automated testing frameworks are indispensable in achieving comprehensive test coverage and reducing the incidence of bugs. Unit tests, integration tests, and end-to-end tests, when automated, provide continuous feedback and ensure that code changes do not introduce new defects. This continuous testing approach is crucial for maintaining software reliability, especially in agile and DevOps environments where rapid iterations are common. Furthermore, the integration of static and dynamic code analysis tools into the development pipeline offers additional layers of quality assurance. Static analysis tools inspect the codebase for potential vulnerabilities, code smells, and compliance with coding standards without executing the program. Dynamic analysis tools, on the other hand, evaluate the software during runtime to detect memory leaks, concurrency issues, and performance bottlenecks. Together, these tools provide a comprehensive assessment of the code’s health and reliability. Moreover, fostering a culture of continuous improvement and learning within the development team is essential. Regular training sessions, workshops, and knowledge-sharing activities help in keeping the team updated with the latest advancements in software engineering practices and tools. Encouraging a mindset of quality-first and reliability among developers ensures long-term benefits and sustainability. In conclusion, achieving comprehensive code quality and ensuring software reliability require a multifaceted approach that integrates rigorous code reviews, automated testing frameworks, and both static and dynamic analysis tools. Coupled with a strong culture of continuous learning and improvement, these strategies collectively contribute to the development of robust, reliable, and high-quality software systems. Keywords: Software Reliability, Code Quality, Advanced, Strategies, Comprehensive.

Pair programming, a collaborative coding practice, has been widely adopted in software development, but its application in Data Engineering is still emerging.We will review the benefits of pair programming in Data Engineering, particularly with the integration of Generative AI (Gen-AI) tools.We discuss how pair programming enhances code quality, reduces errors, and improves knowledge sharing among data engineers.Furthermore, we examine how Gen-AI assistants, like Meta-AI, Github co-pilot, and Google's Gemini in Colab, can augment pair programming by providing real-time suggestions, automating routine tasks, and facilitating more efficient problem-solving.Our review reveals several advantages of combining pair programming with Gen-AI in Data Engineering, such as improved code quality, enhanced collaboration, and more.

Project-based learning is among the most common learning approaches aimed at conveying professional standards and best practices to students in programming courses. However, team projects commonly impose problems related to responsibility sharing, such as low effort or inequality in contributions. This paper presents a collaborative programming assessment system featuring a code quality assessment function with specific metrics to measure individual contributions. Student engagement data is used to detect nonconformities in collaboration using a learning analytical approach. Latent profile analysis was used to detect four theoretical team profiles differentiated by team effort (2 levels) and within-team collaboration (2 levels). We demonstrated the efficacy of assessing code to evaluate team dynamics and student behaviour, wherein efforts to resolve coding style failures can be used as a proxy by which to estimate the taskwork awareness of team members. Submission data from 146 students in 41 web-programming projects revealed four behavioural patterns that could potentially hinder the effective functioning of programming teams: free-riding, social loafing, the bystander effect, and lone wolves. We also demonstrated the applicability of automated programming assessment systems to the monitoring of learning progress, thereby facilitating timely interventions to correct difficulties at the team level.

Refactoring has been defined as improving code quality without affecting its functionality. When refactoring is overlooked in daily development, the likelihood of larger refactorings increases with time. Disadvantages of larger refactorings include that they disrupt the daily work, require additional planning effort, and often they need to be justified to stakeholders. In this paper, we investigate with interviews how professionals make refactoring decisions. As a result, we present a framework for decision making for larger refactoring operations describing the key stages in a refactoring workflow. Furthermore, one actual industry case of refactoring decision making is presented in detail.

classification is the problem of identifying a set of categories to a new comments.To improve the efficiency of the code,quality metrics are applied for evaluation.The binary classifier,predicts the false positive rates with lesser accuracy,and limited number of classes only to predict the accuracy for classifier.To address this problem,support vector machine classifier is used,which helps in detecting the false positive rates,improving code quality and the accuracy will also increased.

Code review is a widespread practice in software engineering during which developers examine each other’s source code changes to identify potential issues and improve code quality. Among the automated techniques proposed by researchers to reduce the manual workload of code review, Automated Code Revision (ACR) aims to automatically address reviewers’ feedback by producing a revised version of the code. Transformer-based language models have demonstrated state-of-the-art results in ACR. The performance of these models, however, is significantly influenced by the quality and preparation of the training and evaluation data. We present several systematic analyses of prevalent preprocessing steps, examined both cumulatively and in isolation, across three established preprocessing pipelines and two dataset splitting strategies (time-level vs. project-level). Our study spans across models of different scales: OpenNMT (small), T5 and CodeReviewer (mid-sized), LoRA-tuned CodeLLaMA-7B (large), and GPT-3.5-Turbo (large, black-box). Using datasets up to 496k training records, we evaluate and statistically compare models’ performance using exact match ratio (EXM), CodeBLEU, and Levenshtein ratio. Our findings show that preprocessing may be a significant component in the success of the different techniques: OpenNMT relies on heavy preprocessing; T5 benefits from light filtering (selective removal of records); CodeReviewer performs best when trained on larger, less aggressively filtered data; CodeLLaMA-7B and ChatGPT-3.5 Turbo are largely indifferent to preprocessing. Overall, the effectiveness of ACR tools depends on aligning preprocessing with model scale and training setup. In general, small models need abstraction, mid-sized ones benefit from light filtering, and large-scale models perform best when trained on the original, unprocessed form of the code.

Abstract. The rapid advancement of Artificial Intelligence (AI) has significantly influenced various industries, including software engineering. This paper explores the integration of AI into software engineering, focusing on its applications across different stages of the software development life cycle, including design, development, testing, project management, and maintenance. AI's ability to automate tasks, enhance efficiency, and improve code quality is revolutionizing how software is built and maintained. The paper also addresses the challenges and risks associated with AI-driven software engineering, such as dependency on AI tools, ethical concerns, and security vulnerabilities. Finally, the paper highlights future trends in AI-powered software engineering, including adaptive and self-healing systems, AI-enhanced collaboration, and full software automation. The role of AI in shaping the future of software engineering is both profound and transformative, making it a critical area of study.

DevOps is the new approach in software development that has encouraged interaction between the development and operation teams. DevOps also involves using feedback mechanisms that enhance continuous and rapid cycle feedback. However, what often occurs is that these feedback loops must be managed manually, which takes time and can be prone to mistakes. This paper explores AI and ML's ability to perform feedback loops in DevOps pipelines. In the context of the current study, we investigate the application of big data and real-time monitoring to improve code quality problem detection and prediction of performance consequences. We illustrate how feedback to developers about the necessary changes can be provided through ML models to analyze data obtained from different sources like application logs, monitoring tools, and user interactions. The paper explains the basics needed to establish feedback loops based on ML, which include data acquisition, data cleaning, model training, and online prediction. We also discuss the issues and concerns when using AI/ML in DevOps, such as the model's interpretability, the tool's integration, and change management. In this article, we explain how AI can make feedback loops smarter and provide case studies and real-life examples of how this can help improve code quality, solve problems more quickly, and enhance the relationship between development and operations. Last but not least, we discuss potential research directions for this area's further development, such as approaches to improve model interpretability, integrating collaborative learning into the DevOps process, and creating reference models for AI adoption in DevOps pipelines. In this paper, we use AI and ML to map out ways for organizations to improve their DevOps processes and ensure a feedback loop at every stage.

This paper describes our trace-based JIT compiler (trace-JIT) for Java developed from a production-quality method-based JIT compiler (method-JIT). We first describe the design and implementation of our trace-JIT with emphasis on how we retrofitted a method-JIT as a trace-based compiler. Then we show that the trace-JIT often produces better quality code than the method-JIT by extending the compilation scope. Forming longer traces that span multiple methods turns out to be more powerful than method inlining in extending the compilation scope. It reduces method-invocation overhead and also offers more compiler optimization opportunities. However, the trace-JIT incurs additional runtime overhead compared to the method-JIT that may be offset by gains from the improved code quality. Overall, our trace-JIT achieved performance roughly comparable to the baseline method-JIT. We also discuss the issues in trace-based compilation from the viewpoint of compiler optimizations. Our results show the potentials of trace-based compilation as an alternative or complementary approach to compiling languages with mature method-based compilers.

Based on the practical design of enterprise management system, this paper illustrates the design idea of enterprise management system, such as design procedure, logical division of layer and function, system efficiency enhancement, and code quality improvement and puts forward how to establish a high-efficient, safe and scalable enterprise management system.KeywordsJ2EE (Java 2.0 Enterprise Edit)JDBC (Java Database Connectivity)Application server

Blended learning, which combines traditional teaching methods with online tools, requires effective technological solutions, particularly for ensuring continuous feedback between teachers and students. This article analyzes the current state of organizing blended learning and explores the use of modern information technologies, specifically artificial intelligence and neural networks, in programming education. The authors present a detailed description of the educational platform VirtualLaboratories, a concept for a programming education platform that leverages artificial intelligence, particularly neural networks, to automate various aspects of coding, assessment, and evaluation of completed programming solutions. The platform supports multiple programming languages, such as C#, SQL, and Python, and integrates leading neural networks for code analysis, optimization, and quality improvement. This includes models like GPT-4 Code, CodeBERT, and CodeT5, which provide not only automatic code analysis but also recommendations for improvement and optimization. These capabilities allow teachers to focus on individualized work with students by tracking their progress, while students can tackle assignments at their convenience and receive objective, high-precision analyses of their solutions. The article also provides examples of neural network integration for automating code evaluation processes, which significantly reduces the time required for reviewing work and minimizes errors. It describes the main functional features of the platform, which enable the creation of multi-level programming tasks, real-time feedback, and error analysis to improve programming solutions. Additionally, the article outlines prospects for further research on implementing new artificial intelligence algorithms and expanding the platform’s capabilities to support more complex tasks and programming languages.

We evaluate the benefits of applying aspect-oriented software development techniques in the context of a large-scale industrial embedded software system implementing a number of crosscutting concerns. Additionally, we assess the feasibility of automatically extracting these crosscutting concerns from the source code. In order to achieve this, we present an approach for reverse engineering aspects from an ordinary application automatically. This approach incorporates both a concern verification and an aspect construction phase. Our results show that such automated support is feasible, and can lead to significant improvements in source code quality.

Code reuse has become very popular among software developers in recent times since it saves time and resources. One of the significant difficulties to software reuse is the time pertaining to assess the fitness of the reusable code components. Over the recent years, code search engines have made momentous advancement in establishing the semantic suitability of software components for new usage scenarios. But the issue of evaluating software components based on their nonfunctional suitability has been overlooked to a large extent. The maintenance and reusability of software systems are highly influenced by the structural properties of system classes like complexity, size, coupling, cohesion, etc. The quality of object-oriented code or design artifacts is commonly measured by analyzing the structure of these artifacts in terms of the interdependencies of classes and components as well as their internal elements. In this paper, we perform an empirical analysis on Python packages for the two measures namely coupling and cohesion. The coupling score of a module is computed as module imports and the cohesion score of a module is evaluated as call dependency between classes and global functions of the module. Finally, the proposed work evaluates a package in terms of reusability score which is a cumulative score of the coupling scores and cohesion scores of all the modules within the package. The study has evaluated 15 different packages and five different releases of one single package for reusability. We have empirically tested that the Halstead’s effort metric is inversely proportional to the reusability score. The reusability score was validated using four code detuners. The proposed work was compared with the existing metrics namely cyclomatic complexity and maintainability Index showing satisfactory results.