Jeong-Hoon Ji

A source code linearization technique for detecting plagiarized programs

It is very important to detect plagiarized programs in the field of computer science education. Therefore, many tools and algorithms have been developed for this purpose. Generally, these tools are operated in two phases. In phase 1, a program plagiarism detecting tool generates an intermediate representation from a given program set. The intermediate representation should reflect the structural characterization of the program. Most tools use the parse tree or token sequence by intermediate representation. In phase 2, the program looks for plagiarized material and evaluates the similarity of two programs. It is helpful to announce the plagiarized metarials between two programs to the instructor. In this paper, we present the static tracing method in order to improve program plagiarism detection accuracy. The static tracing method statically executes a program at the syntax-level and then extracts predefined keywords according to the order of the executed functions. The result of experiment proves this method can detect plagiarism more effectively than the previously released plagiarism detecting method.

Source Code Similarity Detection Using Adaptive Local Alignment of Keywords

Program similarity checking is an important application of programming education fields. Local alignment is one of the typical algorithms for comparing two strings. However local alignment based comparison does not reflect the weights of program keywords. This paper introduces an adaptive local alignment which reflects the frequencies of keywords to the similarity matrix. We experimented this method using a set of programs submitted to more than 10 real programming contests. The experimental result shows that the adaptive local alignment is more robust than greedy-string-tiling adopted in JPlag.

Revising cohesion measures by considering the impact of write interactions between class members

Cohesion refers to the degree of the relatedness of the members in a class and several cohesion measures have been proposed to quantify the cohesiveness of classes in an object-oriented program. However, the existing cohesion measures do not differentiate write interactions from read interactions between class members, thus, do not properly reflect the cohesiveness of the class. This paper presents the revised versions of the existing five cohesion measures by considering the impact of write interactions between class members. In addition, we prove that the revised measures can be reduced into the original ones. To demonstrate the importance of write interactions, we have developed tools for automatic computation of the original and the revised cohesion measures and performed a case study where we found that write interactions are so commonly used in classes that they have much influence on cohesion measurement and the revised measures have stronger relations with change-proneness of classes than the original ones.

Understanding the evolution process of program source for investigating software authorship and plagiarism

This paper addresses the evolution process of program source codes to establish the framework for software authorship identification. Since program code cheating is getting serious in academic institutions, we will be able to apply the software authorship identification tool as a detection tool for code plagiarism. The main contribution of our work is twofold. First, we have devised new asymmetric distance measure to compute the distance of authorship between two different programs. Second, we have proposed an algorithm to construct the evolution tree(hylogenetic tree) for a set of similar program clones. For the experiment we have gathered two set of codes: a set of assignment programs and another program set which have been submitted to the ICPC, an international programming contests. Our experiment showed that our distance measure for program sources has successfully identified the code authorship and has also reliably detected plagiarized programs. This experiment has showed a strong possibility that the proposed construction algorithm for phylogenetic forest can be used to trace the evolution(improving) process of software. This paper shows the confidence of the authorship identification and plagiarism detection can be interchangeably applied for both these purposes in student assignment program domain.

Analysis and Visualization for Comment Messages of Internet Posts

There are many internet users who collect the public opinions and express their opinions for internet news or blog articles through the replying comment on online community. But, it is hard to search and explore useful messages on web blogs since most of web blog systems show articles and their comments to the form of sequential list. Also, spam and malicious comments have become social problems as the internet users increase. In this paper, we propose a clustering and visualizing system for responding comments on large-scale weblogs, namely `Daum AGORA,` using similarity analysis. Our system shows the comment clustering result as a simple screen view. Our system also detects spam comments using Needleman-Wunsch algorithm that is a well-known algorithm in bioinformatics.

Design and Implementation of Retargetable Software Debugger Based on GDB

Many processors for embedded system have been developed and is widely being used in many industrial area. If we develop a new embedded processor, we need a simulator, compiler, and debugger for developing an operating system and basic program running on the embedded processor. The debugger is used for finding the error in a program. theses software are very important in embedded system. In this paper, we design and implement a retargetable software debugger for a new 32-bit microprocessor. Our software debugger is based on GNU debugger (GDB) which is a widely used open-source debugger. We explain how to develop a retagetable software debugger for a new embedded processor rapidly. In order to develop a debugger rapidly, we extended only processor-dependent modules for register, memory and instruction set. And, we reused the processor-independent modules in the debugger. In the experiment, we tried to compare our software debugger with ARM AXD debugger to verify the debugger operation. The ARM AXD Debugger is well-known debugger for ARM processor.

A Case Study on Programming Intelligent Swarm Robots Using Pyro Environment and Player/Stage Simulator

A set of robots which shows an intelligent behavior as a whole is called swarm robots. Programming real swarm robots needs a lot of financial cost because many robot hardware systems should be purchased to test the implemented swarm intelligence. In this paper, we report a case study on programming swarm intelligence to control a set of robots using Pyro. Pyro (Python Robotics) is a Python based programming environment to provide a common platform for controlling robots. In practice, Pyro is normally operates on top of a simulator such as Player/Stage. This paper reports the experience on programming swarm robots searching for target objects in a maze. The swarm robots implemented can successfully move the target objects in a maze to the home location, where the robots started from.

A visualization system of source codes using FOL

It is a tedious and time-consuming task to understand the source code of a program, even for programming experts. Not a few methods suggested measuring the complexity of a source code, namely software metrics. But, every software metrics focuses on a specific facet of the source code and it also needs a specific knowledge of the software metric discipline to understand the metric values. In some cases, however, wepsilad like to get a glance of the complexity of the structure of a program without a specific knowledge or a burden of analyzing the details of the program structure. This paper suggests a new visualization method which is based on FOL (flower of life) diagram. The visualization result is intuitive for programming novices and can be presented in different levels of details. Further, we suggested a method to measure the complexity of the visualization result. According to the experimental results, the correlation between the complexity of the FOL diagram and the execution time of programs is in a meaningful range.

Evolution Analysis of Homogenous Source Code and its Application to Plagiarism Detection

Due to intelligent softwares and worldwide internet environment, unauthorized source code theft/copying and partial plagiarism is widespread. So the detecting the plagiarized source codes and software is getting important, especially in academic field. Though there have been announced lots of studies for detecting plagiarized pair of codes, we did not find somewhat more fundamental work for understanding the mechanism of plagiarism. So in order to improve the plagiarism detecting algorithm, it is desirable to reveal the whole procedure of code plagiarism. The basic idea of this paper is that software plagiarism can be considered as an evolution process of a source code. The final goal of our paper is to reconstruct the phylogenetic tree with a set of plagiarized codes. The main contribution of this paper is to propose an asymmetric code similarity measure, which enables us to guess the direction of plagiarism. For this purpose, we applied local alignment approach to detect a region of similar codes with a novel adaptive matching score matrix. To show the effectiveness and efficiency of our procedure, we conducted experiments on 20 artificially generated phylogenetic trees whose roots are selected from four program groups of ICPC (International Collegiate Programming Contest). Experiment showed that the proposed algorithm can effectively estimate the evolution direction, which enables us to identify plagiarized codes more accurately and reliably.

Design methodology for on-chip-based processor debugger

Due to the increased complexity of modern embedded systems and time-to-market constraints, a debugger with efficient debugging functions is becoming increasingly necessary, and it plays an important role in the development of application systems. Accordingly, the implementation of efficient debug functionalities must a critical process in the design of a new processor. Since deeply embedded processor cores in a core-based system chip allow only restricted access for debugging its internal status, most recent processors employ the on-chip-based debug method that embeds special logic-supporting debug capabilities. In this paper, we propose an on-chip debug support logic that can be embedded into the processor core to support debug functions. Moreover, we describe an overall implementation method of the on-chip-based processor debugger based on the on-chip debug support logic, which includes a source-level debugger and an interface block. We designed an on-chip debug support logic, and embedded it into a target processor core. We used the GNU Project debugger (GDB) as the source-level debugger of the target processor core. An interface block that uses the remote debugging features of GDB was also developed and that includes a software module and a hardware board. We discuss all major design steps for implementing this on-chip-based processor debugger. We have successfully applied the proposed implementation method to develop the processor debugger for two new 32-bit RISC processors. In addition, we introduce another use of the on-chip-based processor debugger in the design of a processor-based system chip, which can facilitate simulation-based functional verification.