• Journal of Information Processing Systems
• /
• v.16 no.4
• /
• pp.915-934
• /
• 2020

Software refactoring is a process to restructure an existing software code while keeping its external behavior the same. Currently, various refactoring techniques are being used to develop more readable and less complex codes by improving the non-functional attributes of software. Refactoring can further improve code maintainability by applying various techniques to the source code, which in turn preserves the behavior of code. Refactoring facilitates bug removal and extends the capabilities of the program. In this paper, an exhaustive review is conducted regarding bad smells present in source code, applications of specific refactoring methods to remove that bad smell and its effect on software quality. A total of 68 studies belonging to 32 journals, 31 conferences, and 5 other sources that were published between the years 2001 and 2019 were shortlisted. The studies were analyzed based on of bad smells identified, refactoring techniques used, and their effects on software metrics. We found that "long method", "feature envy", and "data class" bad smells were identified or corrected in the majority of studies. "Feature envy" smell was detected in 36.66% of the total shortlisted studies. Extract class refactoring approach was used in 38.77% of the total studies, followed by the move method and extract method techniques that were used in 34.69% and 30.61% of the total studies, respectively. The effects of refactoring on complexity and coupling metrics of software were also analyzed in the majority of studies, i.e., 29 studies each. Interestingly, the majority of selected studies (41%) used large open source datasets written in Java language instead of proprietary software. At the end, this study provides future guidelines for conducting research in the field of code refactoring.

• Journal of the Korea Society of Computer and Information
• /
• v.9 no.3
• /
• pp.27-34
• /
• 2004

As software developing paradigm has been changing to complicate Web environment, study of complexity becomes vigorous. Yet still it seems that general agreement has not to be reached to architecture or complexity measure of Web application. And so traditional complexity metrics - program size(LOC) and Cyclomatic Complexity can be derived from the source code after implementation. it is not helpful to the early phase of software development life cycle - analysis and design phase. In this study 6 Web projects has been used for deriving applications with possible errors suited by Complexity Indicator. Using 61 programs derived, linear correlation between complexity, number of classes and number of methods has been proposed. As Web application complexity could be estimated before implementation, effort and cost management will be processed more effectively.

• Journal of the Korea Society of Computer and Information
• /
• v.21 no.11
• /
• pp.159-166
• /
• 2016

Compiler course is one of the important courses in computer science. It requires more efficient learning environment because of its large coverage scale and complexity. One of its solutions is to provide the integrated development environment for educational compilers which is enable to give practice-oriented class and enhance student's interest. This paper presents the code generation support system developed in an integrated development environment of educational compiler. Our system helps students to understand the process of code generation and visualizes the relation among the source language, AST, and the target language. It makes students develop their own compilers more easily.

• Journal of the Institute of Electronics Engineers of Korea SP
• /
• v.47 no.5
• /
• pp.153-164
• /
• 2010

A program consumes energy by executing its instructions. The amount of cosumed power is mainly proportional to algorithm complexity and it can be calculated by using complexity information. Generally, the complexity of a S/W is estimated by the microprocessor simulator. But, the simulation takes long time why the simulator is a software modeled the hardware and it only provides the information about computational complexity quantitatively. In this paper, we propose a complexity estimation method of analysis of S/W on source code level and produce the complexity metric mathematically. The function-wise complexity metrics give the detailed information about the calculation-concentrated location in function. The performance of the proposed method is compared with the result of the gate-level microprocessor simulator 'SimpleScalar'. The used softwares for performance test are $4{\times}4$ integer transform, intra-prediction and motion estimation in the latest video codec, H.264/AVC. The number of executed instructions are used to estimate quantitatively and it appears about 11.6%, 9.6% and 3.5% of error respectively in contradistinction to the result of SimpleScalar.

• Journal of Korea Society of Digital Industry and Information Management
• /
• v.11 no.3
• /
• pp.31-43
• /
• 2015

In this paper, we discuss a code generation technique for custom transport triggered architecture (TTA) from a high-level language structure. This methodology is implemented by using TTA-based Co-design Environment (TCE) tool. The results show how the scheduler exploits instruction level parallelism in the custom target architecture and source program. Thus, the scheduler generates parallel TTA instructions using lower cycle counts than the sequential scheduling algorithm. Moreover, we take Tensilica tool to make a comparison with TCE. Because of the efficiency of TTA, TCE takes less execution cycles compared to Tensilica configurations. Finally, this paper shows that it requires only 7 cycles to generate the parallel TTA instruction set for implementing Cyclic Redundancy Check (CRC) applications as an input design, and presents the code generation technique to move complexity from the processor software to hardware architecture. This method can be applicable lots of channel Codecs like CRC and source Codecs like High Efficiency Video Coding (HEVC).

• Journal of Communications and Networks
• /
• v.13 no.3
• /
• pp.257-265
• /
• 2011

In this paper, a cooperative relaying protocol called soft-decision-and-forward (SDF) with multiple antennas in each node is introduced. SDF protocol exploits the soft decision source symbol values from the received signal at the relay node. For orthogonal transmission (OT), orthogonal codes including Alamouti code are used and for non-orthogonal transmission (NT), distributed space-time codes are designed by using a quasi-orthogonal space-time block code. The optimal maximum likelihood (ML) decoders for the proposed protocol with low decoding complexity are proposed. For OT, the ML decoders are derived as symbolwise decoders while for NT, the ML decoders are derived as pairwise decoders. It can be seen through simulations that SDF protocol outperforms AF protocol for both OT and NT.

• Journal of KIISE:Computing Practices and Letters
• /
• v.15 no.2
• /
• pp.140-144
• /
• 2009

The efficient test tool is indispensable to the test driven development. The test tool is very helpful to get the advantage of the test driven development. Many traditional automation test tool does not support standard script language and are not suitable to unit test. In traditional unit test tool, a code for the test is added at the source code. Such method makes the complexity of a source code and has a problem which must modify many part of the source code when the test case is changed. In this paper, we present a design technique of a flexible unit testing tool which makes a developer can modify easily the test case by using the standard java script in test driven development. We implement the test tool by this design technique to verify the availability of this technique.

• The Journal of Korean Institute of Communications and Information Sciences
• /
• v.36 no.2C
• /
• pp.105-111
• /
• 2011

In this paper, we propose a novel Alamouti space-time transmission scheme for orthogonal frequency division multiplexing (OFDM) based asynchronous cooperative communication systems with low relay complexity. The conventional scheme requires an additional operation likes time-reversal at the relay nodes besides the simple multiplications at the relay nodes, which result in increasing the complexity of relay nodes. Unlike the conventional scheme, exploiting the simple combination of the symbols at the source node and the simple multiplications at the relay nodes, the proposed scheme achieves the second order diversity gain by obtaining the Alamouti code structure at the destination node. Simulation results show that the proposed scheme achieves the second order diversity gain and has the same bit error rate performance as the conventional scheme.

• Journal of the Institute of Electronics Engineers of Korea SP
• /
• v.41 no.1
• /
• pp.57-68
• /
• 2004

Although variable-length codes (VLCs) increase coding efficiency using the statistical characteristics of the source data, they have catastrophic effects from bit errors in noisy transmission environments. In order to overcome this problem with VLCs, reversible variable-length codes (RVLCS) have recently been proposed owing to their data recovering capability. RVLCS can be divided into two categories: symmetrical and asymmetrical RVLCs. Although the symmetrical RVLC has generally more overheads than the asymmetrical RVLC, it has some advantages of simpler design and more efficient memory usage. However, existing symmetrical RVLCs still have high complexity in their code design and some room for improvement in coding efficiency. In this paper, we propose a new algorithm for constructing a symmetrical RVLC from the optimal Huffman code table. The proposed algorithm has a simpler design process and also demonstrates improved performance in terms of the average codeword length relative to the existing symmetrical RVLC algorithms.

• Journal of KIISE:Software and Applications
• /
• v.32 no.9
• /
• pp.847-852
• /
• 2005

Over the last decade, numerous complexity measurement techniques for Object-Oriented (OO) software system have been proposed for managing the effects of OO codes. These techniques may be based on source code analysis such as WMC (Weighted Methods per Class) and LCOM (Lack of Cohesion in Methods). The techniques are limited to count the number of functions (C++). However. we suggested a new weighted method that checks the number of parameters, the return value and its data type. Then we addressed an effective complexity measurement technique based on the weight of class interfaces to provide guidelines for measuring the class complexity of OO codes in reverse engineering. The results of this research show that the proposed complexity measurement technique ECC(Enhanced Class Complexity) is consistent and accurate in C++ environment.