Source code does not exist in isolation. Code is structured in project repositories composed of packages, and large applications are often composed of multiple projects. This paper investigates whether token-level completion engines can take advantage of such information.In this context, Pharo offers a sophisticated completion engine based on language semantics using heuristics, i.e., ordered sequences of lazy fetchers that retrieve and rank completion candidates. These heuristics can be recomposed or extended to support various activities (e.g., live programming or history usage navigation). The default heuristics rely on the language’s semantics and scoping rules. While this system is powerful, it does not account for package concerns of any sort (neither repository structure nor package dependencies). As a result, it does not prioritize classes within the same package or project, nor the classes that they may use, treating all global names equally.In this paper, we introduce and systematically evaluate several new heuristics that address this limitation: Lateral Packages, Direct Package Dependencies, and Two-Level Package Dependencies heuristics. Our benchmark runs over the method call sites of 219 packages, comprising 4,535 classes and a total of 35,972 methods. This codebase covers major projects such as Iceberg, Moose, Roassal, Seaside, and Spec, ensuring a diverse and realistic benchmark for assessing the effectiveness of our proposed heuristics. We evaluate two key concerns: the completion of class and method names. Rather than proposing a new learning model, this work evaluates whether explicit package dependencies, already available in modular software systems, can serve as a lightweight structural signal for improving completion ranking.Results show that the Direct Package Dependencies heuristic improves Mean Reciprocal Rank (MRR): for 3-character prefixes, MRR increases from 0.20 to 0.44 for class-name completion and from 0.10 to 0.41 for method-name completion. These results indicate that package-aware completion strategies provide more accurate and relevant suggestions than the default Semantics-Based strategy in the evaluated projects. Because Direct Package Dependencies outperformed the default strategy for class-name completion, the Pharo Industrial Consortium decided to introduce it in Pharo 13.
Checking the compliance of software against laws, regulations and contracts is increasingly important and costly as the embedding of software into societal practices is becoming more pervasive. Moreover, the digitalised services provided by governmental organisations and companies are governed by an increasing amount of laws and regulations, requiring highly adaptable compliance practices. A potential solution is to automate compliance using software. However, automating compliance is difficult for various reasons. Legal practices involve subjective processes such as interpretation and qualification. New laws and regulations come into effect regularly and laws and regulations, as well as their interpretations, are subjected to constant revision. In addition, computational reasoning with laws requires a cross-disciplinary process involving both legal and software expertise.This paper reflects on the domain-specific language eFLINT developed to experiment with novel solutions to these challenges. Specifically, the language has been developed to experiment with the abstract syntax and semantics of a language supporting different types of reasoning for various applications. The language combines declarative and procedural elements, formalises connections between legal concepts and computational concepts, and is designed to automate compliance checks before, during and after a software system runs. The various design goals and applications areas for the language give rise to (conflicting) requirements. This paper presents and reflects on the current design of the language by recalling applications and requirements. As such, this paper reports on results and insights of an investigation that can benefit language developers within the field of automated compliance.
Vibe coding is an emerging software engineering paradigm in which developers express high-level intent while large language models (LLMs) generate code. This paper proposes VC-AWG (Vibe Coding-based Automated Website Generation), a method for systematically generating complete website functionalities from heterogeneous artifacts, including use case specifications, Figma-based user interface (UI) designs, API contracts, a predefined codebase, and coding rules. VC-AWG leverages LLMs' ability to interpret structured specifications and design-related inputs - such as layout, color, style, and links - and to produce code in a controlled format. The method adopts a two-phase workflow: first, constructing structured coding prompts from use cases, UI designs, and API contracts; second, synthesizing source code based on these prompts, the existing codebase, and coding rules. Experiments on a Personal Financial Management website show that VC-AWG reduces development time to an average of 21.1 min per use case, achieving a 97.3% reduction compared to manual programming, demonstrating its effectiveness and scalability.
This study presents a machine learning-based approach for detecting code smells in Android applications. An open-source dataset containing size, complexity, object-oriented, and Android-specific code metrics was used in the study. The dataset consists of 629 instances in total, and the prevalence rates of the eight code smells range from 26.23% to 75.36%. This indicates that the problem involves a moderate level of class imbalance. To evaluate the contribution of Android-specific metrics, an ablation analysis was conducted on four different feature sets. These feature sets were constructed from classical metrics, Android-specific metrics, a configuration excluding metrics that may carry application-level information leakage risk, and a set including all metrics. In addition, to prevent classes belonging to the same application from appearing simultaneously in both the training and test partitions, the evaluation process was carried out using package-based group-aware nested cross-validation. Eight classification algorithms were evaluated: Gaussian Naive Bayes, Extra Trees, Random Forest, Logistic Regression, Multi-Layer Perceptron, K-Nearest Neighbors, Linear Discriminant Analysis, and Quadratic Discriminant Analysis. The results show that the Random Forest model achieved the highest average F1 score for many code smells, while the Extra Trees model stood out particularly for the Swiss Army Knife smell. The average-rank and post-hoc analyses revealed that Random Forest was generally the strongest model, although this superiority was not equally statistically significant against all other models. The ablation results indicate that the strongest discriminative signal generally comes from classical software metrics, while Android-specific metrics provide a complementary contribution for certain smells. The findings demonstrate that machine learning techniques provide an effective and practical approach for code smell detection in Android applications.
Task-oriented chatbots help users complete specific goals such as ordering products. We recently proposed Taskyto, a domain-specific language (DSL) for building LLM-based task-oriented chatbots. Although Taskyto simplifies development, it remains challenging for non-experts due to complex installation, required DSL knowledge, and dedicated infrastructure to run the chatbots.To address these limitations, we present Bot-Craft, a low-code platform for creating and deploying Taskyto chatbots, augmented with an intelligent assistant that generates Taskyto code from natural language requests. We report on experiments demonstrating the assistant’s usability, effectiveness, performance, and accuracy in supporting chatbot development.
Sorting algorithms are essential in computing applications, yet their practical performance varies across programming languages and input data structures. Existing studies often focus on single-language implementations or limited datasets, leaving a gap in understanding cross-language behavior under diverse input patterns.This study presents a comparative evaluation of six sorting algorithms—Bubble, Heap, Insertion, Merge, Quick, and Selection Sort—implemented in C, C++, Go, Java, PHP, and Python. Experiments were conducted using identical arrays of 100,000 elements across six input patterns, including ascending, descending, nearly sorted, random, duplicates, and repeated patterns. Execution times were analyzed using the Coefficient of Variation (CV), Relative Slowdown Factor (RSF), and Pattern Sensitivity Coefficient (PSC).The results show that programming language environment has a dominant influence on execution efficiency. C and C++ deliver the fastest performance, followed by Go and Java, while PHP and Python exhibit substantially higher runtimes due to interpreter and runtime overhead. Among algorithms, Heap Sort and Merge Sort provide the most consistent performance across input patterns, whereas Quick Sort performs best on random data but shows sensitivity to ordered inputs. Insertion Sort is highly efficient for nearly sorted arrays but exhibits large performance variation, while Bubble and Selection Sort remain inefficient across all environments.The most effective performance is achieved when robust algorithms are paired with low-overhead languages, particularly Heap Sort and Merge Sort in C and C++. The empirical findings are further supported by theoretical bounds derived from decision-tree complexity and factorial approximations, providing mathematical grounding for observed performance trends.This study provides a structured cross-language benchmarking framework and practical guidance for selecting efficient sorting strategies in real-world computing environments.
Software quality measurement in object-oriented systems relies on structural code metrics that capture key design aspects such as complexity, coupling, cohesion, inheritance, and polymorphism (CCCIP). However, many existing complexity metrics fail to capture the fine-grained structural characteristics of object-oriented code, limiting their effectiveness for software quality assessment and software defect prediction (SDP). Although recent studies increasingly employ semantic features extracted using deep learning techniques, the need for more expressive structural metrics remains significant. To address this limitation, this work decomposes code complexity into four hierarchical levels: class complexity, method complexity, field complexity, and instruction complexity. Based on this decomposition, a new complexity metric suite consisting of seven metrics that collectively cover 44 complexity aspects is proposed. Among these, 27 aspects capture instruction-level complexity derived from expression trees constructed using abstract syntax trees (ASTs). The proposed metric suite is integrated with machine learning techniques to develop a framework for software defect prediction. The effectiveness of the proposed approach is validated through discrimination power and multicollinearity analysis and evaluated on 38 versions of 10 open-source projects. Experimental results from 1,406 experiments demonstrate that the proposed framework improves cross-project defect prediction performance, achieving 9.5% higher ROC-AUC and 7.9% higher F1-score compared with state-of-the-art methods.
Domain-specific languages enable concise and expressive means of programming within a selected domain, resulting in improved productivity and maintainability when compared to general-purpose languages. Although various implementation techniques exist for defining domain-specific languages, it remains a complex and resource-intensive task that typically requires advanced expertise in language engineering. Therefore, there is a growing need to simplify domain-specific language development. In particular, this work seeks to address this by providing a lightweight, extensible framework that abstracts away low-level language concerns and enables effortless creation of a new domain-specific language. This paper introduces DomainBuilder, a C++-based framework centered around an extensible interpreter architecture. The framework enables the definition of domain-specific abstractions using S-expressions extended with user-defined operators. It provides predefined general-purpose programming constructs that can interoperate seamlessly with newly introduced domain-specific constructs. Its practical applicability is demonstrated through an implementation of a domain-specific language in the domain of data pipelines. DomainBuilder enables efficient and modular construction of domain-specific languages, supporting language composability. It provides an extensible environment that can serve as a foundation for further exploration of extensible interpreter architectures.
This paper presents the TeMDA framework, designed to simplify the incorporation of GDPR compliance into software projects. It is based on a meta-model that supports GDPR concepts, accompanied by OCL rules with embedded legal expert knowledge to validate compliance. The meta-model uses a minimal set of meta-classes for easy learning while being sufficient to validate real data usage scenarios. Its vocabulary is designed to be understandable to software developers, employing common terms from information systems and natural languages. Development was supervised by a legal expert. The framework is implemented using Java, Eclipse Modeling Framework, Ecore, OCL, and aspect-oriented programming (AOP). To minimize the need for developers to learn new tools or create formal security policy models, TeMDA’s DSML features a concrete syntax based on Java annotations. This approach facilitates seamless integration into existing development workflows, allowing teams to annotate their code at points where GDPR-relevant data management occurs. Subsequently, aspects dynamically generate the privacy model, which is validated using OCL rules. AOP enables additional functionality to be incorporated into existing projects without modifying their core codebase, making TeMDA applicable to both new and legacy systems. TeMDA was evaluated in three phases across banking, healthcare, and library management systems. Its quality characteristics were discussed in relation to the Framework for Qualitative Assessment of Domain-Specific Languages (FQAD). The evaluation confirmed TeMDA’s applicability in various real-world scenarios, demonstrating that GDPR requirements can be integrated into existing systems with minimal code changes and in a short timeframe. Feedback from developers in the third phase led to improvements in TeMDA’s flexibility.
Code review represents an essential process for contemporary software development because it requires extensive time to improve code quality through bug detection and knowledge transfer. Learning-based methods which include transformer models demonstrate strong performance in automating code review because they implement multiple learning-based techniques according to studies which show positive results with CodeBERT. but they create challenges because they need to understand both structured and time-based elements of code changes to develop useful feedback for review purposes. This disconnect drives the desire to have a common structure, jointly modeling semantics and temporal code development, to fully automate the review of code. In this paper, propose an automated code review framework that integrates CodeBERT, a transformer-based pre-trained language model, with a Multi-Anchor Space-Aware Temporal Convolutional Neural Network (MASATCNN). The proposed framework is designed to address three key code review tasks in a unified manner: code change quality estimation, review comment classification and generation, and code refinement. By combining contextual semantic embeddings with space-aware temporal feature extraction, the framework effectively captures both fine-grained code semantics and structural evolution patterns. Evaluate the proposed approach on multiple benchmark datasets and compare it with classical baselines and recent state-of-the-art methods, including advanced transformer-based and large language model–driven approaches. The experimental findings prove that the suggested framework is always superior to the competing methods in all the tasks with up to 4 to 6% points improvement in classification accuracy, up-to 1 point higher BLEU scores and human-rated relevance and informativeness in comment generation, and significant improvements in the accuracy of the selected refinement codes. These findings indicate the efficiency of a combination of semantic and temporal modeling to automated code review and show how the proposed framework can aid with scalable and high-quality software development processes.
Distributed transactions that access multiple replicated objects face scalability issues when each operation is executed under strong consistency. Weakening consistency levels for some operations may improve performance, particularly for replicated data types such as CRDTs. However, using operations with different consistency levels within the same transaction complicates reasoning about correctness. In this work, we assume that correct transactions are serializable, meaning that the actual execution of a transaction is equivalent to a sequential execution without interleaving operations with equivalent behavior. For concurrent transactions, locks on shared locations can be used to avoid conflicts. However, if the locks are not chosen wisely, performance can be negatively affected (due to excessive locking) or isolation can be compromised (due to insufficient locking).This paper proposes a type system that statically records information about accessed reference locations to safely approximate the required locks to ensure transaction isolation. Additionally, the type system tracks the information flow, enforcing a non-interference property between data accessed under different consistency levels. This allows the type system to enforce transaction serializability and reorder operations with weak consistency. To enhance scalability, we introduce commutative operations to reduce coordination among replicas.We formalize the type system for a typed concurrent lambda calculus with shared references, consistency labels, and transactions. We prove type soundness and the serializability of transactions by demonstrating the equivalence of the concurrent language with a language where transactions are serialized in a trivial manner.
This paper introduces a novel technique for synthesizing imperative programs that meet behavioral specifications given in the form of assumptions and assertions (logic formulas). In particular, we combine basic statement-directed enumerative search, abstract interpretation-based static analysis for pruning the search space, and expression-directed enumerative search via (incremental) SMT-based mutations to efficiently explore all candidate complete programs generated from an input program template (with statement and expression holes) until a solution is found. Firstly, the algorithm uses a basic enumerative search through the space of all possible statements, thus filling in all statement holes. In effect, we obtain partial programs with only missing (arithmetic and Boolean) expressions, which are subsequently classified by an abstract static analysis either as potential solutions or as definite failures. Finally, we repeatedly mutate the missing expressions in potential solutions and check if the resulting complete programs become bounded correct with respect to the given assertions. To efficiently explore the big state space of mutants, we call SAT and SMT solvers in an incremental way.We have implemented our logic formula-based technique for imperative-program synthesis in a prototype tool and evaluated it on a set of introductory C programs. The experimental results confirm the effectiveness of our technique for synthesizing various interesting C programs from assumptions and assertions.
Python is a widely adopted programming language celebrated for its ease of use, dynamic typing, and strong community support. Despite these advantages, Python presents challenges when considered for safety-critical applications, notably those in airborne systems. Concerns arise from performance limitations, limited compile-time checking, and dynamic features that may impact reliability in environments where failures can have severe consequences. Airborne systems, with their stringent safety requirements, provide a context in which these challenges can be critically examined.This study evaluates Python’s alignment with the objectives defined in DO-178C (Software Considerations in Airborne Systems and Equipment Certification). By analyzing Python’s core characteristics against these rigorous standards, we highlight potential compliance gaps and practical challenges that may hinder its use in safety-critical contexts.In addition, we perform a comparative analysis between Python and Rust—a modern systems programming language noted for its safety guarantees and performance. Rust was selected not as a replacement for established baselines such as Ada, C, and C++, but as a complementary point of comparison illustrating how a newer, safety-oriented compiled language contrasts with Python’s interpreted model. Our findings indicate that Python lacks compile-time error checking, exhibits delayed signal handling, and has limited optimization capabilities, which together may affect its performance and reliability. Potential enhancements such as Just-In-Time (JIT) compilation, advanced static analysis, and robust type-checking tools are recommended to mitigate these issues. Overall, our study emphasizes both the strengths and limitations of Python and suggests pathways to improve its viability for safety-critical use.
This study examines the first two introductory computer science courses (CS1 and CS2) at the world's top universities, focusing on the choice of programming languages and paradigms, assessment types and weights, and policies regarding student use of AI tools. Data were compiled from 150 programming courses across 83 institutions ranked in the Shanghai 2023 Global Ranking of Academic Subjects for Computer Science & Engineering. The analysis reveals that the prevailing languages are Python in CS1 (32.5%) and Java in CS2 (56.7%). Typical transitions from CS1 to CS2 involve moving from Python or C to Java. There are some regional preferences: Asian institutions favor lower-level languages like C and C++, whereas European universities explore functional programming languages like Haskell. Regarding programming paradigms, CS1 emphasizes imperative approaches, sometimes introducing object-oriented concepts later in the course, while CS2 consolidates object-oriented programming. However, some CS1 courses adopt a functional paradigm. Course assessments are typically divided into several categories, with a preference for exams and various types of continuous assessments. However, there is also significant use of projects, quizzes, and labs. Examinations usually have the highest weight in the final grade. Course-level policies on students' use of generative AI tools reveal very different approaches, from complete prohibition to active encouragement. These findings offer valuable insights into how leading universities approach programming education in a multidimensional view that includes languages, paradigms, assessments, and AI tools policies.
The increasing use of GPS-enabled mobile devices and the popularity of location-based services have fueled demand for spatial keyword (SK) queries, which fuse a geographic location with descriptive text. To meet this demand, this paper proposes an improved in-memory IR-tree structure for efficiently storing and querying spatio-textual data. The research details the structure’s design and implementation, alongside efficient in-memory query algorithms, a novel algorithm for the spatio-textual similarity join query. Exhaustive experiments with real-world datasets demonstrate that the proposed in-memory IR-tree and its algorithms offer excellent performance, significantly accelerating the processing of all tested SK queries.
Software design smells refer to structural abnormalities in a software system that negatively impact maintainability and evolution. Prior research relies on structural metrics for software smell prediction and did not consider the evolutionary aspect. This paper proposes an evolutionary and structural metrics-based method for predicting design smells. A dataset has been curated using multiple versions of Java projects. The proposed method uses ensemble classifiers for classification of design smells, and findings show that adding evolutionary features with structural makes predictions more accurate. In all the design smells, both evolutionary and structural metrics together work better than using structural metrics alone.
Polymorphic type is an important feature in most strongly typed programming languages. They allow functions to be written in a way that can be used with different data types, while still enforcing the relationship and constraints between the values. However, programmers often find polymorphic types difficult to use and understand, and tend to reason in terms of concrete types. We propose GeckoGraph, a graphical notation for types. GeckoGraph aims to complement traditional text-based type notation by making reading, understanding, and comparing types easier. We conducted a large-scale user study comparing GeckoGraph to text-based type notation. To our knowledge, this is the largest controlled user study on functional programming ever conducted. The results show no overall significant differences in task completion time or success rate. However, we observed a modest improvement in success rate among beginner participants. For the most challenging task, GeckoGraph improved success rates by 14.5% for beginners and 11.2% for less experienced users. These findings suggest that GeckoGraph has potential as a teaching and learning aid for polymorphic type systems.
Programming concepts from functional programming have grown in popularity and have been introduced in object-oriented programming. Among these concepts, immutability is a core concept of functional programming, which brings advantages to software development. However, introducing immutability in object-oriented programming languages presents some challenges. Problem: One of these challenges, in the concept of inheritance, is overriding of non-destructive mutators. Mutators are necessary for updating data as a software is running. Non-destructive mutators are mutators on immutable objects, which return new objects instead of modifying the receiver. When inheriting non-destructive mutators, a naive implementation will yield code duplication and have code scalability issues. Contribution: We analyze an example of overriding non-destructive mutators, discuss the challenges, and propose a solution that takes the form of a new design pattern, inspired from the Factory Method pattern. We also discuss the advantages and limitations of this pattern, as well as implementations in eight languages (Clojure, Common Lisp, C#, Java, Kotlin, OCaml, Rust, and Scala). We finally identify and discuss the language features that mostly affect the implementation of this pattern, and present a language extension to Common Lisp to demonstrate the effects of those features on the implementation. Conclusion: Our proposed design pattern helps reduce the code duplication and improve the code scalability of a naive implementation of inherited non-destructive mutators. However, using a language which includes features for functional updating is required to completely remove the code scalability issues of the implementation. We conclude that object-oriented programming languages should consider adding functional updating to their language features to better support their new functional programming features.
