Perancangan dan Implementasi Program Pengukuran Kualitas Desain Perangkat Lunak pada Google Web Toolkit Menggunakan Object Oriented Metrics

ABSTRAKSI: Object Oriented Metrics merupakan pendekatan pengukuran fungsional dan analisis data pada desain object oriented yang menitikberatkan pada kombinasi fungsi dan data sebagai object yang terintegrasi. Metrik merupakan hasil numerisasi pada desain aplikasi yang menggunakan Object Oriented design pada proses pengembangannya. Hal-hal yang diperlukan dalam pengukuran metrik adalah jumlah inheritance pada sebuah kelas, coupling antar method pada satu kelas, coupling atribut antar object, jumlah method dalam suatu object. Belum adanya aplikasi pengukuran metrik yang tersedia untuk mengukur aplikasi yang dibangun menggunakan framework menjadi sebab program pengukuran metrik ini dibangun untuk mengukur nilai metrik pada sebuah aplikasi yang menggunakan suatu framework.Program pengukuran metrik dapat mengukur kualitas aplikasi ATM Simulation java Swing dan aplikasi Sales Processing System framework Google Web Toolkit. Metrik yang diukur terdiri dari CBO, NOC, DIT, WMC dan RFC. Keenam metrik tersebut termasuk dalam Chidamber dan Kemerer (CK) metrik.Dari hasil analisis program pengukuran metrik pada Sales Processing System memiliki reusability dan maintainability yang tinggi sedangkan aplikasi ATM Simulation memiliki usability, maintainability, testability yang tinggi.Kata Kunci : metrik, coupling, inheritance, frameworkABSTRACT: Object Oriented Metrics is a functional approach to measurement and analysis of data on object-oriented design that focuses on the combination of functions and data as an integrated object. Metric is the result numerisasi on the design of applications using Object Oriented design on its development process. Things that are needed in the measurement metric is the amount of inheritance in a class, the coupling between the method on a class, coupling between object attributes, the number of methods in an object. The absence of metric measurement applications are available for measuring application built using a framework for measurement metrics program is constructed to measure the value of metrics on an application that uses a framework.Metric measurement program can measure the quality of ATM Simulation java Swing applications and applications Sales Processing System framework Google Web Toolkit. Metrics that measure consists of CBO, NOC, DIT, WMC and RFC. The five metrics are included in the Chidamber and Kemerer (CK) metrics.Analysis of the measurement program metrics on Sales Processing System has high reusability and maintainability of the application while the ATM Simulation have usability, maintainability, testability is high.Keyword: metrics, coupling, inheritance, framewor

Weighted Class Complexity: A Measure of Complexity for Object Oriented System

Software complexity metrics are used to predict critical information about reliability and maintainability of software systems. Object oriented software development requires a different approach to software complexity metrics. In this paper, we propose a metric to compute the structural and cognitive complexity of class by associating a weight to the class, called as Weighted Class Complexity (WCC). On the contrary, of the other metrics used for object oriented systems, proposed metric calculates the complexity of a class due to methods and attributes in terms of cognitive weight. The proposed metric has been demonstrated with OO examples. The theoretical and practical evaluations based on the information theory have shown that the proposed metric is on ratio scale and satisfies most of the parameters required by the measurement theor

STATIC CODE ANALYSIS FOR SOFTWARE QUALITY IMPROVEMENT: A CASE STUDY IN BCI FRAMEWORK DEVELOPMENT

This paper shows how the systematic approach in software testing using static code analysis method can be used for improving the software quality of a BCI framework. The method is best performed during the development phase of framework programs. In the proposed approach, we evaluate several software metrics which are based on the principles of object oriented design. Since such method is depending on the underlying programming language, we describe the method in term of C++ language programming whereas the Qt platform is also currently being used. One of the most important metric is so called software complexity. Applying the software complexity calculation using both McCabe and Halstead method for the BCI framework which consists of two important types of BCI, those are SSVEP and P300, we found that there are two classes in the framework which have very complex and prone to violation of cohesion principle in OOP. The other metrics are fit the criteria of the proposed framework aspects, such as: MPC is less than 20; average complexity is around value of 5; and the maximum depth is below 10 blocks. Such variables are considered very important when further developing the BCI framework in the future

Crosscutting, what is and what is not? A Formal definition based on a Crosscutting Pattern

Crosscutting is usually described in terms of scattering and tangling. However, the distinction between these concepts is vague, which could lead to ambiguous statements. Sometimes, precise definitions are required, e.g. for the formal identification of crosscutting concerns. We propose a conceptual framework for formalizing these concepts based on a crosscutting pattern that shows the mapping between elements at two levels, e.g. concerns and representations of concerns. The definitions of the concepts are formalized in terms of linear algebra, and visualized with matrices and matrix operations. In this way, crosscutting can be clearly distinguished from scattering and tangling. Using linear algebra, we demonstrate that our definition generalizes other definitions of crosscutting as described by Masuhara & Kiczales [21] and Tonella and Ceccato [28]. The framework can be applied across several refinement levels assuring traceability of crosscutting concerns. Usability of the framework is illustrated by means of applying it to several areas such as change impact analysis, identification of crosscutting at early phases of software development and in the area of model driven software development

From a Domain Analysis to the Specification and Detection of Code and Design Smells

Code and design smells are recurring design problems in software systems that must be identified to avoid their possible negative consequences\ud on development and maintenance. Consequently, several smell detection\ud approaches and tools have been proposed in the literature. However,\ud so far, they allow the detection of predefined smells but the detection\ud of new smells or smells adapted to the context of the analysed systems\ud is possible only by implementing new detection algorithms manually.\ud Moreover, previous approaches do not explain the transition from\ud specifications of smells to their detection. Finally, the validation\ud of the existing approaches and tools has been limited on few proprietary\ud systems and on a reduced number of smells. In this paper, we introduce\ud an approach to automate the generation of detection algorithms from\ud specifications written using a domain-specific language. This language\ud is defined from a thorough domain analysis. It allows the specification\ud of smells using high-level domain-related abstractions. It allows\ud the adaptation of the specifications of smells to the context of\ud the analysed systems.We specify 10 smells, generate automatically\ud their detection algorithms using templates, and validate the algorithms\ud in terms of precision and recall on Xerces v2.7.0 and GanttProject\ud v1.10.2, two open-source object-oriented systems.We also compare\ud the detection results with those of a previous approach, iPlasma

An empirical study of aspect-oriented metrics

Metrics for aspect-oriented software have been proposed and used to investigate the benefits and the disadvantages of crosscutting concerns modularisation. Some of these metrics have not been rigorously defined nor analytically evaluated. Also, there are few empirical data showing typical values of these metrics in aspect-oriented software. In this paper, we provide rigorous definitions, usage guidelines, analytical evaluation, and empirical data from ten open source projects, determining the value of six metrics for aspect-oriented software (lines of code, weighted operations in module, depth of inheritance tree, number of children, crosscutting degree of an aspect, and coupling on advice execution). We discuss how each of these metrics can be used to identify shortcomings in existing aspect-oriented software. (C) 2012 Elsevier B.V. All rights reserved.CNPq [140046/06-2]; Project CNPQ-PROSUL [490478/06-9]; Capes-Grices [2051-05-2]; FAPERGS [10/0470-1]; FCT MCTESinfo:eu-repo/semantics/publishedVersio

A Domain Analysis to Specify Design Defects and Generate Detection Algorithms

Quality experts often need to identify in software systems design defects, which are recurring design problems, that hinder development\ud and maintenance. Consequently, several defect detection approaches\ud and tools have been proposed in the literature. However, we are not\ud aware of any approach that defines and reifies the process of generating\ud detection algorithms from the existing textual descriptions of defects.\ud In this paper, we introduce an approach to automate the generation\ud of detection algorithms from specifications written using a domain-specific\ud language. The domain-specific is defined from a thorough domain analysis.\ud We specify several design defects, generate automatically detection\ud algorithms using templates, and validate the generated detection\ud algorithms in terms of precision and recall on Xerces v2.7.0, an\ud open-source object-oriented system

Object-oriented cohesion as a surrogate of software comprehension: An empirical study

The concept of software cohesion in both the procedural and object-oriented paradigm is well known and documented. What is not so well known or documented is the perception of what empirically constitutes a cohesive 'unit' by software engineers. In this paper, we describe an empirical investigation using object-oriented (OO) classes as a basis. Twenty-four subjects (drawn from IT experienced and IT inexperienced groups) were asked to rate ten classes sampled from two industrial systems in terms of their overall cohesiveness; a class environment was used to carry out the study. Four key results were observed. Firstly, class size (when expressed in terms of number of methods) did not tend to influence the perception of cohesion by any subjects. Secondly, well-commented classes were rated most highly amongst both IT experienced and inexperienced subjects. Thirdly, the empirical study suggests that cohesion comprises a combination of various class factors including low coupling, small numbers of attributes and well-commented methods, rather than any single, individual class feature per se. Finally, the research supports the view that cohesion is a subjective concept reflecting a cognitive combination of class features; as such it is a surrogate for class comprehension

Modeling the object-oriented software process: OPEN and the unified process

A short introduction to software process modeling is presented, particularly object-oriented modeling. Two major industrial process models are discussed: the OPEN model and the Unified Process model. In more detail, the quality assurance in the Unified Process tool (formally called Objectory) is reviewed