Demo

Analysis of the source code of video games is not an integrated part of the formal analysis. Rather, few scholars have investigated how an analysis of the source code can inform a hermeneutic reading of the game. In this paper I will present a reading of the source code of Passage (Rohrer, 2007), argue for why a traditional focus on authorial intention is unnecessary when investigating the symbolism and metaphors of a game, and illustrate how source code analysis can inform the formal analysis of the executed game. Finally, I shall discuss how the source code relates to the game as a ‘work’, and how it can be used for studies of symbolism and metaphors. Thus, I will conclude that it is indeed a valuable method for game studies, although further studies should expand on the textual relation between executed game and source code.

Static code analysis is a very important stage in the development and implementation of software, and it needs to be used to obtain a better code. The most complicated in static analysis is the analysis of source code, and further analysis. Analysis of the source code can be done multiple times and expand the set of necessary grammar. The main goal was and remains to provide a solution to reduce the time needed for a global reassessment of static analysis at code level after a change.The main problem when using static code analysis is to build an abstract semantic graph, because each software solution is provided with a separate data warehouse. The proposed solution proposes to use as a database repository using graphs. Thus, the storage mechanisms of the created abstract semantic graph have been simplified, which in turn, in addition to increasing the clarity of the information we store, provides convenient ways to further work with the stored information.The developed solution can transform a rather large source repository into a graphic representation and maintain it later. It is found that the approach is suitable for carrying out code compliance checks and for performing static analysis tests on a graphic representation. This approach also uses advanced file-level detailing, accelerating static analysis. Based on my measurements, the frameworks are fast enough to help their users quickly change the repository of codes.This article confirms the thesis about the possibility of storing an abstract semantic graph in a graph database, and after refinement, if it contains sufficient transformations and requests for language processing, can become a complete transport for communication between various static analysis tools that usually perform one of two the functions of verification either for quality or for vulnerability, thereby making a unified creation of an abstract semantic graph.As an improvement it is necessary to consider the possibility of incremental analysis – the analysis of changes in the code, in order to minimize resource costs for a rather resource intensive operation of the structure of the abstract semantic graph.Manuscript received 09.06.2020

Language analysis of scientific documents and analysis of source code have been done independently in the past. This work presents a network architecture and a self-supervised training approach to find alignments between published computer science research papers and their corresponding public source code by learning a representation of encodings from transformers, from which source code can be enriched with helpful information. We present our ideas, findings and plans for upcoming research.

Inspired by the great success of Deep Neural Networks (DNNs) in natural language processing (NLP), DNNs have been increasingly applied in source code analysis and attracted significant attention from the software engineering community. Due to its data-driven nature, a DNN model requires massive and high-quality labeled training data to achieve expert-level performance. Collecting such data is often not hard, but the labeling process is notoriously laborious. The task of DNN-based code analysis even worsens the situation because source code labeling also demands sophisticated expertise. Data augmentation has been a popular approach to supplement training data in domains such as computer vision and NLP. However, existing data augmentation approaches in code analysis adopt simple methods, such as data transformation and adversarial example generation, thus bringing limited performance superiority. In this paper, we propose a data augmentation approach MixCode that aims to effectively supplement valid training data, inspired by the recent advance named Mixup in computer vision. Specifically, we first utilize multiple code refactoring methods to generate transformed code that holds consistent labels with the original data. Then, we adapt the Mixup technique to mix the original code with the transformed code to augment the training data. We evaluate MixCode on two programming languages (Java and Python), two code tasks (problem classification and bug detection), four benchmark datasets (JAVA250, Python800, CodRep1, and Refactory), and seven model architectures (including two pretrained models CodeBERT and GraphCodeBERT). Experimental results demonstrate that MixCode outperforms the baseline data augmentation approach by up to 6.24% in accuracy and 26.06% in robustness.

EDSA (expert data flow and static analysis tool) which uses static analysis of source code to help gain an understanding of existing code, is described. This may be for the purpose of tracking down a bug or to determine in advance whether an intended change will have any undesirable side effects. In either case, the phase of the development life cycle that is most likely to benefit from a tool like EDSA is the maintenance phase. EDSA provides three kinds of facilities. It helps to browse through code, following either the control flow or data flow, rather than the order in which the code happens to be written. It displays code with unimportant source lines eluded, so that the user can get a more global view of the program. Finally, it provides search management to make it easier to examine all possibilities when browsing. The mechanism used to create and display various views of programs is described and the approach to the user interface is discussed. The state of the current implementation is described. >

This paper is a continuation of our previous work on solving source code authorship identification problems. The analysis of heterogeneous source code is a relevant issue for copyright protection in commercial software development. This is related to the specificity of development processes and the usage of collaborative development tools (version control systems). As a result, there are source codes written according to different programming standards by a team of programmers with different skill levels. Another application field is information security—in particular, identifying the author of computer viruses. We apply our technique based on a hybrid of Inception-v1 and Bidirectional Gated Recurrent Units architectures on heterogeneous source codes and consider the most common commercial development complex cases that negatively affect the authorship identification process. The paper is devoted to the possibilities and limitations of the author’s technique in various complex cases. For situations where a programmer was proficient in two programming languages, the average accuracy was 87%; for proficiency in three or more—76%. For the artificially generated source code case, the average accuracy was 81.5%. Finally, the average accuracy for source codes generated from commits was 84%. The comparison with state-of-the-art approaches showed that the proposed method has no full-functionality analogs covering actual practical cases.

In computer science education, the analysis of source code with errors is of interest as programming errors may give a hint to misconceptions. The analysis of misconceptions can help teachers to improve their exercises and lessons.The semantic analysis of texts or video sequences could lead to different, subjective interpretation. This problem also effects source code errors, which could contain semantic errors.In different projects, we were confronted with a lot of incorrect source codes, which were written by students of universities and secondary schools. A first analysis of these errors led to a categorization of errors regarding missing competencies.To avoid mainly subjective interpretation of source code errors a standardized method for categorizing errors, which could also be applied by a practitioner, has to be developed and justified. Categorizing texts or source code errors is a matter of semantics, because text or code elements have to be interpreted. Thus, a qualitative content analysis is most suitable. In this paper we explain the difference between errors and misconceptions and present our adaption of the qualitative content analysis of Mayring to source code errors.

K-scope is a source code analysis tool with a graphical user interface for the performance tuning of Fortran programs. With K-scope, developers are able to visually understand the structures of their Fortran programs and estimate their performance. However, the original version of K-scope has two problems. First, it lacks the ability to integrate the results of source code analysis with performance profiling data. Second, it requires developers to install XcalableMP because K-scope utilizes the front-end of the XcalableMP compiler. However it is difficult to set up the XcalableMP environment because this requires installing and configuring several libraries and applications. A binary package of XcalableMP is only available for major Linux distributions, and developers thus have a hard time installing XcalableMP on other environments, e.g., Windows. In order to address these two problems, we extend K-scope with two mechanisms. The first visualizes performance profiling data and the second offloads the parsing of Fortran programs to a remote server. More specifically, the visualization mechanism enables users to readily identify performance bottlenecks in their programs by mapping performance profiling data to each line of the source code. With the offloading mechanism, developers no longer need to install XcalableMP. Instead, they can connect K-scope to a remote server on which XcalableMP is installed, and which generates the intermediate code used for analysis. For this purpose, we develop a tool named SSHconnect. To verify the effectiveness of our extended K-scope, we analyze the Nonhydrostatic Icosahedral Atmospheric Model (NICAM) code, an application for global climate simulation that consists of about 300,000 lines of Fortran code. We found that K-scope successfully identified performance bottlenecks in the NICAM code and translated the source code for several applications using its remote parsing mechanism.

Security has been always treated as an add-on feature in the software development lifecycle, and addressed by security professionals using firewalls, proxies, intrusion prevention systems, antivirus and platform security. Software is at the root of all common computer security problems, and hence hackers don't create security holes, but rather exploit them. Security holes in software applications are the result of bad design and implementation of software systems and applications. To address this problem, several initiatives for integrating security in the software development lifecycle have been proposed, along with tools to support a security-centric software development lifecycle. This paper introduces a framework for evaluating security static analysis tools such as source code analyzers, and offers evaluation of non-commercial static analysis tools such as Yasca, CAT.NET, and FindBugs. In order to evaluate the effectiveness of such tools, common software weaknesses are defined based on CWE/SANS Top 25, OWASP Top Ten and NIST source code weaknesses. The evaluation methodology is based on the NIST Software Assurance Metrics And Tool Evaluation (SAMATE). Results show that security static analysis tools are, to some extent, effective in detecting security holes in source code; source code analyzers are able to detect more weaknesses than bytecode and binary code scanners; and while tools can assist the development team in security code review activities, they are not enough to uncover all common weaknesses in software. The new test cases developed for this research have been contributed to the NIST Software Assurance Reference Dataset (samate.nist.gov/SARD).

Whether the developed software system completed all functions in the software design specification and consistent with the design algorithm is an important work in software testing. Analysis of the source code artificial and verify whether the software system is to meet the requirements of the design specification is laborious job. Testers need to have rich experience in programming and strong ability of algorithm analysis. This paper proposes a method to verify consistency of software implementation and design based on function call path. The method can be summarized as analyze the calling relationship of functions from design specifications and source code, extraction function calling path, generation function cluster model. In documents aspect, the function calling relationship can be got by manual analysis of the design specification, then the designed function cluster model can be generated automatically. We can get function calling relationship, function features by static analysis of source code and the specific implementations of function with those features. Finally, compare the two function cluster model to verify that the consistency of software implementation and design. The experimental results showed that this method can obtain the system function structure and algorithm features accurately, make effective judgment of the consistency of the design specification and the software implementation, provides a new way to verify the consistency of software implementation and design.

<bold>background</bold>Uncertainty quantification and nuclear data adjustment of reactor core physical parameters can improve the calculation accuracy, thus improving the safety of reactor core design parameters. In recent years, domestic and foreign research institutions have developed a series of programs to analyze the sensitivity and uncertainty of core physical parameters, and use various methods to adjust the nuclear data to reduce the uncertainty of the calculation results.<bold>Purpose</bold>This study aims to conduct uncertainty quantification and nuclear data adjustment of the core physical parameters of the small lead-bismuth cooled fast reactor (SVBR), which holds broad prospects in the fourth generation nuclear energy technology.<bold>Methods</bold>Firstly, the SVBR was simplified, and the sensitivity analysis of critical reactivity, control rod value and power distribution were carried out by using NECP-SARAX and UNICORN programs. Then,138 groups of critical experimental devices were selected from the International Criticality Safety Benchmark Evaluation Project (ICSBEP) for uncertainty quantification. A similarity analysis was conducted between these 138 critical experiments and the SVBR. Finally, nuclear data adjustment was performed using the critical experiment devices with high similarity coefficients, with the isotopes ²³⁵U and ²³⁸U involved in the adjustment. The adjusted database was then applied to the back-substitution calculations.<bold>Results</bold>The selected critical experiment has a certain similarity with the SVBR. By using the adjusted nuclear data for back substitution calculations, the calculation uncertainty of critical reactivity is reduced from 2.59% to 0.496%, which improves the calculation accuracy.<bold>Conclusions</bold>It is verified in this study by back-substitution calculation that the uncertainty of the physical parameter calculation results after nuclear data adjustment has been significantly reduced, while the adjustments to the nuclear cross-sections are all smaller than the measurement errors. This indicates that the nuclear data adjustment can provide more reliable calculation results for the design of the lead-bismuth fast reactor and offers valuable reference for its design.

Source code quality is undoubtedly very important, yet usually forgotten aspect of software development process. This study shows different approaches to analysis of student codes, mainly in Java. By comparing different widely-used tools and our solution, we are able to get precise results from such an analysis, and thus to improve the code quality. The analysis results can also be used to determine knowledge and skills of novice programmers (students). Analysis of source codes may be as simple as counting the occurrences of language constructs or as complex as design pattern detection. Different approaches and solutions, i.e. measurements of language construct occurrences, copy-pasted code and design pattern detection, or source code quality, are discussed and subjected to evaluation by being executing on source codes of students as novice programmers.

Now a days, risk management plays very important role in Information systems, currently there are various risk assessment techniques. When system is analysing the source code, automatically some disputes may arise which depends on various reasons. These disputes may arise some of the risks in information system which may leads to loss of some data. To avoid that, in this paper we are implementing a framework for source code analysis which is used for brief assessment of risk, which includes guidance to risk minimization. In this framework source based risk assessment is done through the source code analysis. In order to assess risk that arose from the source code, first we need to calculate complexity of a source code in Information System. Finally the complexity which is the result of this framework will indicates the risk intensity of the source code.

In this paper we discuss a new application of Semantic Web and Artificial Intelligence in software analysis research. We show on a concrete example - clone detection for object-oriented source code that transitivity closure computation can provide added value to the clone detection community. Our novel approach models the domain of discourse knowledge as a mixture of source code patterns and inheritance trees represented as Directed Acyclic Graphs. Our approach promotes the use of Semantic Web and inference engines in source code analysis. More specifically we take advantage of the Semantic Web and its support for knowledge modeling and transitive closure computation to detect semantic source code clones not detected by traditional detection tools.

Program transformations have been advocated as a method for accomplishing reverse engineering. The hypothesis is that the original source code can be progressively transformed into alternative forms, but with the same semantics. At the end of the process, an equivalent program is acquired, but one which is much easier to understand and more maintainable. We have been undertaking an extensive programme of research over twelve years into the design and development of transformations for the support of software maintenance. The paper very briefly explains the theory, practice and tool support for transformational systems, but does not present new theoretical results. The main results are on an analysis of the strengths and weaknesses of the approach, based on experience with case studies and industrial applications. The evaluation framework used (called DERE) is that presented in Bennett and Munro (1998). It is hoped that the results will be of benefit to industry, who might be considering using the technology; and to other researchers, interested in addressing the open problems. The overall conclusion is that transformations can help in the bottom-up analysis and manipulation of source code at approximately the 3GL level, and have proved successful in code migration, but need to be complemented by other top-down techniques to be useful at higher levels of abstraction or in more ambitious re-engineering projects.