Search

Due to the diversity and unpredictability of changes in malicious code, studying the traceability of variant families remains challenging. In this paper, we propose a GAN-EfficientNetV2-based method for tracing families of malicious code variants. This method leverages the similarity in layouts and textures between images of malicious code variants from the same source and their original family of malicious code images. The method includes a lightweight classifier and a simulator. The classifier utilizes the enhanced EfficientNetV2 to categorize malicious code images and can be easily deployed on mobile, embedded, and other devices. The simulator utilizes an enhanced generative adversarial network to simulate different variants of malicious code and generates datasets to validate the model's performance. This process helps identify model vulnerabilities and security risks, facilitating model enhancement and development. The classifier achieves 98.61% and 97.59% accuracy on the MMCC dataset and Malevis dataset, respectively. The simulator's generated image of malicious code variants has an FID value of 155.44 and an IS value of 1.72 ± 0.42. The classifier's accuracy for tracing the family of malicious code variants is as high as 90.29%, surpassing that of mainstream neural network models. This meets the current demand for high generalization and anti-obfuscation abilities in malicious code classification models due to the rapid evolution of malicious code. [ABSTRACT FROM AUTHOR]

The purpose of software defect prediction is to identify defect-prone code modules to assist software quality assurance teams with the appropriate allocation of resources and labor. In previous software defect prediction studies, transfer learning was effective in solving the problem of inconsistent project data distribution. However, target projects often lack sufficient data, which affects the performance of the transfer learning model. In addition, the presence of uncorrelated features between projects can decrease the prediction accuracy of the transfer learning model. To address these problems, this article propose a software defect prediction method based on stable learning (SDP-SL) that combines code visualization techniques and residual networks. This method first transforms code files into code images using code visualization techniques and then constructs a defect prediction model based on these code images.During the model training process, target project data are not required as prior knowledge. Following the principles of stable learning, this paper dynamically adjusted the weights of source project samples to eliminate dependencies between features, thereby capturing the "invariance mechanism" within the data. This approach explores the genuine relationship between code defect features and labels, thereby enhancing defect prediction performance. To evaluate the performance of SDP-SL, this article conducted comparative experiments on 10 open-source projects in the PROMISE dataset. The experimental results demonstrated that in terms of the F-measure, the proposed SDP-SL method outperformed other within-project defect prediction methods by 2.11%--44.03%. In cross-project defect prediction, the SDP-SL method provided an improvement of 5.89%--25.46% in prediction performance compared to other cross-project defect prediction methods. Therefore, SDP-SL can effectively enhance within- and cross-project defect predictions. [ABSTRACT FROM AUTHOR]

In the field of software engineering, large and complex code bases may lead to some burden of understanding their structure and meaning for developers. To reduce the burden on developers, we consider a code base visualization method to visually express the meaning of code bases. Inspired by remote sensing imagery, we employ graphical representations to illustrate the semantic connections within Java code bases, aiming to help developers understand its meaning and logic. This approach is segmented into three distinct levels of analysis. First, at the project-level, we visualize Java projects by portraying each file as an element within a code forest, offering a broad overview of the project's structure. This macro-view perspective aids in swiftly grasping the project's layout and hierarchy. Second, at the file-level, we concentrate on individual files, using visualization techniques to highlight their unique attributes and complexities. This perspective enables a deeper understanding of each file's structure and its role within the larger project. Finally, at the component-level, our focus shifts to the detailed analysis of Java methods and classes. We examine these components for complexity and other specific characteristics, providing insights that are crucial for the optimization of code and the enhancement of software quality. By integrating remote sensing technology, our method offers software engineers deeper insights into code quality, significantly enhancing the software development lifecycle and its outcomes. [ABSTRACT FROM AUTHOR]

Malware detection has always been a hot topic in the cyber security field. With continuous research over the years, many research methods and detection tools based on code visualization have been proposed and achieved good results. However, in the process of code visualization, the existing methods have some issues such as feature scarcity, feature loss and excessive dependence on manual analysis. To address these issues, we propose in this paper a code visualization method with multi-channel image size adaptation (MC-ISA) that can detect large-scale samples more quickly without manual reverse analysis. Experimental results demonstrate that MC-ISA achieves both higher accuracy and F1-score than the existing B2M algorithm after introducing three mechanisms including image size adaptive, color enhancement and multi-channel enhancement. [ABSTRACT FROM AUTHOR]

Malicious code attacks have severely hindered the current development of the Internet technologies. Once the devices are infected with virus, the damages to companies and users are unpredictable. Although researchers have developed malware detection methods, the analysis result still cannot achieve the desired accuracy due to complicated malicious code families and fast‐growing variants. In this paper, to solve this problem, we combine Convolutional Neural Networks (CNNs) with Generative Adversarial Networks (GANs) to design an efficient and accurate malware detection method. First, we implement a code visualization method and utilize GAN to generate more samples of malicious code variants in the role of data augmentation. Then, the lightweight AlexNet originated from CNN to classify malware families. Finally, simulation experiments are conducted to evaluate that our CNN plus GAN model can achieve a higher classification accuracy (i.e., 97.78%) compared with some related work. [ABSTRACT FROM AUTHOR]

Providing students feedback on their exercise solutions is a crucial element of computer programming education. Such feedback can be generated automatically and can take various forms. This paper introduces and proposes the use of visual profiles of code solutions as a form of automatically generated feedback to programming students. The visual profiles are based on the frequency of code elements belonging to six distinct classes. The core idea is to visually compare a profile of a student-submitted solution code to the range of profiles of accepted solutions (including both reference solutions provided by instructors and solutions submitted by students who successfully passed the same exercise earlier). The advantages of the proposed approach are demonstrated on a number of examples based on real-world data. [ABSTRACT FROM AUTHOR]

Providing students feedback on their exercise solutions is a crucial element of computer programming education. Such feedback can be generated automatically and can take various forms. This paper introduces and proposes the use of visual profiles of code solutions as a form of automatically generated feedback to programming students. The visual profiles are based on the frequency of code elements belonging to six distinct classes. The core idea is to visually compare a profile of a student-submitted solution code to the range of profiles of accepted solutions (including both reference solutions provided by instructors and solutions submitted by students who successfully passed the same exercise earlier). The advantages of the proposed approach are demonstrated on a number of examples based on real-world data.

In an intelligent smart city like Sejong city in Korea, automatic and smart software is absolutely necessary for autonomous traffic and vehicles control systems. Therefore, these systems need to have an accurate and timely performance; otherwise, safety issues may arise. To resolve this, we propose our code visualization approach to adapt an object-oriented smart traffic control simulator, which analyzes Java code's complexity and identifies bad codes against performance. To achieve an accurate performance, we must repeatedly perform refactoring until attaining a range of system-defined performances through effective code visualization. As a result, we enhance the code complexity of the cyber-physical system-based software to achieve the exact performance. With this approach, we expect to obtain an accurate performance and complexity improvement of the object-oriented traffic control simulator without significant power consumption. [ABSTRACT FROM AUTHOR]

In the Fourth Industrial Revolution environment, plenty of automatic and smart software in diverse fields will come out, such as virtual reality/augmented reality (VR/AR), autonomous robots and vehicles, smart factoring, and so on. In Korea, especially, one important issue is the cyber–physical system (CPS), used for monitoring and controlling the smart and automatic system in a smart city. This kind of system, therefore, needs to have good performance; otherwise, it may not respond in time. To solve this, we propose a code visualization approach to reduce code complexity based on a static analysis, which identifies bad codes against performance. To ensure better performance, we make our queries identify performance degradation factors, store statically analyzed data into database (DB) tables, and visualize bad operation patterns. For performance improvement, we can refactor with them. As a result, we reduce the code complexity of CPS-based software to obtain good performance. With this approach, we expect to have better performance and a reduction in the complexity of CPS software without even power consumption. [ABSTRACT FROM AUTHOR]

The Linux kernel has grown to 20 million lines of code, which have been contributed by almost 14,000 programmers. The complexity of the Linux kernel challenges the kernel maintenance and makes comprehending the kernel more difficult for developers learning the kernel. Automated tool support is crucial for comprehending such a large-scale program involving a high volume of code. In this article, we present KernelGraph, which enhances understanding of the Linux kernel by providing a visual representation of kernel internals. KernelGraph resembles online map systems and facilitates kernel code navigation in an intuitive and interactive way. We describe the key techniques used in KernelGraph to process the vast amount of information in the kernel codebase quickly. We also implemented two applications built atop KernelGraph to enhance kernel comprehension. KernelGraph was presented to 30 participants, who were asked several questions about their kernel comprehension in a controlled study. Our experimental results show that, compared with other source code comprehension tools, KernelGraph improves kernel comprehension by enabling people to visually browse the kernel code and by providing an effective means for exploring the kernel structure. The ability to switch seamlessly between high-level views and source code significantly reduces the gap between source code and high-level mental representation. KernelGraph can be easily extended to support visualizations of other large-scale codebases. [ABSTRACT FROM AUTHOR]

In an intelligent smart city like Sejong city in Korea, automatic and smart software is absolutely necessary for autonomous traffic and vehicles control systems. Therefore, these systems need to have an accurate and timely performance; otherwise, safety issues may arise. To resolve this, we propose our code visualization approach to adapt an object-oriented smart traffic control simulator, which analyzes Java code’s complexity and identifies bad codes against performance. To achieve an accurate performance, we must repeatedly perform refactoring until attaining a range of system-defined performances through effective code visualization. As a result, we enhance the code complexity of the cyber-physical system-based software to achieve the exact performance. With this approach, we expect to obtain an accurate performance and complexity improvement of the object-oriented traffic control simulator without significant power consumption.

In the Fourth Industrial Revolution environment, plenty of automatic and smart software in diverse fields will come out, such as virtual reality/augmented reality (VR/AR), autonomous robots and vehicles, smart factoring, and so on. In Korea, especially, one important issue is the cyber−physical system (CPS), used for monitoring and controlling the smart and automatic system in a smart city. This kind of system, therefore, needs to have good performance; otherwise, it may not respond in time. To solve this, we propose a code visualization approach to reduce code complexity based on a static analysis, which identifies bad codes against performance. To ensure better performance, we make our queries identify performance degradation factors, store statically analyzed data into database (DB) tables, and visualize bad operation patterns. For performance improvement, we can refactor with them. As a result, we reduce the code complexity of CPS-based software to obtain good performance. With this approach, we expect to have better performance and a reduction in the complexity of CPS software without even power consumption.

We present a toolset for maintaining C++ programs which are written using a hybrid object-orientated programming style (i.e., one that combines procedural and object-orientated techniques). The toolset maintains a database with control and data flow information found In source code and It is based on a compact hybrid data model for C++ programs. This information is visualized and manipulated both textually and graphically. A maintenance exercise performed on a C++ program using the toolset demonstrates that its code visualization features, abstraction mechanisms and graph management techniques constitute a promising platform towards the comprehension and maintenance of complex hybrid C++ code. [ABSTRACT FROM AUTHOR]