Design Of Software Components Research Articles

CNC Hot Wire Foam Cutting Machine

This research addresses the growing demand for intricate and creative wedding decorations. It proposes a CNC hot wire foam cutter design specifically for cutting Styrofoam. The machine offers precise control and automation, overcoming limitations of manual cutting for complex designs. This paper details the design process, including hardware and software components, and presents the results of cutting tests performed on various Styrofoam thicknesses and feed rates. Keywords— Arduino Uno, CNC, Cutting Foam, Hotwire, G-code

Fuzzy Logic Testing Approach for Measuring Software Completeness

Due to advancements in science and technology, software is constantly evolving. To adapt to newly demanded requirements in a piece of software, software components are modified or developed. Measuring software completeness has been a challenging task for software companies. The uncertain and imprecise intrinsic relationships within software components have been unaddressed by researchers during the validation process. In this study, we introduced a new fuzzy logic testing approach for measuring the completeness of software. We measured the fuzzy membership value for each software component by a fuzzy logic testing approach called the fuzzy test. For each software component, the system response was tested by identifying which software components in the system required changes. Based on the measured fuzzy membership values for each software component, software completeness was calculated. The introduced approach scales the software completeness between zero and one. A software component with a complete membership value indicates that the software component does not require any modification. A non-membership value specifies that the existing software component is no longer required in the system or that a new software component is required to replace it. The partial membership value specifies that the software component requires few new functionalities according to the new software requirements. Software with a partial membership value requires partial restructuring and design recovery of its components. Symmetric design of software components reduces the complexity in the restructuring of software during modification. In the study, we showed that by using the introduced approach, high-quality software that is faultless, reliable, easily maintained, efficient, and cost-effective can be developed.

Adopted topic modeling for business process and software component conformity checking

Business processes and software components, especially class diagrams, have a firm connection. Considering software components support the business process in providing an excellent product and service. Besides, business process changes affect on software component design. One of them usually appears on the label or name of the software component or business process. Sometimes, a related business process and software component appears in the different label but the same meaning rather than using the same label. This situation is problematic when there are many changes to be made, in which the software component's modifying process becomes quite long. Therefore, the software maintainers should obtain an efficient procedure to shorten the modifying process. One solution is by using conformity checking, which helps the software maintainers know which software component is related to a specific business process. This paper compared two leading topic modeling techniques, namely probabilistic latent semantic analysis (PLSA) and latent Dirichlet allocation (LDA), to determine which one has a better performancefor process traceability.

Software Component Quality Model

In Component Based Software Development (CBSD), applications are built from existing components either by assembling or replacing software parts. Reusing components may lead to faster software development and subsequently reduce cost and provide higher product quality. In CBSD, software component models define what components are and how they compose. However, no research has been done to assess the quality of software component models, to assess the characteristics of software component design. This paper proposed a software component quality model specifically to answer the question what characteristics make good component. A Systematic Literature Review (SLR) has been conducted by defining a robust protocol that combines automatic searches from different sources. The finding of the SLR has contributed to the development of quality model for CBSD, i.e. a proposed component quality model with metrics which is specific to software component design.

REBA: A Refinement-Based Architecture for Knowledge Representation and Reasoning in Robotics

This article describes REBA, a knowledge representation and reasoning architecture for robots that is based on tightly-coupled transition diagrams of the domain at two different levels of granularity. An action language is extended to support non-boolean fluents and non-deterministic causal laws, and used to describe the domain's transition diagrams, with the fine-resolution transition diagram being defined as a refinement of the coarse-resolution transition diagram. The coarse-resolution system description, and a history that includes prioritized defaults, are translated into an Answer Set Prolog (ASP) program. For any given goal, inference in the ASP program provides a plan of abstract actions. To implement each such abstract action, the robot automatically zooms to the part of the fine-resolution transition diagram relevant to this action. The zoomed fine-resolution system description, and a probabilistic representation of the uncertainty in sensing and actuation, are used to construct a partially observable Markov decision process (POMDP). The policy obtained by solving the POMDP is invoked repeatedly to implement the abstract action as a sequence of concrete actions. The fine-resolution outcomes of executing these concrete actions are used to infer coarse-resolution outcomes that are added to the coarse-resolution history and used for subsequent coarse-resolution reasoning. The architecture thus combines the complementary strengths of declarative programming and probabilistic graphical models to represent and reason with non-monotonic logic-based and probabilistic descriptions of uncertainty and incomplete domain knowledge. In addition, we describe a general methodology for the design of software components of a robot based on these knowledge representation and reasoning tools, and provide a path for proving the correctness of these components. The architecture is evaluated in simulation and on a mobile robot finding and moving target objects to desired locations in indoor domains, to show that the architecture supports reliable and efficient reasoning with violation of defaults, noisy observations and unreliable actions, in complex domains.

Multi-objective exploration of architectural designs by composition of model transformations

Designing software architectures and optimizing them based on extra-functional properties (EFPs) require to identify appropriate design decisions and to apply them on valid architectural elements. Software designers have to check whether the resulting architecture fulfills the requirements and how it positively improves (possibly conflicting) EFPs. In practice, they apply well-known solutions such as design patterns manually. This is time-consuming, error-prone, and possibly sub-optimal. Well-established approaches automate the search of the design space for an optimal solution. They are based model-driven engineering techniques that formalized design decisions as model transformations and architectural elements as components. Using multi-objective optimizations techniques, they explore the design space by randomly selecting a set of components and applying to them variation operators that include a fixed set of predefined design decisions. In this work, we claim that the design space exploration requires to reason on both architectural components as well as model transformations. More specifically, we focus on possible instantiations of model transformations materialized as the application of model transformation alternatives on a set of architectural components. This approach was prototyped in RAMSES, a model transformation and code generation framework. Experimental results show the capability of our approach (i) to combine evolutionary algorithms and model transformation techniques to explore efficiently a set of architectural alternatives with conflicting EFPs, (ii) to instantiate, and select transformation instances that generate architectures satisfying stringent structural constraints, and (iii) to explore design spaces by chaining more than one transformation. In particular, we evaluated our approach on EFPs, architectures, and design alternatives inspired from the railway industry by chaining model transformations dedicated to implement safety design patterns and software components allocation on a multi-processor hardware platform.

Making a Formal Case for the Development of Components of Modern Enterprise Information Systems

Background: The article covers the specifics of streamlining the design of software components for modern information systems, proposes a multiple-path integration approach intended for obtaining optimal and suboptimal solutions in multidimensional problems. Methods: The article proposes an approach to establishing a smooth pipeline for the development of software components within enterprise Information Systems (IS) based on the principles of Service-Oriented Architecture (SOA) that intend to reduce the complexity of the IS components themselves and the way they communicate with each other. To come up with the most practical solutions, the authors have used multiple-path integration methods that can help provide solutions to multidimensional problems within a reasonable time. Findings: The proposed formalization of the task to design an IS component serves as a base for studying the characteristics of the life cycles of different IS components, strategies and approaches to their design and development, as well as the general IS structure by means of various strategies of interaction between the existing software components and the ones being designed. Improvements/Application: The proposed approach can be used as a tool for building large-scale information systems in order to reduce the time and resources spent on the project. The article suggests a use case for this approach involving the building of IS components for telecommunication companies.

Pattern-Based Coarse-Grained Component Modelling for Enterprise Application Software Developing

To improve the efficiency of ESA (Enterprise Application Software) development, component-based software development is a good solution. However, though those general software components, like JavaBean, COM/COM+ (Component Object Model), are maturely used to develop ESAs, it is still too inefficient to industrialize ESA development. This is because design of software component has a tightly correlation with the inner structure of an ESA and should not be independent from architecture of ESA. By analysing software patterns and characteristics, a business component (BC) modelling based on pattern is proposed first. Then a BC scheduling pattern and an executable workflow model are presented to show the principle by which BCs are organized and scheduled. The proposed method is a PSM (Platform-Specific Model) modelling which a part of MDA (Model-Driven Architecture) based framework. Finally, a case is showed that our method can provide theoretical and practical significance to the development software of ESA.

Neuro-Fuzzy Model to Estimate & Optimize Quality and Performance of Component Based Software Engineering

Component Based Software Engineering (CBSE) constructs a quality software system by reusing existing components. For the construction of high-quality software system, reusability plays an important role. Software component should be designed and implemented in such a way that many different programs can reuse them. Reuse of software can increase the productivity and quality of software by reducing effort, time and cost which was elapsed in designing and developing reusable software component. In this paper, a Neuro-fuzzy model has been proposed that uses software component design patterns for analysis and Chidamber and Kemerer (CK) metric for evaluation, optimization and categorization of reusability for component based software. The work is divided into 2 phases. In the first phase, analysis and optimization of reusability are empirically evaluated with high precision value using CK metric and unsupervised Self Organizing Map (SOM) Neural Network. In the second phase, reusability is categorized as very low, low, medium, high and very high using a supervised Back propagation Neural Network (BPNN) and fuzzy inference rules applied on CK metric values. The proposed model may help a software designer to evaluate and optimize the reusability of components while designing software to make quality software system.

Modeling and Simulation Method of Component Based Petri Net

The structure of Petri net model is relative fixed after it is built, so it cant describe dynamic change behavior of real system structure easily. Description formalness, coupling mechanism and simulation method were presented, the dynamic change of Petri net structure in simulation run was realized based on the idea of software component design. The reuse capability of Petri net model is enhanced, integration with other models is convenience and hierarchical modeling mode is realized, and the capability of modeling and simulation of Petri net is improved.

Research and Design of Task-Oriented Software Component

Alone with the Component-Based Software Engineering (CBSE) has been becoming the mainstream in applications development, there are a lot of people has been used software components to build their applications and business systems. But in practice, how to create a reusable and easy customized component and can be easily integrated into users’ application is still a headache problem to many designers and developers. Here by study and analyzing the interface-oriented software component model and research on the XML and task-oriented technologies, it illustrates a task-oriented software component design and try to improve the CBSE in practice

In Search of Efficient Flexibility: Effects of Software Component Granularity on Development Effort, Defects, and Customization Effort

Simultaneously achieving efficiency and flexibility in enterprise software production has been a considerable challenge for firms. Newer software development paradigms such as component-based and model-driven development attempt to overcome this challenge by emphasizing modular design of complex systems. However, there is a paucity of rigorous empirical research on the use of such software methodologies and the associated extent to which trade-offs between efficiency and flexibility can be influenced. Addressing this gap, we investigate the performance outcomes of a model-driven, component-based software development methodology using data collected from an enterprise software development firm that deployed such a methodology for its product development processes. Examining the design, development, and implementation of 92 business software components of the firm's enterprise resource planning product, we discuss how the design of software components, specifically component granularity, affects development efficiency (development effort and defects) and flexibility (customization effort). Our results suggest that (a) components that are coarse grained are associated with higher flexibility (lower customization effort) but are also associated with lower development efficiency (more development effort and defects), and (b) defect proneness of a component plays a mediating role on the relationship between component granularity and flexibility. These findings present strong evidence for the existence of trade-offs between efficiency and flexibility in mass-customized software product life cycles. They establish component granularity as a key design dimension that needs to be managed judiciously to enable potential trade-off shifting mechanisms through the use of software methodologies that emphasize modular design approaches.

Mass customization and personalization software development: a case study eco-design product service system

A large number of customers currently require manufacturers to develop more flexible products to satisfy their own personalization. Due to buyer's market and short product lifecycles, many industries are beginning to shift from mass production to mass customization to satisfy their customer requirements. The purpose of this research is to provide a model for enhancing the software component design in order to improve quality and reusability, as well as to reduce costs based on the concept of mass customization and personalization (MC&P). First, quality function deployment (QFD) was used to find out what the customers think, and to determine the core functions and components of the software. The mass customization technology was then used to aggregate the software modules. Thirdly, the software costs for business strategies, purchasing and renting under the customization model were evaluated. Finally, a real case of Eco design software in PSS was illustrated based on the model.

Concurrent usability evaluation and design of software component: a digraph and matrix approach

Software component usability is a critical characteristic which represents the significant difference between conventional software quality models and component quality models. Current procedures and techniques are mostly concentrated on usability aspects of software systems as per end-user point of view (who interacts with the system). Very less research has been done to analyse usability characteristics from the viewpoint of a system designer, component selector, component acquirer and system integrator. This study provides a methodology based on digraph and matrix approach to provide in depth analysis of a component considering the usability characteristic. Digraph and (permanent) matrix are utilised to analyse component usability by considering all sub-characteristics and attributed factors along with all levels of interactive complexity (inter-intra) based on the concurrent approach. The proposed methodology will provide benefits to the component designer, component developer, system developer and decision maker. The concept of formation of hypothetical maximum (best) and hypothetical minimum (worst) index is proposed. Based on these, users can take the decision for selection, evaluation and ranking of potential candidates and wherever possible attain improvements in the component design and development. The applicability of the proposed methodology is demonstrated with an illustrative example.

AUTOSAR기반 EPS 시스템 소프트웨어 컴포넌트의 스케줄링 설계 및 시뮬레이션

Through the AUTOSAR methodology, the embedded software shall become more flexible, reusable, maintainable than ever. However, it is not mentioned about specific timing constraints of software components in AUTOSAR. There are a few basic principles for mapping runnable entities. At this point, AUTOSAR software design with optimal scheduling method is one of the enabling technologies in vehicle embedded system. This paper presents an approach based on mapping runnable entities and task scheduling design method for EPS (Electric Power Steering) software components, based on AUTOSAR. In addition, the experimental results of concurrent simulation show that the proposed scheduling technique and timing synchronization in the software component design can achieve the improved torque ripple performance and it well suited for EPS application software.

A FRAMEWORK FOR A WEBSITE SNAPSHOT MANAGEMENT SYSTEM

This paper presents a framework for a website snapshot management system. The objective of the system is to recreate webpage snapshots of every published webpage including their code and rendition upon users’ requests. We define four levels of snapshots and design software components to create snapshots that meet the requirement of each level. A website may choose to maintain the appropriate level of snapshot that fits its needs.

Designing software components to tolerances

Many traditional engineering designs, other than software, depend on the physical properties of components. Those properties enable the engineer to specify precise tolerances between those components. Software components are abstractions with no inherent physical properties. The absence of physical properties makes it more difficult, but not impossible, to design to tolerances. This paper describes some design metrics for designing software components to tolerances. It uses some already established design metrics, and expands on the role of other software practices already available. This paper also restricts the discussion to software components, rather than to the algorithms contained within those components.

Design and implementation of the software system on MPSoC: An HDTV decoder case study

The design effort of software system in multiprocessor system-on-a-chip (MPSoC) is getting heavier with ever-increasing system complexity. The design methodology mainly focuses on things such as co-development with hardware, reducing cost and time, and increasing portability, reusability, and robustness. This paper explores how to design a high performance, robust software system with component-based method and systematic level co-development. Complex architecture and system requirements constrain the whole process. High definition television (HDTV) decoder SoC platform consists of two processors and customized hardware and software components. As an successful experience, we will give the software component design and implementation details

Y: A New Component-Based Software Life Cycle Model

With the need to produce ever larger and more complex software systems, the use of reusable components has become increasingly imperative. Of the many existing and proposed techniques for software development, it seems clear that component-based software development will be at the forefront of new approaches to the production of software systems and holds the promise of substantially enhancing the software production and maintenance process. Attempts to rationalize component-based development have to recognize that the construction of a software system is a complex multifaceted activity that involves domain engineering, frame working, assembling, archiving and design of software components. These activities, among others, are encompassed by a software life cycle, named the Y model, put forward in this study. The Y model provides guidance for the major phases to be followed under its umbrella.

CUSTOMIZING COMPONENT-BASED SOFTWARE USING COMPONENT COORDINATION MODEL: A USE-CONTEXT DRIVEN APPROACH TOWARD ROLE-BASED MODEL

In this paper, we introduce a component coordination model (CCM) that is embedded into the applications during software architecture design. The CCM is driven by the use-context model, which directly reflects the role-based model that abstracts system behaviors as a computational organization comprising various role relationships. It then focuses on exposing the design of software components to be separated from their execution contexts. These separate concerns — computation, coordination, and policies imposed on a given use-context — form the principal concept of our approach. Finally, a case study using the proposed model has been demonstrated in order to provide the feasibility of the introduced approach.