• Journal of the Ergonomics Society of Korea
• /
• v.34 no.3
• /
• pp.235-245
• /
• 2015

Objective: The purpose of this study is to develop visual complexity metrics based on theoretical bases. Background: With the development of IT technologies, drivers process a large amount of information caused by automotive human-machine interface (HMI), such as a cluster, a head-up display, and a center-fascia. In other words, these systems are becoming more complex and dynamic than traditional driving systems. Especially, these changes can lead to the increase of visual demands. Thus, a concept and tool is required to evaluate the complicated systems. Method: We reviewed prior studies in order to analyze the visual complexity. Based on complexity studies and human perceptual characteristics, the dimensions characterizing the visual complexity were determined and defined. Results: Based on a framework and complexity dimensions, a set of metrics for quantifying the visual complexity was developed. Conclusion: We suggest metrics in terms of perceived visual complexity that can evaluate the in-vehicle displays. Application: This study can provide the theoretical bases in order to evaluate complicated systems. In addition, it can quantitatively measure the visual complexity of In-vehicle information system and be helpful to design in terms of preventing risks, such as human error and distraction.

• The KIPS Transactions:PartD
• /
• v.8D no.1
• /
• pp.71-80
• /
• 2001

Object-Oriented (OO) methodology to use the concept like encapsulation, inheritance, polymorphism, and message passing demands metrics that are different from structured methodology. There are many studies for OO software metrics such as program complexity or design metrics. But the metrics for the analysis class need to decrease the complexity in the analysis phase so that greatly reduce the effort and the cost of system development. In this paper, we propose new metrics to measure the complexity of analysis classes which draw out in the analysis phase based on Unified Process. By the collaboration complexity, is denoted by CC, we mean the maximum number of the collaborations can be achieved with each of the collaborator and detennine the potential complexity. And the interface complexity, is denoted by IC, shows the difficulty related to understand the interface of collaborators each other. We prove mathematically that the suggested metrics satisfy OO characteristics such as class size and inheritance. And we verify it theoretically for Weyuker' s nine properties. Moreover, we show the computation results for analysis classes of the system which automatically respond to questions of the it's user using the text mining technique. As we compared CC and IC to CBO and WMC, the complexity can be represented by CC and IC more than CBO and WMC. We expect to develop the cost-effective OO software by reviewing the complexity of analysis classes in the first stage of SDLC (Software Development Life Cycle).

• Journal of KIISE:Software and Applications
• /
• v.28 no.10
• /
• pp.720-731
• /
• 2001

Complexity metrics have been developed for the structured paradigm of software development are not suitable for use with the object-oriented(OO) paradigm, because they do not support key object-oriented concepts such as inheritance, polymorphism. message passing and encapsulation. There are many researches on OO software metrics such as program complexity or design metrics. But metrics measuring the complexity of classes at the OO analysis phase are needed because they provide earlier feedback to the development project. and earlier feedback means more effective developing and less costly maintenance. In this paper, we propose the new metrics to measure the complexity of analysis classes which draw out in the analysis based on RUP(Rational Unified Process). By the collaboration complexity, is denoted by CC, we mean the maximum number of the collaborations can be achieved with each of the collaborator and determine the potential complexity. And the interface complexity, is denoted by IC, shows the difficulty related to understand the interface of collaborators each other. We verify theoretically the suggested metrics for Weyuker's nine properties. Moreover, we show the computation results for analysis classes of the system which automatically respond to questions of the user using the text mining technique. As a result of the comparison of CC and CBO and WMC suggested by Chidamber and Kemerer, the class that have highly the proposed metric value maintain the high complexity at the design phase too. And the complexity can be represented by CC and IC more than CBO and WMC. We can expect that our metrics may provide us the earlier feedback and hence possible to predict the efforts, costs and time required to remainder processes. As a result, we expect to develop the cost-effective OO software by reviewing the complexity of analysis classes in the first stage of SDLC(Software Development Life Cycle).

• Journal of the Korea Computer Industry Society
• /
• v.2 no.3
• /
• pp.407-416
• /
• 2001

In this paper we propose a suite of metrics $\pi_{java}$ Java/, for evaluating the complexity of Java Programs based on a suite of metrics $\pi_{java}$ c++/, which we previously presented for C++ programs. So far, a lot of metrics for C++ are proposed for C++ programs. But since the specific properties of Java programs are not explicitly considered in those metrics, it is hard to apply them to Java programs. Thus we aim to develop a metric suite that is applicable to Java Programs. At first, we decide if any properties are commonly possessed by both C++ programs and Java programs, or not. For example, the multiple inheritance of the class in C++ is not implemented in Java. On the other hand, the features such as package and interface are newly implemented in Java, and therefore we cannot discuss the complexity of Java programs without considering these new features. Then we define a new suite of metrics $\pi_{java}$ Java/ for Java programs by deleting 3 metrics $\pi_{java}$/c++/, and then incorporating 3 metrics which are newly defined or modified for Java programs to $\pi_{java}$ c++/. Finally, we analytically evaluate the new metric with regard to Weyuker's measurement principles and also compare it with conventional metrics for Java.

• International Journal of Computer Science & Network Security
• /
• v.23 no.12
• /
• pp.187-193
• /
• 2023

Large software systems are being produced with a noticeably higher level of quality with component-based software engineering (CBSE), which places a strong emphasis on breaking down engineered systems into logical or functional components with clearly defined interfaces for inter-component communication. The component-based software engineering is applicable for the commercial products of open-source software. Software metrics play a major role in application development which improves the quantitative measurement of analyzing, scheduling, and reiterating the software module. This methodology will provide an improved result in the process, of better quality and higher usage of software development. The major concern is about the software complexity which is focused on the development and deployment of software. Software metrics will provide an accurate result of software quality, risk, reliability, functionality, and reusability of the component. The proposed metrics are used to assess many aspects of the process, including efficiency, reusability, product interaction, and process complexity. The details description of the various software quality metrics that may be found in the literature on software engineering. In this study, it is explored the advantages and disadvantages of the various software metrics. The topic of component-based software engineering is discussed in this paper along with metrics for software quality, object-oriented metrics, and improved performance.

• The Journal of Korean Institute of Communications and Information Sciences
• /
• v.27 no.10C
• /
• pp.887-901
• /
• 2002

Software management model divided into the software project model and design estimation model, software matrices model, reliability growth model, process improvement model(or process maturity model) etc. Among these software management models, software complexity model make an estimated of the product software. For a practice of software managed, need to guideline of the static analysis of software. Especially, Software complexity model introduced for the estimation of software quantity and program complexity. In case of measurement the software matrices, its need for us to analysis of software quality and products. On the other hand, we known that complexity program include many defects and consuming of source cost. So, we apply to complexity model using of the program complexity, control structure and volume matrices, interface metrics, process complexity metrics method. In this paper, we represent that the analysis of fault data detected during the system test. Also, we analysis of program control structure and interface, volume matrices in various aspect of switching software. Others, their results utilized similar of project and system development.

• Convergence Security Journal
• /
• v.10 no.1
• /
• pp.29-34
• /
• 2010

It is very important to evaluate the quality of soft wares based on SOA, which develops rapidly. Particularly, one of the most important properties influencing on the quality of system is complexity. Therefore, we propose the metrics for measuring a structural complexity of softwares based on SOA. The proposed metrics is composed of the size of a service, the depth of a service and interdependency from the viewpoint of system structure, and finally we applied the proposed metric to an example.

• Journal of Internet Computing and Services
• /
• v.3 no.4
• /
• pp.71-82
• /
• 2002

Recently. component-based software development is getting accepted in industry as a new effective software development paradigm, Since an introduction of component-based software engineering(CBSE) at later 90's, the CBSD research has focused largely on component modeling, methodology, architecture and platform, However. as the number of components available on the market increases, it becomes more important to make metrics to measure the various characteristics of components. In this paper. we propose metrics for measuring the complexity, customizability, and resuability of software components, Complexity of metrics can be used to evaluate the complexity of components Customizability is used to measure how efficiently and widely the components can be customized for specific requirements organization, Resuability can be used to measure the degree of features that is reused in building applications.

• Journal of the Korea Academia-Industrial cooperation Society
• /
• v.4 no.4
• /
• pp.346-351
• /
• 2003

In spite of the size and complexity of software becomes large and complicated, the demand of rapid development, cost reduction, good productivity and good quality software is increasing in these days. Many methods were proposed for efficient software development such as various Case tools. Metrics, Process improvement model (CMM, SPICE, ISO9000) and etc. However, most of them we useful to manage the whole projects rather than an individual programming. In this paper, we introduced a system for quality assessment and complexity metrics for Java programs to assess the individual programmer's quality rather than team's quality. This system shows not only the metrics value for quality assessment but also the source code and the soucture of classes simultaneously.

• Journal of the Korea Computer Industry Society
• /
• v.2 no.3
• /
• pp.377-388
• /
• 2001

Software metrics provide effective methods for characterizing software. Metrics have traditionally been composed through the definition of an equation, but this approach restricted within a full understanding of every interrelationships among the parameters. This paper use fuzzy logic system that is capable of uniformly approximating any nonlinear function and applying cognitive psychology theory. First of all, we extract multiple regression equation from the factors of 12 software complexity metrics collected from Java programs. We apply cognitive psychology theory in program volume factor, and then measure program volume complexity to execute fuzzy learning. This approach is sound, thus serving as the groundwork for further exploration into the analysis and design of software metrics.