This article presents a description of a software service for analyzing text information for the formation of an OWL ontology. This software service analyzes the state of complex technical systems. The work describes ...
详细信息
In recent years, scripting languages such as JavaScript and Python have gained a lot of traction due to their flexibility, which allows developers to write concise code in a short amount of time. However, this flexibi...
详细信息
ISBN:
(数字)9798400712487
ISBN:
(纸本)9798400712487
In recent years, scripting languages such as JavaScript and Python have gained a lot of traction due to their flexibility, which allows developers to write concise code in a short amount of time. However, this flexibility is achieved via weak, dynamic typing, which fails to catch subtle bugs that would be prevented by a compiler, in static typing. Gradual-type systems like TypeScript emerged as a solution that combines the best of both worlds, allowing developers to annotate parts of their code with optional type hints. Nonetheless, most practical deployments of such systems are unsound, limiting themselves to static checks and not performing residual runtime checks that help enforce type hints uniformly. This is a missed automation opportunity that offloads the burden on developers, who still need to perform explicit type checks at transition points between untyped and typed code so that values at runtime obey the type hints. Failure to do so can result in subtle type inconsistency bugs, and when user input is involved, it can render input validation mechanisms ineffective, resulting in type confusion problems. In this work, we study the relation between gradual typing and type confusion. Our main hypothesis is that the type hints in the code can mislead developers into thinking they are enforced consistently by the compiler, resulting in a lack of explicit runtime checks that ensure type safety. We perform a large empirical study with 30,000 open-source repositories to statically analyze if and how they use gradual typing and to what extent this influences the presence of explicit type checks. We find that many projects feature gradually typed code, but usually only in small portions of their code base. This implies the presence of many points in the code base where developers must add explicit type checks, i.e., at the transition points between unannotated and annotated code. Our results further indicate that gradual typing may have a deteriorating effect when pa
Because of its efficiency and lightweight design, the Message Queue Telemetry Transport (MQTT) protocol is widely used in Internet of Things (loT) and messaging systems. However, despite its widespread use, guaranteei...
详细信息
Optical Character Recognition, or OCR, is a tool that could apprehend textual content in photographs or scanned documents and convert it into system-readable textual content. To recognize and extract information from ...
详细信息
Dynamic Wireless Charging systems for electric vehicles offers a revolutionary approach to EV charging, enabling vehicles to charge while in motion and overcoming the limitations of stationary wireless charging. Despi...
详细信息
Cyberphysical systems with autonomous functions are complex pieces of software, consisting of many components, some of which implement autonomous functionality and some may use AI or machine learning algorithms. Softw...
详细信息
ISBN:
(纸本)9798350326970
Cyberphysical systems with autonomous functions are complex pieces of software, consisting of many components, some of which implement autonomous functionality and some may use AI or machine learning algorithms. software bugs in an autonomous system are of particular concern, as they can have catastrophic consequences. However, detailed studies based on empirical data are rare and therefore these bugs are not well understood. This paper aims to contribute towards filling that gap by investigating the software changes and bugs in Autonomy Operating System (AOS) for Unmanned Aircraft systems (UAS), which consist of 26 components containing about 103,000 lines of code and having a total of 772 bugfixes. Based on the data extracted from the code repository and semi-structured interviews with the developers of AOS, we explore the differences among autonomous software components, components developed using Model-based softwareengineering, and reuse with respect to change proneness, fault proneness, distribution of bugfixes among AOS components and files of these components, and characteristics of bugs of different AOS components. Our results show that the autonomous components were significantly more change prone (measured in number of commits and code churn) and fault prone (measured in bugfixes per KLoC) than non-autonomous components. The distribution of the locations of bugfixes was skewed, both at component and file level (i.e., a small number of components / files contained the majority of bugs). These evidence-based findings provide important insights to researchers and practitioners alike and can be used to efficiently improve the quality and reliability of autonomous systems.
Autonomous driving technology is progressing rapidly, largely due to complex End-To-End systems based on deep neural networks. While these systems are effective, their complexity can make it difficult to understand th...
详细信息
The adoption of runtime monitoring has historically been limited to experts, primarily due to the intricate complexities associated with formal notations and the verification process. In response to this limitation, t...
详细信息
In modern software development, the early detection of defects is critical for ensuring the reliability and quality of softwaresystems. However, software defect prediction (SDP) poses significant challenges, mainly w...
详细信息
ISBN:
(纸本)9783031837890;9783031837906
In modern software development, the early detection of defects is critical for ensuring the reliability and quality of softwaresystems. However, software defect prediction (SDP) poses significant challenges, mainly when dealing with heterogeneous datasets comprising different feature types. Heterogeneity in the data can lead to class imbalance and hinder the performance of traditional SDP models. The proposed model integrates Generative Adversarial Networks (GAN) with Support Vector Machines (SVM) to predict software defects in heterogeneous datasets. The methodology involves several key steps: First, GANs are used to generate synthetic data samples to address class imbalance issues inherent in heterogeneous datasets. The synthetic, and original data are then utilized to train an SVM classifier, which is well-suited for handling complex data structures and providing robust predictions. The model's performance is evaluated using metrics such as precision and recall demonstrating its effectiveness in software defect prediction. The experimental results indicate that the GAN-SVM approach effectively manages heterogeneous datasets, significantly improving the precision and recall rates compared to traditional SDP models. Specifically, the model achieved a precision of 98.00% for the CM1 dataset and 99.00% for the KC1 dataset, along with recall rates of 98.00% and 99.00% for CM1 and KC1, respectively. These findings underscore the GAN-SVM model's robustness and superior performance in predicting software defects across diverse datasets. The proposed model offers significant improvements in precision and recall, providing valuable insights into the potential of combining these techniques for better defect prediction in softwaresystems. Implementing GAN-SVM in software development pipelines could markedly improve defect prediction, aiding software engineers in maintaining high-quality systems.
More complex software solutions are in greater demand in today's software business due to the convergence of evolving technology and ever-changing consumer expectations. Because they offer early software delivery ...
详细信息
暂无评论