• The Transactions of the Korean Institute of Electrical Engineers D
• /
• v.51 no.11
• /
• pp.514-520
• /
• 2002

n industrial computer vision systems, the image quality is dependent on the parameters such as light source, illumination method, optics, and surface properties. Most of them are related with the lighting system, which is designed in heuristic based on the designer's experimental knowledge. In this paper, a design code by which the optimal lighting method and light source for computer vision systems can be found are suggested based on experimental results. The design coed is applied to the design of the lighting system for the transistor marking inspection system, and the overall performance of the machine vision system with the lighting system show the effectiveness of the proposed design code.

• Proceedings of the KIEE Conference
• /
• 2002.06a
• /
• pp.41-45
• /
• 2002

In industrial computer vision systems, the image quality is dependent on the parameters such as light source, illumination method, optics, and surface properties. Most of them are related with the lighting system, which is designed in heuristic, based on the designer's experimental knowledge, In this paper, a design code by which the optimal lighting method and light source for computer vision systems can be found are suggested based on experimental results, To prove the usefulness of the design code, it is applied to the lighting system design of the transistor marking inspection system and the results are presented.

• Journal of the Korea Society of Computer and Information
• /
• v.13 no.4
• /
• pp.1-9
• /
• 2008

Most consumer electronics companies hold numerous line-ups to cope with divergent customer's needs. To cope with current situation, most products are derived from the 'base product' which is developed for brand new features with respect to the change requests. That is called derivation. After 'base code' is developed for newly introduced products, some modification will occur corresponding to the derivative product models. So, quality attributes of 'base code' affects quality and productivity of 'derived code'. But in the middle of continuous modification to 'base code', violation of architectural design decision and unauthorized or maybe unsophisticated change to source code willing to happen and thus it cause critical problem. Those code has 'aging symptom' both architectural and code level in nature. In this paper, we introduced reengineering framework which guide the procedure and tactics to find and fix 'aging symptom' for improvement on quality attribute of 'base code'.

• Journal of Multimedia Information System
• /
• v.4 no.4
• /
• pp.255-262
• /
• 2017

In recent software development, repetitive code fragments (i.e., clones) are common due to the copy-and-paste programming practice, the framework-based development, or the reuse of same design patterns. Such similar code fragments are likely to introduce more bugs but are easily disregarded by a code reviewer or a programmer. In this paper, we present a code review tool to help code reviewers identify important code changes written by other programmers and recommend which changes need to be reviewed first. Specifically, to identify important code changes, our approach detects code clones across revisions and investigates them. Then, to help a code reviewer, our approach ranks the identified changes in accordance with several software quality metrics and statistics on those clones and changes. Furthermore, our approach allows the code reviewer to express their preferences during code review time. As a result, the code reviewer who has little knowledge of a code base can reduce his or her effort by reviewing the most significant changes that require an instant attention. To evaluate our approach, we integrated our approach with a modern IDE (e.g., Eclipse) as a plugin and then analyzed two third-party open source projects. The experimental results indicate that our approach can improve code reviewer's productivity.

• Journal of the Korea Society of Computer and Information
• /
• v.21 no.8
• /
• pp.65-75
• /
• 2016

In this paper, we present a novel approach to help MSR researchers obtain necessary data with a tool, termed General Purpose Extractor for Source code (GPES). GPES has a single function extracts high-quality data, e.g., the version history, abstract syntax tree (AST), changed code diff, and software quality metrics. Moreover, features such as an AST of other languages or new software metrics can be extended easily given that GPES has a flexible data model and a component-based design. We conducted several case studies to evaluate the usefulness and effectiveness of our tool. Case studies show that researchers can reduce the overall cost of data analysis by transforming the data into the required formats.

• The Transactions of the Korea Information Processing Society
• /
• v.5 no.8
• /
• pp.2041-2049
• /
• 1998

This paper suggests a technique for program segmentation and maintenance using PSDG(Post-State Dependency Graph) that improves the quality of a software by identifying and detecting defects in already fixed source code. A program segmentation is performed by utilizing source code analysis which combines the measures of static, dynamic and semantic slicing when we need understandability of defect in programs for corrective maintanence. It provides users with a segmental principle to split a program by tracing state dependency of a source code with the graph, and clustering and highlighting, Through a modeling of the PSDG, elimination of ineffective program deadcode and generalization of related program segments arc possible, Additionally, it can be correlated with other design modeb as STD(State Transition Diagram), also be used as design documents.

• Nuclear Engineering and Technology
• /
• v.54 no.6
• /
• pp.2077-2083
• /
• 2022

In the unlikely event of core disruptive accident in sodium cooled fast reactors, the reactor containment building would be bottled up with sodium and fission product aerosols. The behavior of these aerosols is crucial to estimate the in-containment source term as a part of nuclear reactor safety analysis. In this work, the evolution of sodium aerosol characteristics (mass concentration and size) is simulated using HAARM-S code. The code is based on the method of moments to solve the integro-differential equation. The code is updated to FORTRAN-77 and run in Microsoft FORTRAN PowerStation 4.0 (on Desktop). The sodium aerosol characteristics simulated by HAARM-S code are compared with the measured values at Aerosol Test Facility. The maximum deviation between measured and simulated mass concentrations is 30% at initial period (up to 60 min) and around 50% in the later period. In addition, the influence of humidity on aerosol size growth for two different aerosol mass concentrations is studied. The measured and simulated growth factors of aerosol size (ratio of saturated size to initial size) are found to be matched at reasonable extent. Since sodium is highly reactive with atmospheric constituents, the aerosol growth factor depends on the hygroscopic growth, chemical transformation and density variations besides coagulation. Further, there is a scope for the improvement of the code to estimate the aerosol dynamics in confined environment.

• Proceedings of the Korea Information Processing Society Conference
• /
• 2024.05a
• /
• pp.53-56
• /
• 2024

Though lots of approaches to develop mobile apps are suggested up to now, developers have difficulties selecting a right one. This study compares native and cross-platform application development approaches, particularly focusing on the shift in preference from Java to Kotlin and the increasing use of Flutter. This research offers practical insights into factors influencing developers' choice of programming languages and frameworks in mobile application development by creating identical applications using Java, Kotlin, and Dart (Flutter). Furthermore, this study explores the best practices for development by examining the quality of code in 45 open-source GitHub repositories. The study evaluates LOC and code smells using semi-automated SonarQube assessments to determine the effects of selecting a specific language or framework on code maintainability and development efficiency. Preliminary findings show differences in the quality of the code produced by the two approaches, offering developers useful information on how to best optimize language and framework selection to reduce code smells and improve project maintainability.

• Journal of the Korea Convergence Society
• /
• v.12 no.9
• /
• pp.11-19
• /
• 2021

A software system is required to change during its life cycle due to various requirements such as adding functionalities, fixing bugs, and adjusting to new computing environments. Such program code modification should be considered as carefully as a new system development becase unexpected software errors could be introduced. In addition, when reusing open source programs, we can expect higher quality software if code changes of the open source program are predicted in advance. This paper proposes a Convolutional Neural Network (CNN)-based deep learning model to predict source code changes. In this paper, the prediction of code changes is considered as a kind of a binary classification problem in deep learning and labeled datasets are used for supervised learning. Java projects and code change logs are collected from GitHub for training and testing datasets. Software metrics are computed from the collected Java source code and they are used as input data for the proposed model to detect code changes. The performance of the proposed model has been measured by using evaluation metrics such as precision, recall, F1-score, and accuracy. The experimental results show the proposed CNN model has achieved 95% in terms of F1-Score and outperformed the multilayer percept-based DNN model whose F1-Score is 92%.

• Journal of Internet Computing and Services
• /
• v.12 no.6
• /
• pp.161-170
• /
• 2011

Despite some practical confusion over the variations in the diagram which may be drawn differently depending upon the CASE, the statechart of UML has been widely used to show the dynamic behaviour of the systems. Prior research has employed either simple switch-case statement or the state design pattern to generate source code from the statechart, which may result in varying source codes. This paper made an attempt to formally define the statechart and generate source codes from it. Firstly we cleaned up the XMI which was generated from different CASEs. This XMI has been translated to the EHA to identify automata contained in it. Then the elements of the statechart metamodel were mapped to the java programs. We also verified the quality of source codes by measuring functionality and maintainability. The case employed in this study was the air conditioner. The reason was that the case includes various states and transitions of interest. It was found that XMI was well extracted by removing some legacy codes in the CASE and the source codes were then successfully generated with the concurrency and hierarchy of the statechart. Further research is required to validate it practical significance with a larger case.