Object-oriented Software Research Articles

A Real-Time Associative Feature-Based Customer Relationship Management and Enterprise Resource Planning Integration Model for Small- and Medium-Sized Enterprises

Abstract Customer relationship management (CRM) and enterprise resource planning (ERP) have been extensively discussed in the research literature respectively. However, existing studies do not reach a complete agreement on the CRM/ERP integration method, especially for small- and medium-sized enterprises (SMEs). Generally, this work proposed a novel method for CRM/ERP integration approach via associative feature technology. A new feature type, Real-time Data Link Board (RDLB), is developed and detailed as a generic information carrier solution for multisystem integration between CRM and ERP packages. Valuable data elements are mapped into such data boards dynamically and synchronized across different data sources, structures, and databases. The contribution of this work is to present a well-defined and generically reusable data carrier definition, alongside related methods for ensuring consistent data modeling during the system integration phase across various digitalization engineering implementation projects. With this approach, the consistent management of data integration across intricate systems is achievable throughout application lifecycles, supported by the object-oriented software engineering foundation.

Enhancing integration testing efficiency through AI-driven combined structural and textual class coupling metric

Integration testing, a critical and resource-intensive phase in the software development lifecycle, can account for up to a high percentage of the total testing cost. Identifying classes with high coupling is crucial for efficient integration testing, as these classes are more susceptible to the impact of maintenance-related changes. This research introduces a novel metric called <i>combined structural and textual class coupling</i> (CSTCC), which harnesses the power of artificial intelligence (AI) techniques to predict and rank the most critical classes in an object-oriented software system. CSTCC integrates structural coupling metrics with <i>latent semantic indexing</i> (LSI)-based textual coupling, providing a comprehensive measure of class coupling. LSI, an information retrieval technique, analyses the semantic relationships between classes based on their textual content, enabling CSTCC to capture both structural and conceptual dependencies, resulting in a more accurate identification of high-risk classes. The effectiveness of the proposed approach is rigorously evaluated using mutation testing on four Java open-source projects, and the results demonstrate that test cases developed based on CSTCC achieve high mutation scores, indicating their ability to detect a significant percentage of integration faults. By focusing testing efforts on high-coupling classes identified by CSTCC, developers can potentially save time and cost during integration testing. The results demonstrate that test cases developed based on CSTCC achieve high mutation scores, ranging from 98% to 100%, indicating their ability to detect a significant percentage of integration faults. Additionally, the approach results in substantial efficiency gains, with a notable reduction in the number of test cases needed, saving up to 33.3% of the testing effort in some cases. By focusing testing efforts on high-coupling classes identified by CSTCC, developers can potentially save time and cost during integration testing. The CSTCC metric provides a novel and effective approach to prioritize testing resources and improve the efficiency of integration testing in object-oriented software systems.

On the use of Change History Data to Enhance Class Change-Proneness Prediction Models

As software evolves, new artifacts are created, modified, or removed. One of these main artifacts generated in the development of object-oriented software is the class. Classes have a very dynamic life cycle that can result in additional costs to the project. One way to mitigate this is to detect, in the early stages of the development, classes that are prone to change. Some approaches in the literature adopt Machine Learning (ML) algorithms to predict the change-proneness of a class. However, most of these approaches do not consider the temporal dependency between training instances, i.e., they consider that the instances are independent. To overcome such a limitation, this study presents an approach for predicting change-proneness based on the class change history. The approach adopts the sliding window method and is evaluated to obtain six kinds of models, which are derived by using, as predictors, different sets of metrics: structural, evolutionary, and smell-based. The evaluation uses five systems, four ML algorithms, and also explores some resample techniques to deal with imbalanced data. Regardless of the kind of model analyzed and the algorithm used, our approach overcomes the traditional one in 378 (~80) cases, out of 420, considering all systems, kinds of models, indicators, and algorithms. Moreover, the results show that our approach presents the best performance when the set of evolutionary metrics is used as predictors. There is no improvement when smell-based metrics are added. The Random Forest algorithm with the resampling technique ADA reaches the best performance among the ML algorithms evaluated.

Evaluating Thresholds for Object-Oriented Software Metrics

Software metrics measure quantifiable or countable software characteristics. Researchers may apply them to provide better product understanding, evaluate the process effectiveness, and improve the software quality. A threshold is a value that aids the proper interpretation of software measurements; it indicates whether or not a given value represents a quality risk. Thresholds are unknown for most software metrics, inhibiting their use in a software quality assessment process. In a previous paper, we proposed a catalog with 18 object-oriented software metrics thresholds, providing a preliminary case study in proprietary software to validate them. This article evaluates these thresholds more deeply, considering significant aspects. We show a new example of threshold derivation, discussing it qualitatively. We explain these software metrics and discuss their threshold values, presenting each one’s application level, definition, formula, and implications for the software design. We conduct a study with two software systems to evaluate the capacity of our thresholds to identify software quality enhancement after a restructuring process. We assess these thresholds using two case studies, comparing the evaluation provided by the thresholds with the qualitative analysis given by manual inspections. The study results indicate that the thresholds may lead to few false-positive and false-negative occurrences, i.e., the thresholds provide a proper quantitative assessment of software quality. This study contributes with empirical evidence that the metrics’ thresholds proposed in our previous work provide a proper interpretation of software metrics and, hence, may aid the application of software metrics in practice.

Estimate the effort required to develop an Object-Oriented Software utilizing class point approach

The time and effort put into creating a piece of software may have a significant impact onwhether or not it is commercially successful. As a second step, we examine the found classes' localmethods and their interplay with the rest of the system to ascertain their complexity. In softwaredevelopment, estimation is the process of establishing the most precise measure of size required to designand test the programmed system, based on the software's needs. For calculating rough estimates of thesize of Objective Oriented OO products, we provide a technique that has resemblance to FP (FunctionPoint) we call it Class Point. Particularly, two metrics like number of methods and number of attributesare used for user objects that include design patterns.

OOPS: Object-Oriented Polarization Software for analysis of fluorescence polarization microscopy images.

Most essential cellular functions are performed by proteins assembled into larger complexes. Fluorescence Polarization Microscopy (FPM) is a powerful technique that goes beyond traditional imaging methods by allowing researchers to measure not only the localization of proteins within cells, but also their orientation or alignment within complexes or cellular structures. FPM can be easily integrated into standard widefield microscopes with the addition of a polarization modulator. However, the extensive image processing and analysis required to interpret the data have limited its widespread adoption. To overcome these challenges and enhance accessibility, we introduce OOPS (Object-Oriented Polarization Software), a MATLAB package for object-based analysis of FPM data. By combining flexible image segmentation and novel object-based analyses with a high-throughput FPM processing pipeline, OOPS empowers researchers to simultaneously study molecular order and orientation in individual biological structures; conduct population assessments based on morphological features, intensity statistics, and FPM measurements; and create publication-quality visualizations, all within a user-friendly graphical interface. Here, we demonstrate the power and versatility of our approach by applying OOPS to punctate and filamentous structures.

Financial Application for the STMIK Mardira Indonesia Educational Institution

The waqf asset management system is essential for maximizing and optimizing the managed assets to achieve the highest and most favorable outcomes. A professional waqf institution in Bandung possesses waqf assets dispersed throughout several regions in Indonesia, and its management has successfully reached the level of optimizing productive waqf. Nevertheless, waqf assets are managed manually, leading to slower and worse management practices. This research aims to address the issue of managing waqf assets by applying ISO 55001 to the waqf asset management system in a selected professional waqf institution in Bandung. The research approach employs descriptive analysis with the Object-Oriented Software Engineering (OOSE) system development process. The results reveal eight functions based on 8 and 9 criteria that should be present in the asset management system according to ISO 55001. The program incorporates these eight functionalities and achieves a System Usability Scale (SUS) score of 84.6, signifying a B grade and outstanding acceptance. The ISO 55001 certification readiness level is 57.14%, as determined by the ISO 55001 Self-assessment conducted by the British Standard Institute (BSI). The researcher utilized Black Box testing to evaluate the program's functionality, and the findings indicate that all operations are functioning as anticipated.

Effort-Aware Fault-Proneness Prediction Using Non-API-Based Package-Modularization Metrics

Source code complexity of legacy object-oriented (OO) software has a trickle-down effect over the key activities of software development and maintenance. Package-based OO design is widely believed to be an effective modularization. Recently, theories and methodologies have been proposed to assess the complementary aspects of legacy OO systems through package-modularization metrics. These package-modularization metrics basically address non-API-based object-oriented principles, like encapsulation, commonality-of-goal, changeability, maintainability, and analyzability. Despite their ability to characterize package organization, their application towards cost-effective fault-proneness prediction is yet to be determined. In this paper, we present theoretical illustration and empirical perspective of non-API-based package-modularization metrics towards effort-aware fault-proneness prediction. First, we employ correlation analysis to evaluate the relationship between faults and package-level metrics. Second, we use multivariate logistic regression with effort-aware performance indicators (ranking and classification) to investigate the practical application of proposed metrics. Our experimental analysis over open-source Java software systems provides statistical evidence for fault-proneness prediction and relatively better explanatory power than traditional metrics. Consequently, these results guide developers for reliable and modular package-based software design.

Optimized design refactoring (ODR): a generic framework for automated search-based refactoring to optimize object-oriented software architectures

Optimized design refactoring (ODR): a generic framework for automated search-based refactoring to optimize object-oriented software architectures

A declarative approach to detecting design patterns from Java execution traces and source code

Design patterns are invaluable for software engineers because they help obtain well-structured and reusable object-oriented software components and contribute towards ease of software comprehension, maintenance, and modification. However, identifying design patterns from an inspection of the source code is not easy because, in most cases, there are no syntactic cues that signal their presence. This topic has therefore elicited considerable interest in the field. The novel aspect of our work is that we propose a set of primitives using which we can declaratively specify design patterns based on a combination of static and dynamic information. Our experimental work is carried out in the context of Java: static information is extracted from Java source code, and dynamic information from an execution trace of a program. Each declarative pattern specification is automatically translated into an SQL query which retrieves all instances of the design pattern present in the program. We illustrate our approach with the well-known Gang-of-Four design patterns and the approach extends to other such design patterns. The experimental results show the efficacy of our approach for representative programs for all GoF patterns in addition to more extensive case studies, JHotDraw, Junit, and QuickUML.

Design patterns over SOLID and GRASP principles in real projects

Design patterns (models) are repeatable and reusable constructions and solutions for common situations and problems to improve the quality of software systems. SOLID and GRASP are sets of design principles that are used in object-oriented software development. In this work we consider these solutions and principles and compare their (possibly combined) usage in different cases.

Lamarckian Platform: Pushing the Boundaries of Evolutionary Reinforcement Learning Toward Asynchronous Commercial Games

Despite the emerging progress of integrating evolutionary computation into reinforcement learning, the absence of a high-performance platform endowing composability and massive parallelism causes non-trivial difficulties for research and applications related to asynchronous commercial games. Here we introduce Lamarckian <xref ref-type="fn" rid="fn1" xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">¹</xref> <fn id="fn1" xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink"><label>¹</label> The code and demonstrational setup of Lamarckian are publicly available at <uri>https://github. com/lamarckian/lamarckian</uri>. </fn> – an open-source platform featuring support for evolutionary reinforcement learning scalable to distributed computing resources. To improve the training speed and data efficiency, Lamarckian adopts optimized communication methods and an asynchronous evolutionary reinforcement learning workflow. To meet the demand for an asynchronous interface by commercial games and various methods, Lamarckian tailors an asynchronous Markov Decision Process interface and designs an object-oriented software architecture with decoupled modules. In comparison with the state-of-the-art RLlib, we empirically demonstrate the unique advantages of Lamarckian on benchmark tests with up to 6000 CPU cores: i) both the sampling efficiency and training speed are doubled when running PPO on Google football game; ii) the training speed is 13 times faster when running PBT+PPO on Pong game. Moreover, we also present two use cases: i) how Lamarckian is applied to generating behavior-diverse game AI; ii) how Lamarckian is applied to game balancing tests for an asynchronous commercial game.

Data-oriented QMOOD model for quality assessment of multi-client software applications

There has been a great effort to evaluate software quality using proper tools and methods against different development environments changing over time. Quality Model for Object Oriented Design (QMOOD) is a verified model used for quality assessment of object-oriented software. The model associates quality metrics gathered from the source code and quality attributes in use to present a quality measurement. However, the model should be revised for recent multi-client software including native client applications, because there is a deficiency of metric gathering tools in such environments. More specifically, it is sometimes not possible to gather all quality properties required by QMOOD in all native development platforms of client applications. Hence, even though different client applications have the same design, the implementation quality cannot be monitored for the quality assurance. Analyzing and simplifying the metric set may alleviate this challenge, and a convenient quality assessment might be achieved. Thus, we propose to change the operational aspect of QMOOD by inserting an additional layer, Data Analytic, to the hierarchical structure of the conventional model. Accordingly, we provide a discussion on a case study including five native client applications. For this purpose, a design quality of one of the client applications is achieved to validate the appropriateness of the design, the data analytic on the metric set are implemented and the proposed data-oriented simplified QMOOD is applied to the other client applications. Finally, it is stated that the proposed approach successfully alleviated the problems in metric gathering for multi-client applications while applying QMOOD.

Soft Computing-Based System for Performance Modeling of Object-Oriented Programming (OOP) Software

Performance is a vital attribute for most software, making performance investigation an essential software engineering task. The problem is that modern applications are challenging to analyse for performance. The advancement of Software engineering has seen the application of scientific approach at various stages of Software Development Life Cycle (SDLC). New technique is available for implementation known as soft computing. This approach is a synergistic combination of artificial intelligence methodologies to model and solve real world problems that are either impossible or challenging to be modeled mathematically. The complexity, the commercial constraints and the expectation for high quality software demand, measuring the quality performance of an Object-Oriented Software (OOS). This work presents a set of testing metric (criteria) which hold the potential for ensuring remarkable improvements in quality performance of Object-Oriented software (OOS). A Prediction Model focused on identifying and evaluating the quality of the performance model based on the data set of software design components. The software design properties are comprehensive elucidated and integrating concepts of fuzzy logic and software engineering. The system enables the performance of modeling of Object-Oriented software using Fuzzy Inference System (FIS) to accurately predict the quality Object Oriented Software based on quality performance criteria such as reliability, efficiency, functionality and maintainability. Empirical validation of the results using checking data set is made to prove the usefulness of the design metrics and design quality attributes on the software prediction models. The purpose of this work is to provide development tool to solves practical problems, and focus on identifying and evaluating the quality performance of software design components. Again, the results demonstrate that, despite the research including approaches explicitly aimed at object-oriented software, there are substantial challenges in providing realistic feedback on the performance of large-scale object-oriented applications accordingly.

Inventory Information System Using LIFO Method

At one of the goods distribution organizations in Bandung, manual recording problems such as data mistakes, delayed information, and challenges with inventory analysis must be addressed, and here is where the inventory information system comes in. An inventory system must be implemented to improve accuracy and efficiency in inventory management. With the correct technology, the business can reduce data errors, speed up information access, do practical inventory analysis, and increase productivity when taking and maintaining inventory. This study develops a web-based inventory information system using the MySQL database from the XAMPP application, the Laravel framework, and the PHP programming language. Representative data modeling and the creation of user-friendly interfaces are critical components of the design focus, which also considers proper technology selection. In order to better understand user needs and provide answers, system design will use the Object-Oriented Software Engineering (OOSE) model. In order to help with more precise decision-making in inventory management, the Last-In-First-Out (LIFO) method is used in inventory data analysis. Inventory may be easily monitored by using LIFO to offer information on nearly depleted stock and out-of-stock items. One of the Bandung-based goods delivery companies has seen notable gains due to the adoption of the new inventory system. With this new technology, the business may get past problems with manual recording, like data inaccuracies, delayed information, and challenges with inventory analysis. By streamlining the recording process and facilitating more efficient inventory management, this system facilitates better access to inventory information and increases the efficiency of inventory management. In summary, using an inventory system is an excellent way to get around problems with manual goods recording. This solution increases inventory management efficiency and speeds up the recording process for one of the Bandung-based commodities delivery enterprises. Its deployment offers significant advantages, improving the company's overall operating performance and facilitating more effective inventory management.

Security Evolution in Object-Oriented Software Systems: Shaping the Future Landscape through Innovative Patterns

Security Evolution in Object-Oriented Software Systems: Shaping the Future Landscape through Innovative Patterns

L[formula omitted]OP-ART: A linear-time adaptive random testing algorithm for object-oriented programs

Object-oriented (OO) programming offers useful and desirable characteristics in the resulting code. These OO characteristics, however, demand an effective testing method. Adaptive random testing (ART) serves as an effective testing technique where test cases are distributed uniformly according to a proper metric for difference (distance) between test cases. Recently proposed object and method invocation sequence similarity (OMISS) distance metric was incorporated into a new ART algorithm (OMISS-ART) for testing OO software. Unfortunately, OMISS-ART’s high effectiveness in finding faults comes at significantly higher computational overheads. To alleviate the problem, we present in this paper a linear-time ART algorithm called L′OP-ART (Linear-time Object-oriented Program testing by ART) based on a lightweight OMISS metric. L′OP-ART designs specific data structures that store information about executed test cases, thus, the differences between candidates and executed test cases can be obtained with reduced overheads. Empirical studies show that L′OP-ART detects failures more effectively than random testing (RT), and has comparable fault-detection effectiveness to other ART algorithms for OO testing (according to the F-measure, or the expected number of test case executions required to find a failure). Furthermore, the test case generation overhead of L′OP-ART is low, close to that of RT.

Choral: Object-oriented Choreographic Programming

Choreographies are coordination plans for concurrent and distributed systems, which define the roles of the involved participants and how they are supposed to work together. In the paradigm of choreographic programming, choreographies are programs that can be compiled into executable implementations. In this article, we present Choral, the first choreographic programming language based on mainstream abstractions. The key idea in Choral is a new notion of data type, which allows for expressing that data is distributed over different roles. We use this idea to reconstruct the paradigm of choreographic programming through object-oriented abstractions. Choreographies are classes, and instances of choreographies are objects with states and behaviours implemented collaboratively by roles. Choral comes with a compiler that, given a choreography, generates an implementation for each of its roles. These implementations are libraries in pure Java, whose types are under the control of the Choral programmer. Developers can then modularly compose these libraries in their programs, to participate correctly in choreographies. Choral is the first incarnation of choreographic programming offering such modularity, which finally connects more than a decade of research on the paradigm to practical software development. The integration of choreographic and object-oriented programming yields other powerful advantages, where the features of one paradigm benefit the other in ways that go beyond the sum of the parts. On the one hand, the high-level abstractions and static checks from the world of choreographies can be used to write concurrent and distributed object-oriented software more concisely and correctly. On the other hand, we obtain a much more expressive choreographic language from object-oriented abstractions than in previous work. This expressivity allows for writing more reusable and flexible choreographies. For example, object passing makes Choral the first higher-order choreographic programming language, whereby choreographies can be parameterised over other choreographies without any need for central coordination. We also extend method overloading to a new dimension: specialisation based on data location. Together with subtyping and generics, this allows Choral to elegantly support user-defined communication mechanisms and middleware.

Web-Based Sales Information System in One of The Cash Shops Using the Business to Customer Method

Science and information technology's rapid and sophisticated progress motivates humans to generate novel solutions that facilitate easy and speedy information acquisition. Consumer behavior has experienced a substantial transformation in the present digital age. Many people opt for Internet purchasing due to the ease, accessibility, and flexibility it provides. The fashion industry is not immune to this phenomenon, as internet retailers are gaining popularity as a preferred method for buying clothing and accessories. Online retailers offer advantages such as convenient access to product catalogs, the ability to purchase at any time and from any location, and a broader selection of options. This offers a substantial opportunity for fashion retailers to access a larger pool of potential customers and enhance their market dominance. The sales process in a particular fashion store now depends on a traditional system involving direct transactions at the physical store and maintaining sales data through paper documents. This technique encounters multiple impediments that must be surmounted. A significant challenge is the limited accessibility to clients beyond the geographical confines of the physical business. In addition, using paper documents to manage sales data also needs to be improved in efficiency and accuracy. The method is laborious and prone to human errors. As inferred from the background description, the author's objective is to develop a web-based sales information system for a fashion retailer utilizing the business-to-customer approach. This system will streamline the sales process and aid in managing sales data, encompassing product data, customer data, and transactions. The system development will utilize the PHP programming language and the MySQL database, widely employed in online development. The research methodologies encompass literature review, observation, and interviews. The chosen approach for system development is Object-Oriented Software Engineering (OOSE), which utilizes Unified Modeling Language (UML) for system modeling. This includes using various diagrams such as use case, activity, sequence, and class diagrams. Hence, the sales information system is anticipated to offer a more efficient resolution for carrying out sales procedures and enhancing data administration promptly, safely, and precisely. Implementing this strategy will enable the fashion store to expand its consumer base, particularly among individuals located beyond the geographical reach of the actual store, thereby improving overall business performance.

Investigation of user perception of software features for software architecture recovery in object-oriented software

Investigation of user perception of software features for software architecture recovery in object-oriented software