• KIPS Transactions on Software and Data Engineering
• /
• v.8 no.7
• /
• pp.265-274
• /
• 2019

The reliability test performed when developing the weapon system software is classified into static test and dynamic test. In static test, checking the coding rules, vulnerabilities and source code metric are performed without executing the software. In dynamic test, its functions are verified by executing the actual software based on requirements and the code coverage is measured. The purpose of this static/dynamic test is to find out defects that exist in the software. However, there still exist defects that can't be detected only by the current reliability test on the weapon system software. In this paper, whether defects that may occur in the software can be detected by static test and dynamic test of the current reliability test on the weapon system is analyzed through experiments. As a result, we provide guidance on improving the reliability test of weapon system software, especially the dynamic test.

• Journal of Internet Computing and Services
• /
• v.3 no.4
• /
• pp.83-94
• /
• 2002

Recently for software development productivity a lot of researches in the field of software engineering hove focuses on the component-based software product lines which allows the reuse of forger-granularity software components Its purpose is to develop the specific software application of quality more rapidly by instantiating and assembling the components populated in software product line assets The essential part to build the component-based software product lines is the quality of components, and one of the most important features determining the quality of components is 'reconfigurability' Component reconfigurability means the extent to which the reusers can change the functions and architecture of the component according to their context and environment. This paper proposes the component code generation technique which provides the reconfigurability at the time of code generation using The feature diagram and XML/XSLT technologies The approach of this paper allows the component reusers to get automatically their own component source code by providing only the values of variabilities represented in the feature diagram of the component family. The real world example, the code generation system for o list container family, shows the applicability of the feature model and XML related technologies in the area of the generative programming. Our approach should be basis to build the component based software product lines and extensible to support the larger graularity components.

• Journal of KIISE:Computing Practices and Letters
• /
• v.8 no.4
• /
• pp.450-456
• /
• 2002

Open source web service softwares are usually running on UNIX-based operating systems. Choosing an operating system can affect web system performance. In this paper, we describe a source - code-level time measurement tool and measure a service time of each system call that Squid - open source web proxy cache - makes. We run Squid 2.4.STABLEl on Linux 2.4.2 and Solaris 8, and we compare the measured time. As a result, Linux 2.4.2 performs better than Solaris 8. It can be used as a guide for selecting system software on building web service using open source software, and also be used as a basis for enhancing the operating system performance of supporting web service software.

• Journal of KIISE:Software and Applications
• /
• v.30 no.1_2
• /
• pp.19-30
• /
• 2003

Based upon XML, a standard document format on the web, there have been many active studies on e-Commerce, wireless communication, multimedia technology and so forth. JML is an XML application suitable for understanding and reusing the source code written using JAVA for various purposes. And it is a DTD which can effectively express various information related to hierarchical class structures, class/method relationships and so on. This paper describes a tool which generates JML document by extracting a comment information from Java source code and information helpful for reusing and understanding by JML in terms of the reverse engineering and a tool which generates a skeleton code of Java application program from the document information included in the automatically or manually generated JML document in terms of the forward engineering. By using the result of this study, the information useful and necessary for understanding, analyzing or maintaining the source code can be easily acquired and the document of XML format makes it easy for developers and team members to share and to modify the information among them. And also, the Java skeleton coed generated form JML documents is a reliable robust code, which helps for developing a complete source code and reduces the cost and time of a project.

• Journal of the Korea Academia-Industrial cooperation Society
• /
• v.4 no.4
• /
• pp.346-351
• /
• 2003

In spite of the size and complexity of software becomes large and complicated, the demand of rapid development, cost reduction, good productivity and good quality software is increasing in these days. Many methods were proposed for efficient software development such as various Case tools. Metrics, Process improvement model (CMM, SPICE, ISO9000) and etc. However, most of them we useful to manage the whole projects rather than an individual programming. In this paper, we introduced a system for quality assessment and complexity metrics for Java programs to assess the individual programmer's quality rather than team's quality. This system shows not only the metrics value for quality assessment but also the source code and the soucture of classes simultaneously.

• Journal of the Korea Society for Simulation
• /
• v.27 no.3
• /
• pp.23-36
• /
• 2018

Discrete Event System Specification (DEVS) has been used for decades as it provides sound semantics for hierarchical modular specification of discrete event systems. Instead of the mathematical specification, the DEVS diagram, based on the structured DEVS formalism, has provided more intuitive and convenient representation of complex DEVS models. This paper proposes a clean room process for implementation and verification of a DEVS diagram model specification into a simulation software source code. Specifically, it underlies a sequence of transformation steps from conformance and integrity checking of a given diagram model, translation into a corresponding tabular model, and finally conversion to a simulation source code, with each step being inversely verifiable for traceability. A simple example helps developers to understand the proposed process with associated transformation methods; a case study shows that the proposed process is effective for and adaptable to practical simulation software development.

• Journal of the Semiconductor & Display Technology
• /
• v.20 no.3
• /
• pp.113-116
• /
• 2021

As artificial intelligence technologies, including deep learning, develop, these technologies are being introduced to code similarity analysis. In the traditional analysis method of calculating the graph edit distance (GED) after converting the source code into a control flow graph (CFG), there are studies that calculate the GED through a trained graph neural network (GNN) with the converted CFG, Methods for analyzing code similarity through CNN by imaging CFG are also being studied. In this paper, to determine which approach will be effective and efficient in researching code similarity analysis methods using artificial intelligence in the future, code similarity is measured through funcGNN, which measures code similarity using GNN, and Siamese Network, which is an image similarity analysis model. The accuracy was compared and analyzed. As a result of the analysis, the error rate (0.0458) of the Siamese network was bigger than that of the funcGNN (0.0362).

• The KIPS Transactions:PartD
• /
• v.9D no.5
• /
• pp.847-858
• /
• 2002

A purpose of the object-oriented programming is to promote reuse and development time, and to improve software quality. A way for this purpose is using a design information well-defined and tested in previous time when developing software. Such design information is called design patterns. The design patterns are descriptions of abstract solution to recurse software design problems In a systematic and general way. But because the design patterns are descriptions of abstract solution, the specification and application of patterns generally rely on manual implementation and is applied to various forms. As a result, we need to spend a lot of time to develop software program not only because of difficulty in analyzing and applying to patterns consistently, but also because of the frequent programing faults. And because the applied design patterns don't express inside application visually, it is difficult to analyze and test for this design patterns. In this paper, we propose automatic source code generating technique to be able to efficiently apply the element of design patterns when developing application. And we show a way to analyze and use the applied design patterns in application. As a result, the design patterns in application provide the consistent structure and efficiency, and make analysis and using effect increased.

• Journal of KIISE:Software and Applications
• /
• v.36 no.11
• /
• pp.891-900
• /
• 2009

The priority of software maintenance researches has been increasing, since the lengths of software lifecycle are more increasing. Measuring couplings among software entities provides a good quantitative source for analyzing source code and point out candidate refactoring positions. Logical-coupling measures how strongly two software entities are related with each other from the evolutionary point of view. The researches on logical-coupling have been focusing on improving the correctness and explaining more aspects that are hiding by measuring logical-coupling among finer-grained entities. However, existing researches on logical-coupling fails to consider characteristics of developers and projects reflected in transactions. The research proposes a logical-coupling measurement method based on transaction time, size and expertise of developer to improve the correctness by considering characteristics of developers and projects reflected in transactions. The method has been validated by applying it to three open-source projects.

• International Journal of Computer Science & Network Security
• /
• v.24 no.5
• /
• pp.191-197
• /
• 2024

Software reuse gives the meaning for rapid software development and the quality of the software. Most of the Java components/libraries open-source are available only in Java Archive (JAR) file format. When a software design enters into the development process, the developer needs to select necessary JAR files manually via analyzing the given software architecture and related JAR files. This paper proposes an automated approach, JarBot, to suggest all the necessary JAR files for given software architecture in the development process. All related JAR files will be downloaded from the internet based on the extracted information from the given software architecture (class diagram). Class names, method names, and attribute names will be extracted from the downloaded JAR files and matched with the information extracted from the given software architecture to identify the most relevant JAR files. For the result and evaluation of the proposed system, 05 software design was developed for 05 well-completed software project from GitHub. The proposed system suggested more than 95% of the JAR files among expected JAR files for the given 05 software design. The result indicated that the proposed system is suggesting almost all the necessary JAR files.