Algorithms and data structures are principal parts of computer science education. For many students, however, it is not easy to master them due to their diversity and inherent complexity. The application of algorithm visualizations is a widely adopted approach, which can help to mitigate this difficulty. Within this work, we aim to improve the efficiency of the learning process in the field of algorithms and data structures. The main directions we use in this work to reach this goal are the introduction of comparative algorithm visualization and the implementation of the visualization tool based on contemporary standards. We analyze and compare several of the available solutions for algorithms and data structure visualization and evaluate them according to the provided functionalities. Further, we define a list of requirements, including the capability to compare selected algorithms visually. The practical outcome of this work is a web application that allows us to visualize and compare different algorithms and data structures in terms of their operation and efficiency. At the end of the paper, the proposed solution is evaluated in several ways.

Within this work we analyze and compare ten Petri net supporting tools for system modeling and analysis. A short summary of several available overviews of Petri net tools is performed before the tools analysis itself to evaluate the current state in this field. Principal parts of the paper are focused on analysis and evaluation of the selected tools. We provide detailed and practical description of selection of up to date tools, their evaluation based on various criteria, and recommendations for several use cases.

In this work, we have prepared and analyzed three case studies comparing CPU and GPGPU calculations. After briefly introducing the topic of parallel programming by means of contemporary CPU and GPGPU technologies, we provide an overview of selected existing works closely related to the topic of the paper. For each of the case studies, a set of programs has been implemented using the following technologies: pure CPU, CPU SIMD, CPU multi-threaded, CPU multi-threaded with SIMD instructions, and GPU - Cuda. We also illustrate the basic idea of the operation of selected algorithms using code snippets. Subsequently, the particular implementations are compared, and obtained results are evaluated and discussed.

The paper is focused on examination of properties of transformations of Petri nets and process algebra specifications.After a brief introduction to formal methods and the transformations used, we provide descriptions of several experiments regarding Petri nets and process algebra transformations we accomplished using our transformation tools.The motivations behind this research are to practically evaluate the benefits we would gain by transformation in the field of analysis of resulting specification as well as to verify the accuracy and correctness of the tools by performing the transformations in both directions.By evaluating the experiments we were able to better perceive the actual state of the tools in practical level, the role of transformations in the field of formal methods integration and to collect some suggestions which may stimulate our further research in the given field.

This work is dedicated to the design, implementation and evaluation of a new algorithm visualization system. The currently available systems and libraries are briefly compared with each other based on the visualizations and functionalities they provide. Since the analyzed tools didn't meet all of the given requirements, we decided that the development of a new system for algorithm and data structure visualizations would be beneficial for use in teaching the subject Data Structures and Algorithms. The new system was designed to be easily usable, extensible, available and to cover the basic functionalities available in similar systems and other useful features. The proposed system provides three types of visualizations: predefined visualizations, to explain how each data structure and algorithm works; interactive visualizations, to let the user interact with the visualization directly; and interactive exercises, to let the users test their knowledge. These three types of visualizations cover the whole learning process, provide theoretical and practical knowledge, and also a way to test their knowledge. The system is implemented in the form of a web application and, for the visualizations, the JSAV library is used. The system was also evaluated by the users via a survey and several improvements were implemented in the system based on the feedback provided by the users.

This paper is dedicated to the comparison of different libraries of algorithms and data structures for the Java language. Within the paper currently available and relevant libraries are analyzed and compared. Selected libraries are compared in terms of provided implementations of the particular data structures and algorithms, but also based on the performance of these implementations. Then a summary of the results and recommendations regarding the practical uses of each library are provided. Performance is measured using the Java Microbenchmark Harness. According to the results of this paper, implementations in Java Collections Framework are suitable for most use cases, when more complex data structures are not needed. When more specific data structures or algorithms are needed, that are not covered in Java Collections, GUAVA is a good alternative. For graph-like data structures the use of libraries JUNG and JGraphT is recommended.

Abstract The paper presents some of our recent results in the field of computer emulation for supporting and enhancing the educational processes. The ATmega 328P micro-controller emulator has been developed as a set of emuStudio emulation platform extension modules (plug-ins). The platform is used at the Department of Computers and Informatics as a studying and teaching support tool. Within the Assembler course, currently, the Intel 8080 architecture and language is briefly described as a preliminary preparation material for the study of Intel x86 architecture, and the Intel 8080 emuStudio emulator module is used here. The aim of this work is to explore the possibility to enrich the course by introducing a more up-to-date and relevant technology and the ATmega is the heart of Arduino – a popular hardware and software prototyping platform. We consider the options to make the process of studying the assembly language principles more attractive for students and using the ATmega AVR architecture, which is broadly deployed in embedded systems, seems to be one of them.

The paper presents the results of our research in the field of applying algorithm visualizations within Data structures and algorithms subject. We accomplished several experiments relating the ability of students to solve simple problems in a pure visual way in one case and by programming the solution using a particular programming language in another one. The experiments are described and the results are analyzed within the paper. In accordance with our previous informal experiences and the results of the analysis we found there can be some part of students, which will be able to apply an algorithm to concrete problem in a visual way, but will not be able to express it clearly enough and implement it in given programming language. As an attempt to cope with the situation, we propose a new teaching approach, together with a prototype of study supporting system, based on the idea that students would participate on creating simple visualizations, not just using them. The purpose of such approach is to help students to develop both types of skills - understanding the algorithms and implementing them as well, by increasing the engagement level and supporting the active learning.

The paper deals with algebraic semantics for Petri nets, based on process algebra ACP. The semantics is defined by assigning a special variable to every place of given Petri net, expressing the process initiated in the place. Algebraic semantics of the Petri net is then defined as a parallel composition of all the variables, where corresponding places hold tokens within the initial marking. Resulting algebraic specification preserves operational behavior of the original net-based specification.

The paper presents the results of our research in the field of combining process algebra and Petri nets. To provide better support for design and analysis of larger-scale systems by means of abstraction mechanism, the method itself and the tools allowing its practical application have been enhanced significantly. The theoretical aspects and implementation of enhancements are discussed in detail. Careful testing, along with the process of implementing the new functionality into one of the involved tools, helped us to disclose its certain hidden imperfections, which are subsequently addressed.

Visualizations of algorithms and data structures can be effectively used for supporting the teaching process. However, such visualization must be comprehensive for students and still semantically correct. Algomaster visualization platform offers effective visualization and simple extensibility. In this paper we describe major platform extensions we have implemented, including support for visualization of complex algorithms, features for real-time student testing and the tool for simplified development of new Algomaster plugins. These complex algorithms comprise visualization of operations with self-balancing trees and hashing algorithm. To enable the real-time student testing we have created a database and a separate tool for its management.

Computer system security is the fastest developing segment in information technology. The conventional approach to system security is mostly aimed at protecting the system, while current trends are focusing on more aggressive forms of protection against potential attackers and intruders. One of the forms of protection is also the application of advanced technology based on the principle of baits - honeypots. Honeypots are specialized devices aimed at slowing down or diverting the attention of attackers from the critical system resources to allow future examination of the methods and tools used by the attackers. Currently, most honeypots are being configured and managed statically. This paper deals with the design of a sophisticated hybrid honeypot and its properties having in mind enhancing computer system security. The architecture of a sophisticated hybrid honeypot is represented by a single device capable of adapting to a constantly changing environment by using active and passive scanning techniques, which mitigate the disadvantages of low-interaction and high-interaction honeypots. The low-interaction honeypot serves as a proxy for multiple IP addresses and filters out traffic beyond concern, while the high-interaction honeypot provides an optimum level of interaction. The proposed architecture employing the prototype of a hybrid honeypot featuring autonomous operation should represent a security mechanism minimizing the disadvantages of intrusion detection systems and can be used as a solution to increase the security of a distributed computer system rapidly, both autonomously and in real-time.

In the last decade, the processing of the high dimensional data became inevitable task in many areas of research and daily life. Feature selection (FS), as part of the data processing methodology, is an important step in knowledge discovery. This paper proposes nine variation of two-step feature selection approach with filter FS employed in the first step and exhaustive search in the second step. The performance of the proposed methods is comparatively analysed from the stability and predictive performance point of view. As the obtained results indicate the choice of the filter FS in the first stage has strong influence on the resulting stability. Here, the choice of univariate Pearson correlation coefficient based FS method appears to provide the most stable results.

This paper presents the RASP (Random Access Stored Program) abstract machine emulator implemented as a plugin for emuStudio – extendable platform for computer architectures emulation. It consists of three submodules – the CPU emulator (the core of the plugin), main memory for storing RASP machine’s program and data and compiler of RASP assembly language. The compiler is able to translate RASP program source code into the form executable by the emulator. The main goal is to provide a supporting tool for Data Structures and Algorithms, respectively other subjects taught at the Department of Computers and Informatics. In addition to this, its aim is also to contribute to emuStudio platform so as to support its further development. There are not many universal software products for computer emulation flexibly extendable by plugins for new architectures and that is why emuStudio deserves our interest. Its flexibility makes it an ideal study supporting tool.

Cognitive radio (CR) is the underlying platform for the application of dynamic spectrum access (DSA) networks. Although the auction theory and spectrum trading mechanisms have been discussed in the CR related works, their joint techno-economic impact on the efficiency of distributed CR networks has not been researched yet. In this paper we assume heterogeneous primary channels with network availability statistics unknown to each secondary user (SU) terminal. In order to detect the idle primary user (PU) network channels, the SU terminals trigger regularly the spectrum sensing mechanism and make the cooperative decision regarding the channel status at the fusion center. The imperfections of the spectrum mechanism create the possibility of the channel collision, resulting in the existence of the risk (in terms of user collision) in the network. The spectrum trading within SU network is governed by the application of the sealed-bid first-price auction, which takes into account the channel valuation as well as the statistical probability of the risk existence. In order to maximize the long-term payoff, the SU terminals take an advantage of the reinforcement comparison strategy. The results demonstrate that in the investigated model, total revenue and total payoff of the SU operator (auctioneer) and SU terminals (bidders) are characterized by the existence of the global optimum, thus there exists the optimal sensing time guaranteeing the optimum economic factors for both SU operator and SU terminals.

Within the paper we present the results of our recent experiments related to effectiveness of algorithm visualizations compared to standard ways of teaching algorithms and data structures. Two original software tools used in experiments and the method of assessing of their effectiveness are described. Conclusions are given, together with further possible directions of investigation within the area.

The paper deals with the ACP2Petri tool, providing a transformation of process algebraic specification to equivalent Petri net-based specification. Long-term practical experiences with the tool revealed some suggestions for its update and extension. Shortcomings and limitations found are described and proposed solutions provided within the paper. Implemented extensions, simplifying the usage of the tool and providing more options for analysis of particular transformation, are also presented. One of the most evident extensions of the tool is its graphical user interface, which allows for convenient management and detailed control over the process of transformation.

Algorithm visualization illustrates how algorithms work in a graphical way. It mainly aims to simplify and deepen the understanding of algorithms operation. Within the paper we discuss the possibility of enriching the standard methods of teaching algorithms, with the algorithm visualizations. As a step in this direction, we introduce the VizAlgo algorithm visualization platform, present our practical experiences and describe possible future directions, based on our experiences and exploration performed by means of a simple questionnaire.

Treepace is a new library and a domain specific language for tree pattern matching and replacing, implemented in Python.Selected concepts resemble the well-known application programing interface (API) for string regular expressions.The language is terse since it is possible to write a simple transformation consisting of a pattern and a replacement in one row.Objects of any types can be used as node values.Calling host language constructs, e.g., functions, in the embedded language is straightforward.Node class inheritance allows for mapping tree nodes to external objects like GUI (graphical user interface) components.