not-yet-known not-yet-known not-yet-known unknown The advancement of Large Language Models (LLM) has also resulted in an equivalent proliferation in its applications. Software design (especially, the development of UI/UX) has gained tremendous benefits in using LLMs as an interface component that extends fixed user stories. However, inclusion of LLM-based AI agents in software design often poses unexpected challenges. The most prominent of these challenges is the uncertainty in understanding what the system does (or its scope). Through the example of UI-based user stories, we provide a comparison against traditional methods and propose a new way to enhance specifications of natural language-based questions that allows for better understanding of the system by specifying its data sources, interfaces and algorithms.

An AVL tree is a binary search tree that guarantees O ( log n ) search. The guarantee is obtained at the cost of rebalancing the AVL tree, potentially after every insertion or deletion. This article proposes a deletion algorithm that decreases the rebalancing required after deletion compared to the rebalancing required after deletion by a previously reported algorithm.

The problem of managing multi-service applications on top of Cloud-Edge networks in a QoS-aware manner has been thoroughly studied in recent years from a decision-making perspective. However, only a few studies addressed the problem of actively enforcing such decisions while orchestrating multi-service applications and considering infrastructure and application variations. In this article, we propose a next-gen orchestrator prototype based on Docker to achieve the continuous and QoS-compliant management of multiservice applications on top of geographically distributed Cloud-Edge resources, in continuity with CI/CD pipelines and infrastructure monitoring tools. Finally, we assess our proposal over a geographically distributed testbed across Italy.

Database Management Systems (DBMSs) are largely used to store, retrieve, and manage the vast amounts of data that modern applications handle. There are various DBMSs available in the industry. While a few studies have examined the co-evolution of DBMSs and application source code, there is a research gap in examining the adoption of DBMSs in real systems. Knowing the most commonly used DBMSs, how frequently they are used together, and their patterns of replacement can assist project managers in making informed decisions about DBMS adoption. Therefore, we conducted a historical investigation of 317 popular open source end-user applications developed in Java and hosted on GitHub. We determined if these projects had, at any point, employed any of the top 50 DBMSs as ranked by DB-Engines. We observed that MySQL is the most utilized relational DBMS, succeeded by PostgreSQL and H2. Considering only non-relational DBMSs, Redis emerges as the predominant choice, with Cassandra trailing behind. Multi-model DBMSs are top-ranked in Infrastructure Management projects. Furthermore, we found different combinations of subsets of 11 DBMSs being used together at the beginning of the project life cycle (e.g., PostgreSQL and MySQL). Halfway through the project life cycle, we found combinations of 25 DBMSs being used together (e.g., MS SQL Server and Oracle). Finally, at the end of the life cycle, this number increases to 29 DBMSs (e.g., Redis and H2). We also investigated the replacements of DBMSs. We mined sequential patterns and discovered 20 situations where projects replaced DBMSs. For example, we could observe 11 replacements of PostgreSQL in 8 projects in our corpus, with MySQL being a dominant replacement choice, having superseded PostgreSQL in four instances. Conversely, no project switched from MySQL to PostgreSQL. In summary, our study offers insights into the patterns of DBMS adoption, co-use, and replacement tendencies.

The response time of a website has an impact on the overall user experience. Slow-loading or unresponsive applications can quickly frustrate and alienate users, leading to dissatisfaction and potentially driving them away. Conversely, fast and efficient applications can greatly enhance user engagement, satisfaction, and ultimately contribute to the success of an online business. The main objective of this work is to check and compare the performance between Node.js and Java Spring Boot, in the context of implementing RESTful applications. REST (Representational State Transfer) has emerged as a dominant architectural style for building web services due to its simplicity, scalability, and compatibility with the stateless nature of the web. To achieve this objective, both implementations were created with an identical business use case, aiming to provide the fundamental CRUD operations (Create, Read, Update, and Delete). To conduct the performance analysis, Apache JMeter tool is used that enables the creation of a diverse set of concurrent virtual users, simulating real-world scenarios to load both applications at regular intervals. By subjecting the applications to varying user loads, it can be assessed how each platform performs under different workloads and identify potential bottlenecks and areas for improvement. The results obtained suggest that Node.js excels in faster response times for HTTP GET, ideal for read operations. However, Spring Boot outperforms Node.js for complex operations like POST, PUT, and DELETE under higher user loads. Both faced challenges at 64000 virtual users, with error rates from 10% to 75%, but Spring showed better error handling. Spring required fewer lines of code, benefiting from its environment and dependencies. Resource utilization in Node.js proved to be efficient with CPU load below 40% even under heavy loads. Spring on the other hand provided better response times, exhibited higher CPU usage at times, suggesting more resource-intensive optimization. The comparison emphasizes the importance of technology stack choice in development, speed and performance. The findings serve as a basis for developers to make informed decisions when selecting the appropriate technology stack based on specific project requirements, workload considerations, and performance expectations.

Edge computing (EC) is an efficient technology that enables end users to achieve the goal of high bandwidth and low latency by offloading computationally intensive tasks from mobile devices to edge servers. However, a major challenge arises when the processing load fluctuates continuously, leading to a performance bottleneck due to the inability to rescale edge node (EN) resources. To address this problem, the approach of task migration is introduced, and the resource constrained model, optimal communication overhead model, and optimal task migration model are built to form a theoretical foundation from which to propose a task migration based resilient framework construction method in EC. With the aid of the domino effect and the combined effect of task migration, a dynamic node-growing algorithm (DNGA) and a dynamic node-shrinking algorithm (DNSA), both based on the task migration strategy, are proposed. Specifically, the DNGA smoothly expands the EN scale when the processing load increases, while the DNSA shrinks the EN scale when the processing load decreases. The experimental results show that for standard benchmarks deployed on an elastic framework, the proposed method realizes a smooth scaling mechanism in the EC, which reduces the latency and improves the reliability of data processing.

A document by Ayad Tareq Imam. Click on the document to view its contents.

Component-based software development has been regarded as one of the newest trends in the software development industry. In some ways, component-based software development focuses on reusability. In fact, high-quality software components refer to components that are highly cohesion internally, and also have the least coupling with other components, or in other words, are independent. Thus, using such components will lead to faster software development. In this way, this study aims to identify reusable components in software. To do this, first, software components were extracted from the source code of software systems. To identify reusable components, an artificial neural network algorithm has been used. On the other hand, the reusable components recognized by the evolutionary particle swarm optimization algorithm have been clustered. In this study, the particle swarm optimization algorithm was modified to apply to clustering problems. Finally, with the help of these clusters, the KNN classifier was trained, and during identifying reused inputs, the cluster to which the input belongs was determined by the classifier. This way, we will have a library of reusable components, where similar components are placed in a cluster. The proposed algorithm was experimentally evaluated on nine open-source software systems belonging to different domains. The results of this study show that the counted software components are potentially reusable and confirm the research findings.

Effort estimation is an important activity in agile software development. The goal of the presented study was to determine the influence of individual competence on software development effort estimation. In particular, we measured both the accuracy of effort estimation and the duration of the estimation process itself, both for three different estimation methods. The subjects of our study were teams of students of a graduate-level software engineering course at the University of Ljubljana, Faculty of Computer and Information Science. Based on the grades that individual students attained in their undergraduate study, we classified each team as ‘high-competence’ or ‘low-competence’ and additionally as ‘heterogeneous’ or ‘homogeneous’ (the criterion here being the variance of the members’ average grades). We found out that there was no significant difference in effort estimation accuracy neither between high-competence and low-competence teams nor between heterogeneous and homogeneous teams, regardless of which estimation method was used. However, high-competence teams spent significantly less time on effort estimation than low-competence ones. Likewise, for two of the employed estimation methods, heterogeneous teams completed effort estimation in a significantly shorter time than homogeneous teams. These results might benefit both academic and professional community.

Solving quadratic equations with radicals on a computer with floating-point arithmetic requires great care to handle correctly all possible parameters. Literature on the subject glosses over the details, often considered as important but tedious to present. As a consequence, most implementations are flawed in one way or another. After having reviewed both the literature and the actual implementations in several programming languages and applications, we present an algorithm inspired from an exposition by Pat Sterbenz from 1974, adapted to take advantage of more recent researches in the field, which leads to a robust quadratic equation solver.

Software architecture determines success or failure in the domain of software development and design. As a system evolves, software architecture erodes. This phenomenon is called architectural erosion. Several studies that focused on various approaches to the problem of architectural erosion have been conducted. As a direct consequence of this, the metrics strategy has emerged as the most widely used solution for architectural erosion. However, providing a comprehensive perception of the elements required to evaluate the phenomenon of architectural erosion with an acceptable level of quality is a challenge. The primary goals of this research, which drew from the prior literature about identifying architectural erosion, were to (1) determine whether various adopted measures approaches determine architectural erosion in order to develop a formal model, and (2) evaluate the construct reliability and construct validity of the model. This research presents a model based on the chosen measures approaches for identifying architectural degradation. This model can be used as the cornerstone for a formal definition of general approaches and adopted metrics. Data was collected from 130 software engineering professionals with experience in architecture erosion and software metrics via a questionnaire-based survey. Structural equation Modelling (SEM) was used to analyse construct reliability, construct validity, and research hypotheses. The results demonstrate a substantial association between all metrics approach classes and architectural erosion, except for architectural complexity and architectural technical debt. Both researchers and practitioners can significantly benefit from this model’s empirical assessment and evaluation, which includes a valuable information in this context.

Team formation in an environment where some relevant parameters are not known in advance is a challenging problem. Communicating automata and distributed algorithms have been used to describe protocols for team formation. A high-level specification provides a mathematical description of a protocol or a program. TLA + is a formal specification language designed to provide high-level specifications of concurrent and distributed systems. The associated model checker known as TLC is capable of model checking the TLA + specifications. Recently formal specification of a team formation protocol is given using TLA + when there is a single initiator (an agent or a robot), that initiates the team formation. Using TLA +, we examine the formal specification for the multiple initiator situation and demonstrate that a composition technique can yield a single monolithic specification for the multiple initiator situation from the single initiator situation specification. We have used models of varying sizes, and the TLC model checker has confirmed that the protocol’s specifications meet certain desired characteristics in each case.

Jupyter Notebook is a popular tool among data analysts and scientists for working with data. It provides a way to combine code, documentation, and visualizations in a single, interactive environment, facilitating code reuse. While code reuse can improve programming efficiency, it can also decrease readability, security, and overall performance. We conduct a large-scale exploratory study of code reuse practices in the Jupyter Notebook development community on the Stack Overflow platform to understand the potential negative impacts of code reuse. Our findings identified 1,097,470 Jupyter Notebook clone pairs that reuse Stack Overflow code snippets, and the average code snippet has 7.91 code quality violations. Through our research, we gain insight into the reasons behind Jupyter Notebook developers' decision to reuse code and the potential drawbacks of this practice.

JSON is a popular standard for data interchange on the Internet. Ingesting JSON documents can be a performance bottleneck. A popular parsing strategy consists in converting the input text into a tree-based data structure—sometimes called a Document Object Model or DOM. We designed and implemented a novel JSON parsing interface—called On-Demand—that appears to the programmer like a conventional DOM-based approach. However, the underlying implementation is a pointer iterating through the content, only materializing the results (objects, arrays, strings, numbers) lazily. On recent commodity processors, an implementation of our approach provides superior performance in multiple benchmarks. To ensure reproducibility, our work is freely available as open source software.