• Journal of Information Technology Services
• /
• v.10 no.4
• /
• pp.219-227
• /
• 2011

Service Oriented Architecture (SOA) is rapidly emerging as the efficient approach in contemporary complex, heterogeneous computing environments. SOA increases the adaptability by loose coupling and its main feature is that three elements such as service provider, service requester and service registry are connected with each other systematically. To design the service-oriented system efficiently, a metric to measure the coupling between services accurately is needed. In this paper, we propose four coupling metrics for SOA based softwares. First, we suggest a coupling metric for service-oriented systems by modifying an established coupling metric of object-oriented systems. Then we suggest another coupling metric which includes indirect coupling between services. We also suggest two relative coupling metrics to measure coupling between subsystems. We investigate the theoretical soundness of the proposed metrics by the axioms of Briand et al. Finally, we apply the presented metrics to an industrial-scale case study.

• Journal of the Korean Institute of Intelligent Systems
• /
• v.14 no.6
• /
• pp.793-799
• /
• 2004

Many researches and validations for the complexity metrics of the object-oriented systems have been studied. Most of them are aimed for the measurement of the partial aspects of the systems, for example, the coupling between objects, the complexity of inheritance structures, the cohesion of methods, and so on. But the software practitioners want to measure the complexity of overall system, not partial. We studied the complexity of the overall structures of object-oriented systems by analyzing the class diagram of UML. The class diagram is composed of classes and their relations. There are three kinds of relations, association, generalization, and aggregation, which are making the structure of object-oriented systems to be difficult to understand. We proposed a heuristic metric to measure the complexity of object-oriented systems by putting together the three kinds of the relations. This metric will be helpful to the software developers for their designing tasks by evaluating the complexity of the structures of object-oriented system and redesigning tasks of the system.

• The Transactions of the Korea Information Processing Society
• /
• v.7 no.2
• /
• pp.373-384
• /
• 2000

There are many researches about metrics to measure a quality of Object-Oriented(OO) software. However, most of them have only discussed a concept or properties of metrics, and have not shown the detailed procedure for measuring them. They also define a measurement indicator as a threshold, but it has been influenced on a project size or application domains. In this paper, we propose metrics based on characteristics of OO design such as size, complexity, coupling and cohesion, and use a propotion to an average as the measurement indicator. It is easy to classify classes which have a result above the average, and to predict classes which reduced the quality of OO design. They will be modified to hold the average. Proposed metrics are analytically evaluated by Weyuker's nine properties. They are satisfied with seven properties except two properties co not apply to OO metrics. Also, we design a quality assessment system, ASSOD(ASsessment System of Object oriented Design), to measure the quality of the OO design independent of the platform.

• Journal of the Korean Institute of Intelligent Systems
• /
• v.12 no.6
• /
• pp.537-542
• /
• 2002

We propose new metrics for understandability and modifiability of class inheritance structures based on the object-oriented metrics suggested by Chidamber and Kemerer. The metrics are evaluated using the results of Gursaran s experiments which validated the empirical relation of DIT(Depth of Inheritance Tree) and NOC(Number of Children) metrics of Chidamber and Kemerer.

• Journal of the Korea Institute of Information and Communication Engineering
• /
• v.18 no.3
• /
• pp.742-748
• /
• 2014

The research of the object-oriented visual programming education is related to investigate the instructional method for computer programming, the process for program development for students, and the suitability analysis and design methodology for program development. In order to develop the educational methodology for the students who have the difficulties to study the computer programming and to enhance the abilities for the development of object-oriented programs, in this paper, we suggest the evaluation metrics to apply and assess for the object-oriented programming education. Also, we introduce the visual programming education methodology and curriculum using Alice programming. The evaluation metrics for the visual programming education suggested in this paper, is accepted when the visual programming languages/tools are used in the programming education to assess and analyze the suitabilities for the programming education for students, so to utilize the analyses for abilities of understanding, abstraction, and program implementation by level.

• Journal of KIISE:Software and Applications
• /
• v.31 no.9
• /
• pp.1131-1141
• /
• 2004

Cohesion refers to the degree of the relatedness of the elements in a module, and it is widely accepted that the module of higher cohesion is easier to understand, maintain, and reuse. Recently, several cohesion metrics have been proposed to measure the cohesiveness of classes in an object-oriented program. However, the existing cohesion metrics do not consider the characteristics of dependent instance variables that are commonly used in a class and, thus, do not properly reflect the cohesiveness of the class. This paper presents an approach for improving the cohesion metrics by considering the characteristics of the dependent instance variables in an object-oriented program. To demonstrate the importance of the dependent instance variables, a case study has been conducted on a class library.

• The KIPS Transactions:PartD
• /
• v.10D no.5
• /
• pp.859-872
• /
• 2003

Class hierarchies often constitute the backbone of object-oriented software. Their quality is therefore quite crucial. Building class hierarchies with good qualify is a very important and common tasks on the object oriented software development, but such hierarchies are not so easy to build. Moreover, the class hierarchy structure under construction is frequently restructured and refined until it becomes suitable for the requirement on the iterative and incremental development lifecycle. Therefore, there has been renewal of interest in all methodologies and tools to assist the object oriented developers in this task. In this paper, we define a set of quantitative metrics which provide a wav of capturing features of a rough estimation of complexity of class hierarchy structure. In addition to, we suggest a set of algorithms that transform a original class hierarchy structure into reorganized one based on the proposed metrics for class hierarchy structure. Furthermore, we also prove that each algorithm is "object-preserving". That is, we prove that the set of objects are never changed before and after applying the algorithm on a class hierarchy. The technique presented in this paper can be used as a guidelines of the construction, restructuring and refinement of class hierarchies. Moreover, the proposed set of algorithms based on metrics can be helpful for developers as an useful instrument for the object-oriented software development.velopment.

• 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.

• Journal of KIISE:Software and Applications
• /
• v.31 no.6
• /
• pp.728-740
• /
• 2004

The increasing complexity and shorter life cycle of software have made it necessary to reuse software. Object-oriented development had not provided extensive reuse and computing infrastructures are evolving from mainframe to distributed environments. However, components provide more advanced means of structuring, describing and developing system, because they are more coarse-grained and have more domain-specific aspects than objects. And they are also suited for distributed environment due to their reusability and granularity. In this paper, we present a process including the static metrics and guidelines that can be applied to transform object-oriented systems into component-based systems. Our process consists of two parts: First, basic components are created based upon composition and inheritance relationships between classes. Second, intermediate system is refined into component-based system with the static metrics and guidelines we propose.

• KIPS Transactions on Software and Data Engineering
• /
• v.2 no.10
• /
• pp.651-660
• /
• 2013

Object oriented design brought up improvement of productivity and software quality by adopting some concepts such as inheritance and encapsulation. However, both the number of software's classes and object couplings are increasing as the software volume is becoming larger. The object coupling between classes is closely related with software complexity, and high complexity causes decreasing software quality. In order to solve the object coupling issue, IT-field researchers adopt a component based development and software quality metrics. The component based development requires explicit representation of dependencies between classes and the software quality metrics evaluates quality of software. As part of the research, we intend to gain a basic data that will be used on decomposing software. We focused on properties of the linkage between classes rather than previous studies evaluated and accumulated the qualities of individual classes. Our method exploits machine learning technique to analyze the properties of linkage and predict the strength of dependency between classes, as a new perspective on analyzing software property.