Software Reuse Research Articles

A Context-Based Perspective on Frost Analysis in Reuse-Oriented Big Data-System Developments

The large amount of available data, generated every second via sensors, social networks, organizations, and so on, has generated new lines of research that involve novel methods, techniques, resources, and/or technologies. The development of big data systems (BDSs) can be approached from different perspectives, all of them useful, depending on the objectives pursued. In particular, in this work, we address BDSs in the area of software engineering, contributing to the generation of novel methodologies and techniques for software reuse. In this article, we propose a methodology to develop reusable BDSs by mirroring activities from software product line engineering. This means that the process of building BDSs is approached by analyzing the variety of domain features and modeling them as a family of related assets. The contextual perspective of the proposal, along with its supporting tool, is introduced through a case study in the agrometeorology domain. The characterization of variables for frost analysis exemplifies the importance of identifying variety, as well as the possibility of reusing previous analyses adjusted to the profile of each case. In addition to showing interesting findings from the case, we also exemplify our concept of context variety, which is a core element in modeling reusable BDSs.

Improving reuse during the development process for web systems

Software reuse has emerged as a crucial practice in the software industry, offering significant benefits in time-to-market, and resources management. This is particularly pertinent in web systems development, where the integration of diverse technologies and the varied backgrounds of technical teams pose substantial challenges. The rapid expansion of web systems underscores the urgent need to adopt best practices and methodologies for web system reuse to streamline the development process, reducing effort, cost, and time. This paper aims to identify the key challenges of web system reuse in the context of small and medium-sized software companies in Egypt and Saudi Arabia. Using qualitative research methods, including interviews, focus groups, and participant observations, an empirical study was conducted to examine current reuse practices and understand the root causes of common challenges. Based on the results of the empirical study, a systematic approach was developed to enhance web system reuse during the development process in the context of small and medium-sized software companies in Egypt and Saudi Arabia. The proposed approach addresses critical gaps in current practices, offering practical guidelines to improve efficiency, reduce development time, and enhance overall software quality. This research contributes to the broader discourse on software reuse by providing context-specific insights and adaptable solutions that are relevant to similar markets worldwide.

Effective Hard Negative Mining for Contrastive Learning-based Code Search

Background. Code search aims to find the most relevant code snippet in a large codebase based on a given natural language query. An accurate code search engine can increase code reuse and improve programming efficiency. The focus of code search is how to represent the semantic similarity of code and query. With the development of code pre-trained models, the pattern of using numeric feature vectors (embeddings) to represent code semantics and using vector distance to represent semantic similarity has replaced traditional string matching methods. The quality of semantic representations is critical to the effectiveness of downstream tasks such as code search. Currently, the state-of-the-art (SOTA) learning method uses the contrastive learning paradigm. The objective of contrastive learning is to maximize the similarity between matching code and query (positive samples) and minimize the similarity between mismatched pairs (negative samples). To increase the reusing of negative samples, prior contrastive learning approaches use a large queue (memory bank) to store embeddings. Problem. However, there is still a lot of room for improvement in using negative examples for code search: ① Due to the random selection of negative samples, semantic representations learned by existing models cannot distinguish similar codes well. ② Since semantic vectors in the memory bank are reused from previous inference results and then directly used for loss function calculation without gradient descent, the model cannot effectively learn the negative sample semantic information. Method. To solve the above problems, we propose a contrastive learning code search model with hard negative mining called CoCoHaNeRe: ❶ To enable the model to distinguish similar codes, we introduce hard negative examples into contrastive training, which are negative examples in the codebase that are most similar to positive examples. As a result, hard negative examples are most likely to make the model make mistakes. ❷ To improve the learning efficiency of negative samples during training, we add all hard negative examples to the model's gradient descent process. Result. To verify the effectiveness of CoCoHaNeRe, we conducted experiments on large code search datasets with six programming languages, as well as similar retrieval tasks code clone detection and code question answering. Experimental results show that our model achieves SOTA performance. In the code search task, the average MRR score of CoCoHaNeRe exceeds CodeBERT, GraphCodeBERT, and UniXcoder by 11.25%, 8.13%, and 7.38%, respectively. It has also made great progress in code clone detection and code question answering. In addition, our method performs well in different programming languages and code pre-training models. Furthermore, qualitative analysis shows that our model effectively distinguishes high-order semantic differences between similar codes.

Object-Oriented Fixpoint Programming with Datalog

Modern usages of Datalog exceed its original design purpose in scale and complexity. In particular, Datalog lacks abstractions for code organization and reuse, making programs hard to maintain. Is it possible to exploit abstractions and design patterns from object-oriented programming (OOP) while retaining a Datalog-like fixpoint semantics? To answer this question, we design a new OOP language called OODL with common OOP features: dynamic object allocation, object identity, dynamic dispatch, and mutation. However, OODL has a Datalog-like fixpoint semantics, such that recursive computations iterate until their result becomes stable. We develop two semantics for OODL: a fixpoint interpreter and a compiler that translates OODL to Datalog. Although the side effects found in OOP (object allocation and mutation) conflict with Datalog's fixpoint semantics, we can mostly resolve these incompatibilities through extensions of OODL. Within fixpoint computations, we employ immutable algebraic data structures (e.g. case classes in Scala), rather than relying on object allocation, and we introduce monotonically mutable data types (mono types) to enable a relaxed form of mutation. Our performance evaluation shows that the interpreter fails to solve fixpoint problems efficiently, whereas the compiled code exploits Datalog's semi-naïve evaluation.

Demystifying The Object-Oriented Features Of Popular Object-Oriented Programming Languages.

Background: Indeed, Object-Oriented Programming (OOP) has emerged as one of the major fundamental paradigms in today’s world of software development as it contains principles that enhance modularity, reusability, and maintainability of software. This article explores deeper into some of the facets of OOP aspects as exhibited in some of the most frequently used programming languages ranging from Java, Python, C++, and C# with an intent of offering substantive information to aspects like encapsulation, inheritance, polymorphism, and abstraction. The article synthesizes the ones focusing on the relevance and conceptualization of OOP and problems related to it in the context of learners and practitioners. It also describes strengths and weaknesses of using C++, Python, and Java in relation to OOP while stressing peculiarity of these languages. Some of the core principles of OOP are highlighted such as encapsulation, inheritance, polymorphism, and abstraction and how they are complicated and significant in today’s software engineering. Materials and Methods: There was a presentation of a survey on which the research is based to determine the problems that programmers encounter when applying OOP features using a sample of 80 programmers in the computer science fields in some Nigerian Universities. Results: Findings reveal the significance of understanding OOP concepts in popular languages and suggest ways of increasing developers’ efficiency, minimizing errors, and improving the quality of developed software. Conclusion: Suggestions include a necessity for training and education to enhance software developers' understanding of OOP features. The findings can guide the creation of training materials and courses centered on OOP concepts, aiming to improve software development practices and elevate the quality of software products.

Portfolio Evolution Analysis for SPL Scoping: Unveiling the dynamics with dedicated time-series dashboards

Software Product Line Engineering (SPLE) is a recognized methodology for systematically developing reusable software components and tailored software products for specific market segments. A critical activity within domain engineering is SPL Scoping, aimed at profiling the SPL boundaries and fitting this market segment. Yet, this market is a moving target, which requires SPLs to be proactive in anticipating and addressing future challenges and opportunities. In this setting, rather than all the possible products potentially derived from the SPL’s Feature Model (i.e., the potential portfolio), the subset of products actually deployed is a better indicator of market adoption and customer preferences, and ultimately, of the SPL’s fitness to the market. This study characterizes the phenomenon of ‘deployed portfolio evolution’ in terms of the size and frequency of portfolio changes. We then elaborate on the advantages of utilizing this data source and the necessity for dedicated tools for Portfolio Evolution Analysis integrated within variability managers. To achieve this, we introduce the functional requirements, implementation, and architecture of PortfolioScan, a dashboard for Portfolio Evolution Analysis built on top of pure::variants. The dashboard enables the evaluation of feature usage through time-series charts such as temporal heat maps, line charts, and also a scoping-criteria comparison matrix. Evaluation results (n=13) indicate a positive perception. Practitioners also recognize the benefits of Portfolio Evolution Analysis for Testing Resource Optimization and Configuration Assistance. The ultimate goal of the study is to establish a basis for more responsive and market-oriented decision-making in SPL tasks.

A search-and-fill strategy to code generation for complex software requirements

Context:The realm of software development has seen significant transformations with the rise of Low-Code Development (LCD) and the integration of Artificial Intelligence (AI), particularly large language models, into coding practices. The proliferation of open-source software also offers vast resources for developers. Objective:We aim to combine the benefits of modifying retrieved code with the use of an extensive code repository to tackle the challenges of complex control structures and multifunctional requirements in software development. Method:Our study introduces a Search-and-Fill strategy that utilizes natural language processing (NLP) to dissect complex software requirements. It extracts control structures and identifies atomic function points. By leveraging large-scale pre-trained models, the strategy searches for these elements to fill in the automatically transformed program structures derived from descriptions of control structures. This process generates a code snippet that includes program control structures and the implementations of various function points, thereby facilitating both code reuse and efficient development. Results:We have validated the effectiveness of our strategy in generating code snippets. For natural language requirements involving multifunctional complex structures, we constructed two datasets: the Basic Complex Requirements Dataset (BCRD) and the Advanced Complex Requirements Dataset (ACRD). These datasets are based on natural language descriptions and Python code that were randomly extracted and combined. For the code snippets to be generated, we achieved the best results with the ACRD dataset, with BLEU-4 scores reaching up to 0.6326 and TEDS scores peaking at 0.7807. Conclusion:The Search-and-Fill strategy successfully generates a comprehensive code snippets, integrating essential control structures and functions to streamline the development process. Experimental results substantiate our strategy’s efficacy in optimizing code reuse by effectively integrating preprocessing and selection optimization approach. Future research will focus on enhancing the recognition of complex software requirements and further refining the code snippets.

OPTIMIZATION OF CROSS-PLATFORM APPLICATIONS USING THE REACT LIBRARY

In today's world, with the growing use of mobile devices, the importance of creating cross-platform applications that provide high performance and quality of user experience has increased significantly. Improving the creation of such applications using React and React Native opens up wide opportunities for developers due to the possibility of code reuse, high development speed and ease of innovation, and is especially relevant because it concerns not only the technological aspects of development, but also economic efficiency, quality of user experience and the speed of introducing innovations to the software market. Open source and active community communication allow rapid identification and resolution of issues, development of new features and enhancements, and the sharing of knowledge and experience between developers. This creates a positive environment for innovation and growth, promotes rapid technological progress, and improves the quality of end products. The paper analyzes the key aspects and challenges associated with the creation of cross-platform applications, analyzes the main types of optimizations at different levels of development, including the component level, the state and data level, the level of working with APIs and external data, as well as the loading and code level. Special attention is paid to the integration of synchronous and asynchronous rendering to achieve optimal performance and user experience. Highlights the benefits of flexible state management using state managers, as well as the importance of image and media optimization to improve overall website performance. The article notes the role of the developer community in the process of improvement and innovation. Developers who master these technologies and optimize their application can create products that not only meet the requirements of the time, but also form new standards in the field of mobile and web development. Further research and integration of the latest technologies into the development process of cross-platform applications will have a significant impact on the software industry.

Design and Development of a Flexible Manufacturing Cell Controller Using an Open-Source Communication Protocol for Interoperability

Flexible manufacturing cells provide significant advantages in low-volume mass-customization production but also induce added complexity and technical challenges in terms of integration, control, and extensibility. The variety of closed-source industrial protocols, the heterogeneous equipment, and the product’s manufacturing specifications are main points of consideration in the development of such a system. This study aims to describe the approach, from concept to implementation, for the development of the controller for a flexible manufacturing cell consisting of heterogeneous equipment in terms of functions and communication interfaces. Emphasis is put on the considerations and challenges for effective integration, extensibility, and interoperability. Scheduling and monitoring performed by the developed controller are demonstrated for a manufacturing cell producing microfluidic devices (bioMEMS) that consists of six workstations and a robot-based handling system. Communication between the system controller and the workstations was based on open-source technologies instead of proprietary software and protocols, to support interoperability and, to a considerable extent, code reusability.

Semantic Code Clone Detection Based on Community Detection

Semantic code clone detection is to find code snippets that are structurally or syntactically different, but semantically identical. It plays an important role in software reuse, code compression. Many existing studies have achieved good performance in non-semantic clone, but semantic clone is still a challenging task. Recently, several works have used tree or graph, such as Abstract Syntax Tree (AST), Control Flow Graph (CFG) or Program Dependency Graph (PDG) to extract semantic information from source codes. In order to reduce the complexity of tree and graph, some studies transform them into node sequences. However, this transformation will lose some semantic information. To address this issue, we propose a novel high-performance method that utilizes community detection to extract features of AST while preserving its semantic information. First, based on the AST of source code, we exploit community detection to split AST into different subtrees to extract the underlying semantics information of different code blocks, and use centrality analysis to quantify the semantic information as the weight of AST nodes. Then, the AST is converted into a sequence of tokens with weights, and a Siamese neural network model is used to detect the similarity of token sequences for semantic code clone detection. Finally, to evaluate our approach, we conduct experiments on two standard benchmark datasets, Google Code Jam (GCJ) and BigCloneBench (BCB). Experimental results show that our model outperforms the eight publicly available state-of-the-art methods in detecting code clones. It is five times faster than the tree-based method (ASTNN) in terms of time complexity.

Study of web application development methodology for a medical clinic using React

The article explores in detail the methodologies for developing web applications for medical clinics using the popular React library. The main goal of this study is the analysis of modern approaches to the creation of web applications that meet the specific requirements of medical institutions. Particular attention is paid to the functional and non-functional characteristics that are critical to such systems, including data security, user experience, integration with existing systems, and compliance with regulatory standards. First of all, a comprehensive analysis of the requirements of medical clinics for web applications was carried out. Data security is one of the most important aspects as healthcare institutions work with sensitive information. The study examines methods for ensuring the confidentiality and integrity of medical data, including compliance with HIPAA and GDPR standards. React makes it easy to integrate modern security tools such as JWT (JSON Web Tokens) for authentication and authorization, and use secure HTTP connections for data transfer. In addition, special attention is paid to the user experience (UX/UI), which should ensure the convenience and efficiency of using the web application by both medical personnel and patients. React allows you to create dynamic and interactive interfaces that can adapt to different devices and screens, thus providing a high-quality user experience. This is especially important for medical applications, where the accuracy and speed of interaction can affect the quality of healthcare delivery. A detailed description of best practices and approaches to web application development using React is provided. A component architecture is considered, which provides modularity and code reuse, which is a key factor in creating scalable and easily maintainable applications. Different methods of state management in the application, such as the use of Context API and Redux, have been explored, which allows for efficient data management and stable operation of the application. Guidelines for configuring routing using the React Router library are described, allowing you to create dynamic and multi-page applications while providing smooth navigation and a good user experience. In addition, ways to ensure application security are considered, including protection against XSS attacks, CSRF and other types of vulnerabilities, which is critical in medical applications. The article provides specific recommendations for implementing a web application for a medical clinic. They include practical code examples that demonstrate the implementation of key functionalities such as user registration and authentication, medical record processing, and database interaction. The process of setting up the infrastructure for development, testing and deployment of the application is described, including the use of CI/CD tools to automate these processes, which contributes to increasing the efficiency of development and the quality of the final product. The article provides valuable information for developers who seek to create effective and secure web applications for medical clinics using modern technologies. The conclusions and recommendations presented in the study will help ensure high quality and compliance of the developed solutions with modern industry standards and requirements, which will contribute to increasing the efficiency of the work of medical institutions and the quality of medical services provided to patients

Towards improving aspect-oriented software reusability estimation

Nowadays, large numbers of organizations may opt for Aspect-Oriented Programming (AOP), which is an enhancement to Object-Oriented Programming (OOP). This is due to the addition of a number of concepts that have assisted in the production of more flexible and reusable components. One of the most important elements added by AOP is software reuse, which is based on reusability attributes. These attributes indicate the possibility of reusing one or more components in the development of a new system. It is one of the most essential attributes to evaluate the quality of a system’s components. Thus far, little attention has been paid to the process of measuring AOP reusability, and it has not yet been standardized. The objective of the current study is to come up with a reasonable measurement for AOP software reuse, which is simultaneously a significant topic for researchers while offering several advantages for organizations. Although numerous models have been built to estimate the reusability of software, most of them are not dedicated to Aspect-Oriented Software (AOS). In this study, a model has been designed for AOS reusability estimation and measurement based on a new equation depending on five attributes that have a range of positive and negative impacts on AOS reusability. Three of those attributes, namely coupling, cohesion, and design size, have been included in previous studies. This study proposes complexity and generality as two new attributes to be considered. Each of these attributes was measured based on the metrics also proposed in this study. A new equation to calculate AOS reusability was constructed based on the most important reusability attributes and metrics. Seven aspect projects were employed as a case study to apply the proposed equation. After the proposed equation was applied to the selected projects, we obtained new values of reusability to compare with the values that resulted from applying the previous equation. The fact that new values emerged indicates that the proposed reusability metrics and attributes had a significant effect.

SVulDetector: Vulnerability detection based on similarity using tree-based attention and weighted graph embedding mechanisms

Vulnerability detection by comparing similarities with known vulnerable code is an important method for improving code security, and is particularly effective in detecting vulnerabilities caused by code reuse. However, vulnerability detection is made difficult by the existence of some different and vulnerability-unrelated statements between codes with the same vulnerability pattern, as well as the small differences between vulnerable and fixed non-vulnerable codes. To address these challenges, we believe that more attention needs to be paid to some core syntactic and semantic information about vulnerabilities, which can help models more accurately identify vulnerable code. Hence, we propose a novel code-similarity-based vulnerability detection approach named SVulDetector. First, it contains a code representation, called Slice Composite Graphs (SCGs), which can represent rich syntactic and semantic information related to vulnerable statements while minimizing the interference from similar vulnerability irrelevant information as much as possible. Next, a tree-based attention mechanism is used to highlight certain key syntactic information in vulnerable code and fixed non-vulnerable code. Finally, SVulDetector highlights key vulnerable node information in the graph-based code representation via a weighted graph embedding mechanism. We extensively evaluated SVulDetector on an improved real-world dataset using both two-class and multi-class vulnerability detection tasks, and the proposed SVulDetector outperforms existing state-of-the-art detection methods.

Introduction of the Capsules environment to support further growth of the SBGrid structural biology software collection.

The expansive scientific software ecosystem, characterized by millions of titles across various platforms and formats, poses significant challenges in maintaining reproducibility and provenance in scientific research. The diversity of independently developed applications, evolving versions and heterogeneous components highlights the need for rigorous methodologies to navigate these complexities. In response to these challenges, the SBGrid team builds, installs and configures over 530 specialized software applications for use in the on-premises and cloud-based computing environments of SBGrid Consortium members. To address the intricacies of supporting this diverse application collection, the team has developed the Capsule Software Execution Environment, generally referred to as Capsules. Capsules rely on a collection of programmatically generated bash scripts that work together to isolate the runtime environment of one application from all other applications, thereby providing a transparent cross-platform solution without requiring specialized tools or elevated account privileges for researchers. Capsules facilitate modular, secure software distribution while maintaining a centralized, conflict-free environment. The SBGrid platform, which combines Capsules with the SBGrid collection of structural biology applications, aligns with FAIR goals by enhancing the findability, accessibility, interoperability and reusability of scientific software, ensuring seamless functionality across diverse computing environments. Its adaptability enables application beyond structural biology into other scientific fields.

LIBRARY LINX: BRIDGING EDUCATION WITH EFFICIENT LIBRARY MANAGEMENT

Abstract: The School Library Management System (SLMS) frontend is an essential component designed to provide a user-friendly interface for students, teachers, and librarians to efficiently manage library resources. The frontend interface serves as the gateway for users to access various features and functionalities offered by the SLMS. The popular JavaScript package React.js was utilised to build the front end of the SLMS. A dynamic and responsive interface provided by React.js makes it simple for users to navigate the library system. React.js simplifies component-based development by allowing for code reuse and modularity. Node.js is used to perform server-side logic and data administration on. Index Terms –Front-end Development , React Js , Design , React Dev Tools.

Achieving Syntax Excellence: Best Practices for Organizational Success

Abstract: Syntax Level Up Organization is a methodology that aims to improve the syntactical structure of codebases, fostering improved readability, maintainability, and scalability. It advocates for the systematic arrangement of code elements to enhance comprehension and streamline development workflows. Consistent coding conventions are a fundamental principle of Syntax Level Up Organization, which minimizes confusion and optimizes collaboration. Modularization promotes code reusability and minimizes dependencies, facilitating agile development practices. The judicious use of language features and idioms is another cornerstone of Syntax Level Up Organization. Developers can craft concise and expressive code by leveraging the full spectrum of a programming language’s capabilities, such as lambda functions, list comprehensions, and pattern matching. Meaningful abstractions are also advocated for to encapsulate complex logic, enhancing code maintainability and facilitating testing. Design patterns like the Factory Method, Singleton, and Strategy serve as powerful tools for structuring codebases and promoting code reuse. Code documentation is also crucial for enhancing code comprehensibility. Clear and concise comments supplement code, elucidating design decisions, highlighting edge cases, and facilitating knowledge transfer within teams. In conclusion, Syntax Level Up Organization represents a holistic approach to code organization that transcends superficial aesthetics, focusing on enhancing code clarity, efficiency, and maintainability. By embracing consistent coding conventions, modular design principles, idiomatic language features, meaningful abstractions, and comprehensive documentation, developers can elevate the quality of their codebases and empower teams to tackle modern software development challenges with confidence and agility. IndexTerms – HTML, CSS, Javascript. , MYSQL, PHP.

Going beyond templates: composition and evolution in nested OSTRICH

AbstractLow-code frameworks strive to simplify and speed up application development. An essential mechanism to achieve these goals is to have native support for the safe reuse and usage of parameterized coarse-grain components, providing developers with strong guardrails and a rich software-building experience. —a rich template language for the OutSystems platform—was designed to simplify the use and creation of such components. Thus, the application developer can quickly reuse and assemble sophisticated and thoroughly tested application blocks. However, without a built-in composition and evolution mechanism, templates are still hard to create and maintain. This sometimes requires the repetition of code across different templates and creates a conflict between the customizations of the instantiated application models, and the update and reapplication of a template definition. This paper presents a principled mechanism for using abstraction in the creation of templates and simultaneously supporting the evolution of templates in applications after use. First, we introduce a template composition mechanism, its typing discipline, and its instantiation algorithm for model-driven low-code development environments. We start by extending to support nested templates and allow the instantiation (hatching) of templates in the definition of other templates. Nesting promotes a significant increase in code reuse potential, leading to a safer evolution of applications. We then introduce the support for customizable template instances, which allows one to evolve templates’ code and then update a template instance without losing customizations performed in the generated code. The present definition seamlessly extends the existing OutSystems metamodel with template constructs expressed by model annotations that maintain backward compatibility with the existing language toolchain. We present the metamodel, a set of annotations to support the extensions, and the corresponding validation and instantiation algorithms. In particular, we introduce a type-based validation procedure for abstractions that ensures that using templates always produces valid models. This work also extends prior developments on Nested OSTRICH with the support for safe customizations of instantiated code. We validate Nested OSTRICH using the benchmark by identifying the degree of reusability that can be reached in the existing sample of real templates and template uses. Our prototype is an extension of the OutSystems IDE that allows the annotation of models and their use to produce new models. We also analyze which existing OutSystems sample screen templates can be improved by using and sharing nested templates .

An unstructured body-of-revolution electromagnetic particle-in-cell algorithm with radial perfectly matched layers and dual polarizations

A novel electromagnetic particle-in-cell algorithm has been developed for fully kinetic plasma simulations on unstructured (irregular) meshes in complex body-of-revolution geometries. The algorithm, implemented in the BORPIC++ code, utilizes a set of field scalings and a coordinate mapping, reducing the Maxwell field problem in a cylindrical system to a Cartesian finite element Maxwell solver in the meridian plane. The latter obviates the cylindrical coordinate singularity in the symmetry axis. The choice of an unstructured finite element discretization enhances the geometrical flexibility of the BORPIC++ solver compared to the more traditional finite difference solvers. Symmetries in Maxwell's equations are explored to decompose the problem into two dual polarization states with isomorphic representations that enable code reuse. The particle-in-cell scatter and gather steps preserve charge-conservation at the discrete level. Our previous algorithm (BORPIC+) discretized the E and B field components of TEϕ and TMϕ polarizations on the finite element (primal) mesh [1,2]. Here, we employ a new field-update scheme. Using the same finite element (primal) mesh, this scheme advances two sets of field components independently: (1) E and B of TEϕ polarized fields, (Ez,Eρ,Bϕ) and (2) D and H of TMϕ polarized fields, (Dϕ,Hz,Hρ). Since these field updates are not explicitly coupled, the new field solver obviates the coordinate singularity, which otherwise arises at the cylindrical symmetric axis, ρ=0 when defining the discrete Hodge matrices (generalized finite element mass matrices). A cylindrical perfectly matched layer is implemented as a boundary condition in the radial direction to simulate open space problems, with periodic boundary conditions in the axial direction. We investigate effects of charged particles moving next to the cylindrical perfectly matched layer. We model azimuthal currents arising from rotational motion of charged rings, which produce TMϕ polarized fields. Several numerical examples are provided to illustrate the first application of the algorithm.

SMaLL: Software for Rapidly Instantiating Machine Learning Libraries

Interest in deploying deep neural network (DNN) inference on edge devices has resulted in an explosion of the number and types of hardware platforms that machine learning (ML) libraries must support. High-level programming interfaces, such as TensorFlow, can be readily ported across different devices; however, maintaining performance when porting the low-level implementation is more nuanced. High-performance inference implementations require an effective mapping of the high-level interface to the target hardware platform. Commonly, this mapping may use optimizing compilers to generate code at compile time or high-performance vendor libraries that have been specialized to the target platform. Both approaches rely on expert knowledge across levels to produce an efficient mapping. This makes supporting new architectures difficult and time-consuming. In this work, we present a DNN library framework, SMaLL, that is easily extensible to new architectures. The framework uses a unified loop structure and shared, cache-friendly data format across all intermediate layers, eliminating the time and memory overheads incurred by data transformation between layers. Each layer is implemented by specifying its dimensions and a kernel , the key computing operation of that layer. The unified loop structure and kernel abstraction allows the reuse of code across layers and computing platforms. New architectures only require a few hundred lines in the kernel to be redesigned. To show the benefits of our approach, we have developed software that supports a range of layer types and computing platforms; this software is easily extensible for rapidly instantiating high-performance DNN libraries. An evaluation of the portability of our framework is shown by instantiating end-to-end networks from the MLPerf:tiny benchmark suite on five ARM platforms and one x86 platform (an AMD Zen 2). We also show that the end-to-end performance is comparable to or better than ML frameworks such as TensorFlow, TVM, and LibTorch.

Survival of software reuse: Node.js packages component selection and dependencies

Software reuse is a widely recognized and extensively studied practice in the field of software engineering. It involves using pre-existing software components to enhance productivity and efficiency. Node.js and its package manager enable software reuse by managing dependencies. Dependencies play a crucial role in defining the connections and interactions between various components of a software system. The selection of components and their interactions can greatly impact the functionality, performance, and stability of a software system. Overlooking these factors or making poor choices regarding component selection may lead to incomplete or flawed systems. Various factors that impact the decision-making process for selecting components were discussed, including documentation availability, crowdsourcing initiatives, and GitHub activities.