Earticle

This paper suggests a visual debugging plaftorm based on the game engine, Unity3D for massive parallel processing routines implemented in CUDA. In general, it is tiresome to debug or check the accuracy of numerical geometry information results calculated in a parallel way by GPU; usually, developers would pick and check each numerical value by rummaging overwhelming lines of seemingly meaningless numbers. This manual process is less productive and time-consuming. Also, it is not easy to produce some continuous movements of geometry information to check the validity of implemented CUDA codes for realtime geometry processing applications. To solve those problems, this paper presents a way to use Unity3D game engine to visually and interactively debug CUDA implementations. Also, some practical test results are presented with discussions on limitations of Unity3D as a CUDA debugging platform.

현재 프로그래밍 교육은 문제해결력을 향상하기 위한 교육으로 프로그래밍과 같은 다양한 방법을 통해 진행되 며 오류가 포함된 프로그램으로부터 오류를 탐지하고 수정하는 디버깅 기반의 교육 방법 또한 논리적 사고력과 문제해결력을 향상하는 중요한 방법이다. 디버깅을 활용한 교육을 위해서는 오류가 포함된 프로그램을 생성하는 것이 중요하지만, 기존 연구들에서는 학생들의 프로그래밍 단계에서 발생할 수 있는 오류 분석에 치중하는 등 교 육용 블록 프로그래밍의 오류 생성에 관련된 연구는 부족한 상황이다. 본 논문에서는 디버깅 기반 프로그래밍 교 육을 위해 블록 기반의 교육용 프로그래밍 언어에서 오류가 포함된 프로그램을 생성해 디버깅 교육을 효과적으로 지원하기 위한 뮤테이션 연산자를 제안한다. 제안하는 뮤테이션 연산자는 문헌 연구 등을 통해 기존 프로그래밍 언어에서 사용된 뮤테이션 연산자와 자주 발생하는 오류 유형을 분석하여 블록 프로그래밍 언어에 적용할 수 있 도록 오브젝트/스프라이트 수준과 블록 수준에서 각각 12개와 16개로 제안한다. 또한 본 논문에서는 사례 연구를 통해 제안된 뮤테이션 연산자가 오류가 포함된 프로그램을 체계적으로 생성할 수 있음을 확인하였다.

Currently, programming education is delivered through various methods including programming to enhance problem- solving skills. Among these methods, a debugging based approach in which errors in faulty programs are detected and corrected, is also an useful and important means of improving logical reasoning and problem-solving abilities. Generating programs that contain errors is crucial for effective debugging-based instruction, existing studies has mainly focused on analyzing errors which occur during programming, and there is relatively little research on generating errors in educational block programming languages. In this paper, we propose mutation operators for educational block programming language to effectively support debugging by generating programs with errors. We analyzed mutation operators used in conventional programming languages and identified occurring error types, subsequently defining a set of mutation operators applicable to block-based programming languages. The proposed mutation operators are organized into two groups which consist of 12 and 16 operators respectively. We also performed a case study to demonstrate that the proposed mutation operators can systematically generate programs containing errors.

프로그래밍 교육은 컴퓨팅 사고력과 문제해결력을 기르는 것을 목표로 하며 이를 위해 블록 프로그래밍 언어 를 활용한 프로그래밍 교육이 진행되고 있다. 프로그래밍 교육 방법 중 디버깅 기반 교육은 작성하는 코드에 대 해 파악하고 스스로 수정하며 논리적 사고력과 문제해결력 향상을 위한 교육 방법으로 사용할 수 있다. 효과적 인 디버깅 기반 교육을 위해서는 오류가 포함된 프로그램을 생성하는 것이 중요하며 뮤테이션 연산자는 적합한 접근법이 될 수 있다. 하지만 뮤테이션 연산자를 적용해 오류가 포함된 뮤턴트를 생성할 때 equivalent mutant 와 같은 문제점들이 발생할 수 있다. 이에 본 연구에서는 이전 연구에서 제안한 뮤테이션 연산자를 바탕으로 오 류를 생성하기 위한 사전/사후 조건을 분석하여 제시하고자 한다. 이를 통해 프로그래밍 교육에서 효과적으로 오류가 포함된 문제를 생성하고 이를 바탕으로 교육에 활용할 수 있을 것으로 기대한다.

Programming education aims to improve computational thinking and problem-solving skills. Block programming language is one of the mainly used method for education. Debugging-based programming education can be used as a method to enhance logical thinking and problem-solving skills by increasing understanding of codes and modifying them. For this, generating mutants which are modified programs from original programs including inserted errors, is a crucial activities. Mutation operators can be a suitable approach for generating mutants. However, there also have a equivalent mutant problem. This paper aims to analyze and propose pre/post-conditions for generating errors based on the mutation operator suggested in previous research. This is expected to enable the effective generation of error-containing problems in programming education and their utilization for teaching purposes.

산업용 시스템과 군용 무기체계에서 사용되는 임베디드 시스템들은 높은 신뢰성을 요구하며, 탑재 소프트웨어의 비중이 높아지면서 소프트웨어 품질확보를 위한 테스트의 중요성이 강화되고 있다. 임베디드 소프트웨어에 대한 테스트는 하드웨어와 소프트웨어의 결합력이 매우 높다는 특성 때문에 통합 테스트를 통해 검증되어야 한다. 기존의 통합 테스트에서는 결함이 발생하더라도 디버깅을 위한 정보를 제공해 줄 수 있는 방법이 고려되지 않아 디버깅을 수행하는 데에 많은 시간과 비용이 소모된다는 문제점이 있었다. 본 논문에서는 임베디드 소프트웨어의 통합 테스트단계에서 발생한 결함에 대해 시험 데이터와 소프트웨어 로그를 통합하여 수집하고 연관 규칙을 이용한 마이닝 기반의 분석 방법을 제공함으로써 임베디드 소프트웨어의 디버깅을 보다 원활하게 할 수 있는 방법을 제안한다. 그리고시험을 통해 제안한 방법이 단일 결함에 대해서 디버깅을 위한 정보의 식별이 가능함을 확인하였다.

The embedded systems used in industry systems and military weapon systems require high reliability, and increasing the proportion of the embedded software increases the importance of testing to ensure software quality. Testing for embedded software should be validated through integration testing because of the tight coupling of hardware and software. There was a problem with the existing integration tests that it was not considered a method to provide information for debugging, even if a defect occurred, so it was time consuming and costly to perform debugging. In this paper, we suggest a method to make debugging of embedded software more seamless by integrating test data and software logs for defects occurred in the integrated testing phase of embedded system, and by providing a mining-based analysis method using associative rules. Through the test, it is confirmed that the proposed method can identify information for debugging with respect to single defect.

Software Debugging is the most time consuming and costly process in the software development process. Many techniques have been proposed to isolate different faults in a program thereby creating separate sets of failing program statements. Debugging in parallel is a technique which proposes distribution of a single faulty program segment into many fault focused program slices to be debugged simultaneously by multiple debuggers. In this paper we propose a new technique called Faulty Slice Distribution (FSD) to make parallel debugging more efficient by measuring the time and labor associated with a slice. Using this measure we then distribute these faulty slices evenly among debuggers. For this we propose an algorithm that estimates an optimized group of faulty slices using as a parameter the priority assigned to each slice as computed by value of their complexity. This helps in the efficient merging of two or more slices for distribution among debuggers so that debugging can be performed in parallel. To validate the effectiveness of this proposed technique we explain the process using example.

프로그램을 디버깅하는 과정은 원래 사고력이 집중적으로 필요한 작업이다. 이 프로세스를 수행하는 프로그래머를 돕기 위해서는 지식기반의 도구를 개발하는 것이 적절하다고 생각된다. 이 논문은 그러한 시스템에 대한 설계를 발표하기 위한 것이다. 주로 정형적 프로그램 기술과 자동 프로그램 이해에 기반을 둔 대부분의 지식기반 디버깅 도구들과는 달리 이 도구는 디버깅 휴리스틱에 기반을 둔 것이다. 이 도구는 지식베이스에 저장된 디버깅 휴리스틱을 이용하여 프로그램을 디버깅하는 프로그래머에게 무엇을 그리고 어느 곳을 살펴봐야 하는지 제안만을 하는 보조 도구이다. 이 논문에서는 여러 가지 유용한 디버깅 휴리스틱이 설명되며 그것들의 디버깅 프로세스에서의 사용법이 기술된다. 그 다음에는 그 지식들을 지식베이스에서 체계화하는 방안과 그 지식을 이용한 프로그램 디버깅 보조도구를 제안하고 토의한다.

The process of program debugging is essentially an intelligence intensive process. It is thought viable to develop a knowledge-based tool to help programmer perform this process. This paper presents the design of such a system. Unlike other knowledge-based debugging tools which are mostly based on formal program specification and automatic program understanding, this tool is based on debugging heuristic. This tool is a debugging assistant which only suggests the programmer in program debugging what and where to examine using the debugging heuristic stored in the knowledge base. In this paper, a umber of useful heuristic debugging knowledge are explained and their usage in debugging process are described. The, a scheme to organize the knowledge in the knowledge base and an intelligent program debugging assistant using the knowledge are proposed and discussed.

The hyper-geometric distribution software reliability growth model (HGDM) usually assumes that all the software faults detected are perfectly removed without introducing new faults. However, since new faults can be introduced during the test-and-debug phase, the perfect debugging assumption should be relaxed. In this context, Hou, Kuo and Chang [7] developed a modified HGDM for imperfect debugging environment, assuming tat the learning factor is constant. In this paper we extend the existing imperfect debugging HGDM for tow respects: introduction of random sensitivity factor and allowance of variable learning factor. Then the statistical characteristics of he suggested model are studied and its applications to two real data sets are demonstrated.

IoT 장치는 인터넷에 연결되어 데이터 수집, 전송 및 처리할 수 있는 장치로, 인공지능과 머신러닝 기술의 발전에 따라 다양한 분야에서 활용되고 있다. 그러나, 이러한 장치들은 서비스 개발 비용이 높으며, 공격자들에게 민감정보가 노출되어 보안 문제가 발생할 수 있다. 특히, IoT 장치의 소프트웨어는 디버깅을 통해 악의적으로 분석될 수 있어 안티디버깅 기법이 필요하다. 하지만, 기존의 안티디버깅 기법은 회피 가능성이 있어, 이를 보완하는 방법으로 디바이스 바인딩 기술을 사용할 수 있다. 디바이스 바인딩 기술은 특정 디바이스에서만 소프트웨어가 동작하도록 하는 방법으로, 고유값을 비교하여 인증한다. 본 논문에서는 LLVM Pass를 이용하여 디바이스 바인딩 기법을 자동으로 삽입하는 방법을 제안하며, 디바이스 DNA를 이용한 고유값으로 서명을 생성하고 검증하는 시스템을 보인다.

IoT devices are connected to the internet and capable of collecting, transmitting, and processing data. With advancements in AI and machine learning technologies, these devices are utilized in various fields. However, they handle sensitive information and have high service development costs, making them vulnerable to security issues, Particularly, the software of IoT devices can be maliciously analyzed through debugging, necessitating anti-debugging techniques. Existing anti-debugging methods can be bypassed, so device binding technology is helpful in defending against such attacks. Device binding ensures that software operates only on specified devices by comparing unique values for authentication. This parer proposes a method for automatically inserting device binding techniques using LLVM Pass, and describes a system that generates unique values using Device DNA and verifies signatures.

교육부는 미래 사회의 변화에 대응하기 위해 디지털 기초 소양 강화를 강조하고 있으며 특히 인공지능의 원리를 이해하고 비판적으로 활용할 수 있는 AI 리터러시와 컴퓨팅 사고력 함양에 주목하고 있다. 최근 프로그래밍 교육에서는 코드의 오류를 찾아내고 수정하는 '디버깅' 과정이 문제 해결력과 논리적 사고를 자극하는 핵심기제로 평가받고 있으며 생성형 AI의 등장은 이러한 디버깅 활동에 새로운 교육적 비계(Scaffolding)를 제공하고 있다. 본 연구의 목적은 생성형 AI를 활용한 디버깅 중심 정보 교육 프로그램을 개발하고 이를 초등학교 현장에 적용하여 학생들의 컴퓨팅 사고력과 AI 리터러시에 미치는 교육적 효과를 분석하는 데 있다. 연구 결과 생성형 AI와의 상호작용을 통한 디버깅 과정이 컴퓨팅 사고력과 인공지능 리터러시에 긍정적인 영향을 미친 것으로 나타났다.

To respond to future societal shifts, the Ministry of Education emphasizes strengthening foundational digital lite racy, specifically focusing on fostering AI literacy and computational thinking to understand and critically utilize A I principles. In recent programming education, the 'debugging' process—identifying and correcting code errors—is recognized as a core mechanism that stimulates problem-solving skills and logical thinking, while the emergence o f generative AI provides a new educational scaffolding for these activities. The purpose of this study is to develo p a generative AI-assisted, debugging-centered education program and apply it to an elementary school setting to analyze its educational effects on students' computational thinking and AI literacy. The findings indicate that the debugging process through interaction with generative AI has a positive impact on both computational thinking an d AI literacy.

The software reliability growth model(SRGM) has been developed in order to estimate such reliability measures as remaining fault number, failure rate and reliability for the developing stage software. Almost of them assumed that the faults detected during testing were evetually removed. Namely, they have studied SRGM based on the assumption that the faults detected during testing were perfectly removed. The fault removing efficiency. however, is imperfect and it is widely known as so in general. It is very difficult to remove detected fault perfectly because the fault detecting is not easy and new error may be introduced during debugging and correcting. Therefore, the fault detecting efficiency may influence the SRGM or cost of developing software. It is a very useful measure for the developing software. much helpful for the developer to evaluate the debugging efficiency, and, moreover, help to additional workloads necessary. Therefore, it is very important to evaluate the effect of imperfect dubugging in point of SRGM and cost, and may influence the optimal release time and operational budget. I extent and study the generally used reliability and cost models to the imperfect debugging range in this paper.

Developing dependable distributed multi-agent programs is not an easy task. Even with extensive testing and debugging, faults cannot be completely removed. However, many distributed multi-agent programs, especially those employed in safety critical environments, should be able to function properly even in the presence of software faults. Monitoring the execution of a distributed multi-agent program, detecting failures, and reacting to these failures at runtime is the appropriate way to tolerate these failures. In this paper, we have designed and implemented a framework for monitoring the execution of distributed multi-agent programs. The proposed framework extends the Java Agent DEvelopment framework (JADE) allowing agent programmers to monitor global states, to detect the occurrence of certain events and to react to these events at runtime. An example of monitoring a distributed multi-agent program has been presented to demonstrate the effectiveness of the proposed framework.

Spectrum-based Fault Localization (SBFL) is a well-known debugging technique that locates fault in program code by utilizing execution profiles (spectra) of pass and fail test cases. Hence, the performance of SBFL depends on the test cases executed and the test results. In the most extreme scenarios, the debugging process may have to be conducted with only one fail test case, one pass test case or no pass test case. These scenarios might occur due to extremely high or extremely low failure rates or when software testers decide to stop running more test cases due to time and resource constraints. However, limited test case execution profiles may reduce the accuracy of SBFL metrics. In view of this, we evaluate the performance of SBFL metrics in these extreme scenarios to identify the best performing SBFL metric for each of these scenarios. From the experiment results, we have further discovered the convergence in performance for SBFL metrics under these extreme scenarios.

Anti-debugging technology refers to various ways of preventing binary files from being analyzed in debuggers or other virtual machine environments. If binary files conceal or modify themself using anti-debugging techniques, analyzing these binary files becomes harder. There are some anti-anti-debugging techniques proposed so far, but malware developers make dynamic analysis difficult using various ways, such as execution time delay, debugger detection techniques and so on. In this paper, we propose a Evading Anti-debugging techniques method that can avoid anti-debugging techniques in binary files, and showed several samples of anti-debugging applications and how to detect and patch anti-debugging techniques in common utilities or malicious code effectively.

Event-driven programs are prone to concurrency bugs due their inherent nature of handling asynchronous events. Asynchronous events introduce logical concurrency into these programs making them hard to be thoroughly tested and debugged. However, understanding the root causes and characteristics of concurrency bugs can ease the debugging process and help developers to avoid introducing them. Unfortunately, previous taxonomies on concurrency bugs do not provide enough knowledge on event-driven concurrency bugs. This paper classifies the event-driven program models into low and high level according to the type of events they handle, categorizes concurrency bug patterns and surveys existing techniques to detect them in event-driven programs.

Ensuring the reliability of structured fork-join parallel programs is difficult because the potential for subtle interactions between concurrent threads can cause concurrency bugs, such as data races, which are hard to detect, reproduce, and eliminate. The visualization for the executions of the programs may offer effective debugging environments with intuitively understanding. Unfortunately, visualization techniques for structured fork-join parallel programs still also difficult to represent and analyze the information of programs executions, because the information for analyzing thread executions and relevant events to data races are increased exponentially in proportion to maximum parallelism of the program. This paper presents a visualization tool that offers overall information for detecting data races by grouping and abstracting thread executions and accesses to shared variables. Moreover, the tool provides an effective approach to debug data races by indicating locations of the defects.

ARINC 653 applications using event synchronization may result in behaviors unexpected by the programmers when concurrency errors, such as race conditions, occur due to their non-deterministic executions. The errors can be debugged by means of previous visualization tools, such as System viewer, provided by ARINC 653 IDE. However, these tools do not consider race conditions, which require the programmers to analyze the process state transition considering event synchronization and to ratiocinate the occurrence of accesses to shared resources from source codes. This paper presents a visualization tool, called ConpathView that intuitively shows the aspect of the process execution with race conditions and the accesses to the shared memories based on the event services in ARINC 653 applications. The ConpathView enables to reduce visual complexity as well as to provide effective understanding of the aspect of the process execution. It provides concrete and practical information for debugging ARINC 653 applications by locating the accesses to the shared resources on the source code.

Most software reliability growth models (SRGMs) take software faults detected that may be removed immediately into consideration. In fact, it costs often considerable resources to identify the root causes of faults detected and to remove them. In additional, detection effort and correction effort have the great effect on software debugging process. The detection effort function and correction effort function are defined as resource expenditures spent on software debugging process, respectively. In this paper, we investigate software debugging process using the queue theory. We propose finite server queuing models with resource and change-point under imperfect debugging environment. A real software failure project is demonstrated the effectiveness of proposed models, and numerical results demonstrate that new models can provide better fit and prediction.

Memory forensics is growing concern. For effective evidence retrieval, it is important to take snapshot timely. With proper modification of guest OS, VMM is powerful tool for timely snapshot. In this paper, we propose an incident-driven memory snapshot for full-virtualized OS using interruptive debugging techniques. We modify debug register handler to invoke snapshot facility of VMM. Software interrupt or signal are generated in register handler. Then, we can take snapshot asynchronously when debug register is changed. On guest OS, we apply three kinds of interruptive debugging techniques: driver supplied callback function, DLL injection. IDT (interruption descriptor table) is modified by driver supplied callback function, which makes it possible to cope with vulnerability exploitation. DLL injection is applied to insert security check function into a resource access function. Proposed system is implemented XEN virtual machine monitor and KVM (Kernel Virtual machine).

디버깅(debugging) 도구는 소프트웨어 개발 과정에서 논리 오류나 버그가 발생되었을 때 프로그램의 내부 상태와 동작 방식을 사용자에게 보여줌으로써 오류를 찾고 수정하는데 도움을 주는 도구이다. 반면에 지적재산권이 포함된 프로그램의 내부 알고리즘 추출이나 권한 상승과 같은 시스템 공격을 위한 취약성 분석에 디버깅 도구가 악용되고 있어 문제가 되고 있다. 이에 대한 대응 기술로 디버깅을 방지할 수 있는 안티 디버깅(anti-debugging) 기술이 적용되고 있으나 이를 우회하는 기술도 지속적으로 발전하고 있다. 본 논문에서는 기존의 우회 기법을 방지할 수 있는 시간 기반 키 생성 방식을 이용한 안티 디버깅 기법을 제안한다. 제안하는 기법은 기존 디버깅을 탐지 후 조건문 방식으로 응답 하는 방식이 아닌 프로그램 실행 시간의 차분 값과 특정 코드 영역의 해시 값으로 키를 생성하고 이를 키 값으로 다음 실행될 코드 영역을 암호화함으로써 우회 공격을 어렵게 하는 방법이다. 또한 단순히 프로그램의 특정 영역의 실행 시간으로 키 값을 유도하는 방식이 아닌 시프트(shift) 연산으로 실행 시간의 범위를 설정할 수 있게 하는 방식을 소개한다. 이는 시스템 하드웨어에 따라 발생할 수 있는 실행 시간의 오차 범위를 설정할 수 있게 함으로써 기법을 유연하게 적용할 수 있게 한다.

Debuggers are the tools which are helping the user to find out and correct the logic errors or bug by showing internal state and running mechanism while developing software. But it is also misused as vulnerability analysis for system attacks like extracting internal algorithm of program or privilege elevation. For this reason, anti-debugging techniques are applied to prevent debugging, but the techniques to bypass anti-debugging are keep developing. In this paper, we propose anti-debugging techniques by using time-based key generation method to prevent previous bypass techniques. The proposed techniques are difficult to bypass attack generate key by using hash value instead of not using previous method which is detecting previous debugging and respond in conditional method. We also introduce scheme that setting scope of the execution time by shift operation instead of simply induce the value of the key by specific area of the program’s execution time. It can set a range of run-time errors can be occurred by system hardware so scheme can be applied flexibly in the various environments.