Search

Blockchain is a cross‐cutting technology allowing interactions among untrusted entities in a distributed manner without the need for involving a trusted third party. Smart contracts (i.e., programs running on the blockchain) enabled organizations to envision and implement solutions to real‐world problems in less cost and time. Given the immutability of blockchain and the lack of best practices for properly designing and developing smart contracts, it is crucial to assure smart contract quality before deployment. With the help of an exploratory survey involving developers and researchers, this paper identifies the practices and tools used to develop, implement, and evaluate smart contracts. The survey received 55 valid responses. Such responses indicate that (i) inefficiencies may occur during the development cycle of a smart contract, especially regarding requirements specification, design, and testing phases, and (ii) the lack of a shared standard to evaluate the functional quality of implemented smart contracts. To start coping with these issues, the adoption of functional suitability assessment measures recommended by the ISO/IEC 25000 standard, widely used in software engineering, is proposed by adapting them to the context of smart contracts. Through some examples, the manuscript also illustrates how to measure the functional completeness and correctness of smart contracts. The proposed procedure to measure smart contract functional suitability brings advantages to both developers and users of decentralized finance or non‐fungible tokens platforms, data marketplaces, or shipping and real estate services, just to mention a few. In particular, it helps (i) better outline the responsibilities of smart contracts, (ii) uncover errors and deficiencies of smart contracts in the early stages, and (iii) ensure that the established requirements are met. [ABSTRACT FROM AUTHOR]

Presented as a research challenge in 2001, the Semantic Web (SW) is now a mature technology, used in several cross‐domain applications. One of its key benefits is a formal semantics of its RDF data format, which enables a system to validate data, infer implicit knowledge by automated reasoning, and explain it to a user; yet the analysis presented here of 71 RDF‐based SW systems (out of which 17 reasoners) reveals that the exploitation of such semantics varies a lot among all SW applications. Since the simple enumeration of systems, each one with its characteristics, might result in a clueless listing, we borrow from Software Engineering the idea of maturity model, and organize our classification around it. Our model has three orthogonal dimensions: treatment of blank nodes, degree of deductive capabilities, and explanation of results. For each dimension, we define 3–4 levels of increasing exploitation of semantics, corresponding to an increasingly sophisticated output in that dimension. Each system is then classified in each dimension, based on its documentation and published articles. The distribution of systems along each dimension is depicted in the graphical abstract. We deliberately exclude resources consumption (time and space) since it is a dimension not peculiar to SW. This article is categorized under:Fundamental Concepts of Data and Knowledge > Knowledge RepresentationFundamental Concepts of Data and Knowledge > Explainable AI [ABSTRACT FROM AUTHOR]

In the context of its initiative to promote the adoption of model‐based approaches in the development of present and upcoming missions, the European Space Agency (ESA) organised this year its annual workshop on Model‐Based Space Systems and Software Engineering (MBSE2023) at its European Space Research and Technology Centre (ESTEC) premises. The aim of this year's workshop was to investigate how the model‐based systems engineering community could contribute to bridging the gap with domain‐specific model‐based approaches used in subsystem design. The World Café Method was used to facilitate the group discussions, the outcomes of which are summarized and presented in this paper. [ABSTRACT FROM AUTHOR]

Software requirements management is vital in the system analysis stage, so the methods used in software development companies in Colombia were analyzed. The study aimed to explore the techniques used in the software development industry in Colombia for requirements management. It was carried out through a mixed approach of descriptive depth, interviewing five Chief Information Officers (CIOs) in Bogota, Medellin, and Sincelejo. Natural language processing techniques were used for the analysis, finding similarities among the interviewees in terms of software requirements and a positive perception towards requirements analysis; however, differences in requirements management were identified. Companies use hybrid methodologies to develop software projects, integrating principles of agile methodologies and methods such as Scrum and Kanban, while keeping traditional approaches as a base. This trend has an impact on requirements management since it allows greater flexibility and adaptability in the project development process. [ABSTRACT FROM AUTHOR]

This paper presents a migration from relational databases (RDB) to NoSQL databases, leveraging a data model that utilizes concepts such as objects, semantic enrichment, and metadata. It addresses the limitations of previous approaches and extends them to overcome issues encountered in the relational model, allowing for simpler and faster handling of large datasets. This approach eliminates problems related to joins, incorporates the concepts of references and embedded documents, and includes a comparative study between our approach and other methods for migrating from RDB to NoSQL. This comparison covers aspects such as structural changes, insertion rates, selection, and deletion. Automated migration uses document-oriented nested types to store related data in one database record. This simplifies the design phase and reduces queries and updates, speeding up user responses. This research provides a comprehensive summary of the achievement of migrating from a relational database to a document-oriented NoSQL database. The essence of this migration lies in its automatic nature, aimed at transforming the pre-existing relational model into an object-oriented model. This transition aims to align the database structure with MongoDB's documentoriented paradigm, ensuring optimal integration and efficient utilization of the technology's features. This research significantly distinguishes itself from previous work, primarily due to its ability to facilitate automatic database migration. It accomplishes this task by autonomously identifying object concepts, including those related to inheritance. This functionality is unique and represents a significant advancement, as no other migration method has thus far been capable of performing this automatic detection of object concepts, especially inheritance. The result of the migration provides several advantages in terms of reducing record count, particularly as we deal with massive data sets, and in terms of the time required for data deletion and insertion. A prototype shows how effective this automated approach is. Maintain that the migration process is automated. [ABSTRACT FROM AUTHOR]

A frequent problem in building initial software effort estimation (SEE) models is the existence of many missing values in historical software engineering datasets. Due to human intervention, this is caused by frequent damage to software project data. Loss of information and bias in data analysis due to missing data are serious problems. This study proposes a method to estimate missing data using a masked-denoising autoencoder (Masked- DAE) with L2-norm regularization, which can handle various types of data, missing patterns, proportions, and distributions. In this study, Cocomo81 and ISBSG-IFPUG datasets from open-source repositories were used. This experiment involved five missing data techniques, eight missing data rates (from 10% to 80%), and two missingness mechanisms (MCAR: missing completely at random and MNAR: missing not at random). The results show that the proposed Mask-DAE method has the best imputation performance in terms of imputation errors by outperforming DAE, k-nearest neighbor imputation (kNNI), random forest (RF) imputation, multiple imputations by chained equation (MICE), mean imputation and mode imputation. We find that the prediction error rate increases with the rate of missing data. Furthermore, prediction errors generated by MCAR mechanisms are lower than those generated by MNAR. Nevertheless, our method can reduce the model variance, which results in lower generalization error. [ABSTRACT FROM AUTHOR]

(Source) code search is widely concerned by software engineering researchers because it can improve the productivity and quality of software development. Given a functionality requirement usually described in a natural language sentence, a code search system can retrieve code snippets that satisfy the requirement from a large-scale code corpus, e.g., GitHub. To realize effective and efficient code search, many techniques have been proposed successively. These techniques improve code search performance mainly by optimizing three core components, including query understanding component, code understanding component, and query-code matching component. In this article, we provide a 3-dimensional perspective survey for code search. Specifically, we categorize existing code search studies into query-end optimization techniques, code-end optimization techniques, and match-end optimization techniques according to the specific components they optimize. These optimization techniques are proposed to enhance the performance of specific components, and thus the overall performance of code search. Considering that each end can be optimized independently and contributes to the code search performance, we treat each end as a dimension. Therefore, this survey is 3-dimensional in nature, and it provides a comprehensive summary of each dimension in detail. To understand the research trends of the three dimensions in existing code search studies, we systematically review 68 relevant literatures. Different from existing code search surveys that only focus on the query end or code end or introduce various aspects shallowly (including codebase, evaluation metrics, modeling technique, etc.), our survey provides a more nuanced analysis and review of the evolution and development of the underlying techniques used in the three ends. Based on a systematic review and summary of existing work, we outline several open challenges and opportunities at the three ends that remain to be addressed in future work. [ABSTRACT FROM AUTHOR]

Testing Autonomous Driving Systems (ADSs) is crucial to ensure their reliability when navigating complex environments. ADSs may exhibit unexpected behaviours when presented, during operation, with driving scenarios containing features inadequately represented in the training dataset. To address this shift from development to operation, developers must acquire new data with the newly observed features. This data can be then utilised to fine tune the ADS, so as to reach the desired level of reliability in performing driving tasks. However, the resource-intensive nature of testing ADSs requires efficient methodologies for generating targeted and diverse tests. In this work, we introduce a novel approach, DeepAtash-LR, that incorporates a surrogate model into the focused test generation process. This integration significantly improves focused testing effectiveness and applicability in resource-intensive scenarios. Experimental results show that the integration of the surrogate model is fundamental to the success of DeepAtash-LR. Our approach was able to generate an average of up to 60× more targeted, failure-inducing inputs compared to the baseline approach. Moreover, the inputs generated by DeepAtash-LR were useful to significantly improve the quality of the original ADS through fine tuning. [ABSTRACT FROM AUTHOR]

With the continuous advancement of quantum computing (QC), the demand for high-quality quantum programs (QPs) is growing. To avoid program failure, in software engineering, the technology of automatic program repair (APR) employs appropriate patches to remove potential bugs without the intervention of a human. However, the method tailored for repairing defective QPs is still absent. This article proposes, to the best of our knowledge, a new APR method named UnitAR that can repair QPs via unitary operation automatically. Based on the characteristics of superposition and entanglement in QC, the article constructs an algebraic model and adopts a generate-and-validate approach for the repair procedure. Furthermore, the article presents two schemes that can respectively promote the efficiency of generating patches and guarantee the effectiveness of applying patches. For the purpose of evaluating the proposed method, the article selects 29 mutated versions as well as five real-world buggy programs as the objects and introduces two traditional APR approaches GenProg and TBar as baselines. According to the experiments, UnitAR can fix 23 buggy programs, and this method demonstrates the highest efficiency and effectiveness among three APR approaches. Besides, the experimental results further manifest the crucial roles of two constituents involved in the framework of UnitAR. [ABSTRACT FROM AUTHOR]

Background: Research shows that emotional intelligence (EI) should be used alongside cognitive intelligence during requirements change (RC) handling in Software Engineering (SE), especially in agile settings. Objective: We wanted to study the role of EI in-depth during RC handling. Method: We conducted a mixed-methods study (an interview study followed by a survey study) with 124 software practitioners. Findings: We found the causal condition, intervening condition and causes lead to key direct consequences of regulating own emotions, managing relationships, and extended consequences of sustaining productivity, setting and sustaining team goals. We found several strategies of supporting EI during RC handling. Further, we found strong correlations between six strategies and one being aware of own emotions, regulating own emotions, sustaining team productivity, and setting and sustaining team goals. Conclusion: Empathising with others and tracking commitments and decisions as a team are key strategies that have strong correlations between managing emotions, between sustaining team productivity, and between setting and sustaining team goals. To the best of our knowledge, the framework we present in this paper is the first theoretical framework on EI in SE research. We provide recommendations for software practitioners to consider during RC handling. [ABSTRACT FROM AUTHOR]

This paper introduces the El Greco Platform, a Python programming platform for distance learning that employs an educational robot. This website allows prospective learners to remotely control El Greco, a social humanoid robot designed to be cost‐effective, simple to construct, and appropriate for use in education. El Greco is capable of performing multiple tasks, including combined movements. These Robot capabilities can be programmed using either Python code or the Blockly library, which adds an editor to an application that visualizes coding concepts as interlocking blocks. Programming a robot appears to be a significantly more effective and creative method for students to learn a programming language. This educational tool was designed primarily for use by students and allows anyone to learn Python while controlling a robot for free. El Greco Platform features gamification elements that increase the enjoyment and engagement of the learning experience while reinforcing the concepts taught. The survey results on students aged 13–18 revealed that the El Greco Platform captivated the study participants and positively affected their attitudes toward programming and robotics. In addition, it significantly impacted their comprehension of programming and motivated them to seek additional opportunities to expand their knowledge of robotics and programming. [ABSTRACT FROM AUTHOR]

Call graphs facilitate various tasks in software engineering. However, for the dynamic language Python, the complex language features and external library dependencies pose enormous challenges for building the call graphs of real projects. Some program analysis techniques used for call graph construction in other languages are impractical for Python. In this paper, we present STAR, a practical technique for the construction of Python static call graphs. We reformulate call graph construction as an entity identification task. STAR leverages inter-module summary and cross-project dependencies to construct a fine-grained entity knowledge base to identify the possible nodes and edges of the call graph in the code, and then construct the call graph. Our evaluation of three benchmarks shows that (1) STAR improves recall in three benchmarks compared to three baseline tools. Especially, STAR improves the recall of reachable nodes and reachable edges compared with the state-of-the-art tool by 11.3% and 9.8%, respectively; (2) STAR achieves comparable performance as three baseline tools in execution time and memory usage and is more efficient in large projects; (3) STAR can be effectively used for the task of detecting vulnerability propagation with real-world cases. We expect our results will attract more exploration of practical methods and improve the application of Python call graphs. [ABSTRACT FROM AUTHOR]

Copyright of Baghdad Science Journal is the property of Republic of Iraq Ministry of Higher Education & Scientific Research (MOHESR) and its content may not be copied or emailed to multiple sites or posted to a listserv without the copyright holder's express written permission. However, users may print, download, or email articles for individual use. This abstract may be abridged. No warranty is given about the accuracy of the copy. Users should refer to the original published version of the material for the full abstract. (Copyright applies to all Abstracts.)