Teachers deal with plagiarism on a regular basis, so they try to prevent and detect plagiarism, a task that is complicated by the large size of some classes. Students who cheat often try to hide their plagiarism (obfuscate), and many different similarity detection engines (often called plagiarism detection tools) have been built to help teachers. This article focuses only on plagiarism detection and presents a detailed systematic review of the field of source-code plagiarism detection in academia. This review gives an overview of definitions of plagiarism, plagiarism detection tools, comparison metrics, obfuscation methods, datasets used for comparison, and algorithm types. Perspectives on the meaning of source-code plagiarism detection in academia are presented, together with categorisations of the available detection tools and analyses of their effectiveness. While writing the review, some interesting insights have been found about metrics and datasets for quantitative tool comparison and categorisation of detection algorithms. Also, existing obfuscation methods classifications have been expanded together with a new definition of “source-code plagiarism detection in academia.”

Grading student programming assignments is not an easy task. This task is even more challenging when talking about complex programming assignments at university graduate level. By complex assignments, we mean assignments where students have to program a complete application from scratch. For example, building a complete web application with a client and server side, whereby the application uses multiple threads that gather data from some external service (like the REST service, IoT sensors, etc.), processes these data and store them in some storage (e.g., a database), implements a custom protocol over a socket or something similar, implements their own REST/SOAP/GraphQL service, then sends or receives JMS/MQTT/WebSocket messages, etc. Such assignments give students an inside view of building real Internet applications. On the other hand, assignments like these take a long time to be tested and graded manually, e.g., up to 1 h per student. To speed up the assessment process, there are different automation possibilities that can check for the correctness of some application parts without endangering the grading quality. In this study, different possibilities of automation are described that have been improved over several years. This process takes advantage of unit testing, bash scripting, and other methods. The main goal of this study is to define an assessment process that can be used to grade complex programming assignments, with concrete examples of what and how to automate. This process involves assignment preparation for automation, plagiarism (i.e., better said similarity) detection, performing an automatic check of the correctness of each programming assignment, conducting an analysis of the obtained data, the awarding of points (grading) for each programming assignment, and other such activities. We also discuss what the downsides of automation are and why it is not possible to completely automate the grading process.

Component-based software engineering and generative programming are common approaches in software engineering. Each approach has some benefits and domain of usage. Component-based development is used to build autonomous components that can be further combined in different ways, while generative programming is more suitable when building systems that have different variants. Before a variable component based system can be build, it needs to be modeled. In this article, a new common metamodel that aims to enable modeling a system which combines both component-based development and generative programming is introduced. The introduced metamodel proposed in this paper combines the component diagram that is used to model systems in component-based development and the feature diagram that is employed in modeling systems in generative programming. The combined metamodel enables modeling of variable systems using components.

Phaser and WebAssembly are both excellent options for web game development, each offering unique advantages. This paper specifically focuses on procedural maze generation and compares the performance of WebAssembly (using C++ and SDL) and Phaser across various levels of complexity, defined by maze dimensions. The study aims to assess execution time efficiency and identify performance trends across different scenarios. Using the Depth-First Search (DFS) algorithm, we conducted multiple test runs at increasing maze sizes to evaluate the scalability and computational efficiency of both technologies. The results indicate that WebAssembly enables near-native execution of C++ code in web browsers, leading to significant performance advantages in larger maze dimensions. Specifically, WebAssembly exhibited a more consistent, linear increase in execution time, making it a strong candidate for handling computationally intensive tasks. In contrast, Phaser performed slightly better in smaller maze dimensions but demonstrated greater variability and steeper increases in execution time as complexity grew. The findings suggest that while Phaser is an accessible and user-friendly framework for game development, its performance may not scale as efficiently as WebAssembly when dealing with complex procedural generation tasks. However, the study also acknowledges limitations, such as fewer test runs for larger mazes and potential differences in implementation efficiency between the two technologies. Overall, WebAssembly appears better suited for tasks requiring high-performance execution, whereas Phaser remains a viable option for less demanding applications where ease of use and rapid development are prioritized.