Design and Development of Interactive Software Models for Teaching Coding Theory: A Case Study on Hamming Codes—General Algorithm

Abstract

This paper presents the design and development of interactive software models for teaching coding theory, aiming to enhance students’ comprehension through an intuitive and hands-on approach. A general methodology for designing interactive educational software is proposed and has been successfully applied in developing four software models for learning various coding techniques. These software models are suitable for both online and face-to-face classroom environments. As a case study, the paper details the implementation of an interactive software model for solving Hamming code–general approach problems, outlining its design, development, implementation, and evaluation. A pedagogical experiment was conducted to evaluate student performance using the ANCOVA statistical method. Additionally, an analysis of the completed tasks was performed to assess student progress using the interactive software tool. A survey was also administered to gather students’ feedback on their experience with the model. The findings suggest that the proposed methodology has strong potential to enhance student engagement and performance in coding theory education, making it applicable to various teaching settings and other coding techniques beyond Hamming codes, and it can be adapted for use in other scientific disciplines and teaching contexts.

1. Introduction

In modern education, there is a growing need for interactive learning tools [1,2,3,4] to support the learning of complex theoretical concepts. Traditional teaching methods often make it difficult for students to understand abstract mathematical and technical courses, which necessitates the development of innovative learning technologies. Interactive software models offer visualizations, simulations, and practical exercises that facilitate understanding and apply concepts in real-world scenarios. By being adaptable and personalized to the needs of learners, these tools could increase engagement, motivation, and learning outcomes.

Educational software has evolved from static computer-based learning systems to interactive, adaptive, and gamified environments in recent decades. Early educational software systems focused primarily on presenting static learning materials, such as text, images, and pre-recorded video lessons. These platforms are primarily based on a linear teaching structure, in which students follow a predetermined learning “path”. While this model is effective for certain disciplines, it does not offer dynamic adaptation to individual learner needs [5].

One of the main disadvantages of non-interactive learning platforms is the passive participation of learners. Some studies claim that active engagement and immediate feedback when solving problems and simulations lead to better perception of information and, respectively, to better results [5,6,7]. Therefore, the focus of modern educational platforms is on the inclusion of interactive simulations, problem-solving exercises, and adaptive learning techniques to ensure the individual needs of students [8]. In areas requiring a deep understanding of abstract mathematical concepts, such as coding theory, these educational approaches would be extremely valuable.

Error-control codes, which play a key role in ensuring the reliability of communication systems, are extremely important for understanding and applying basic principles in information technology. The introduction of interactive software learning models could provide students with the opportunity to master these concepts in a way that is both visual and practical. Research on interactive learning tools shows that such technologies can improve student understanding and retention, especially when combined with gamification elements [9]. Gamified systems can include mechanisms such as points, levels, achievements, and challenges that would motivate students to complete assignments and progress in their learning [9]. By integrating problem-solving exercises, automated feedback, and adaptive difficulty levels, educational software can bridge the gap between theoretical information and practical application.

This article proposes a general methodology for designing and creating an interactive software model intended to support the learning of various codes from coding theory. The methodology provides a systematic and unified approach to the development of educational environments, focusing on the algorithmic and programmatic aspects of modeling, along with key principles of interactive learning.

Unlike traditional static learning materials and passive simulations (simple animations with limited or no interaction), the proposed model integrates modern interactive technologies, which include:

• Real-time feedback—students receive automated guidance and analysis of their errors during task completion.
• Gamification through a point system and individual tasks—engaging students by dynamically assigning exercises with progressive difficulty.
• Process visualization—presenting the computational steps in encoding and/or decoding, which supports understanding abstract concepts.

The proposed framework builds on existing educational solutions by providing a standardized approach for developing interactive software environments. It combines theoretical training with practical experiments, allowing for both teaching and research on the effectiveness of interactive methods. This makes it applicable not only to teaching the concepts of error-control codes but also to other disciplines related to algorithmic thinking and binary data processing.

Based on this methodology, four interactive software models have been developed: Hamming code utilizing the general algorithm; Hamming code utilizing the matrix algorithm; Cyclic code employing the polynomial algorithm; and Cyclic code based on a linear feedback shift register. Some of these models support both modes of operation—encoding and decoding (Hamming codes), while others support only encoding (Cyclic codes). These models offer an opportunity for a detailed study of the relevant encoding and/or decoding processes, thereby facilitating training in coding theory.

Thanks to a unified methodology and design, the developed software models have been successfully integrated into a common virtual laboratory [10], which features various administrative modules for managing the learning process and tracking student progress. This has the potential to enhance teaching effectiveness and enable long-term analysis of learning outcomes and the adaptation of learning strategies.

This article focuses solely on the process of designing, implementing, and researching the Hamming code model using the general algorithm, providing a detailed analysis of its functional characteristics and possibilities for interactive learning.

In coding theory, Hamming code is one of the basic methods for error detection and correction in digital data transmission. Devised by Richard Hamming in 1950, this code was among the very first to allow for effective schemes for the reliable transfer of information with minimal disturbance caused by noise or other forms of errors in communication channels [11]. The applications of Hamming codes are found widely in computer networks, mobile communications, data storage, etc. [12].

The study [13] presents a way to increase the security of QR codes using Hamming codes. A mechanism is proposed for covertly embedding secret messages in QR codes using (8, 4) Hamming codes, where 8 is the total number of bits in the codeword and 4 is the number of information bits. This approach allows for compensation of errors occurring during information embedding through the built-in error correction of QR codes. The results obtained show improvements in the covert message capacity and embedding efficiency, making the method suitable for the secure transmission of sensitive data.

The article [14] presents sum-rank Hamming codes, which provide optimal efficiency in single-error correction for multiple matrix-multiplicative channels. The new family of codes is well-suited for applications where the transmission of matrix information needs to be highly reliable. In addition, these codes see application in the construction of locally correctable codes, which is in high demand in contemporary data storage systems.

In [15], a method is proposed for hiding confidential information in compressed images using Hamming codes. The described method uses Hamming codes to embed the secret bits while it optimizes the code words and reduces the pixel distortion. Experimental results indicate that this method has satisfactory performance in terms of capacity and image-embedding quality. The application of Hamming codes thus shows their effectiveness in ensuring data integrity in image-based data-hiding techniques.

Another study [16] proposes a hybrid steganography method based on least significant bit substitution and Hamming coding. This method increases the capacity for embedding secret messages with the maintenance of high-quality images. Experimental results show that this proposed technique has a higher embedding capacity and better image quality than other techniques.

Hamming codes are especially good at single-error correction and double-error detection, which makes them applicable in resource-constrained systems, such as IoT devices and memory modules [17]. The analysis shows that this code improves communication efficiency and ensures data transmission accuracy, along with strengthening device security. However, some challenges still exist to implementing them in the real IoT system. According to the authors, extended Hamming code has a lot of potential for optimization and development regarding IoT technologies. In the context of LoRaWAN and IoT networks [18], Hamming codes are integrated to improve signal decoding and increase system accuracy at low signal-to-noise ratios. In addition, they find application in serially concatenated schemes, where they significantly reduce the bit error rate (BER) in noisy communication channels while maintaining high speed.

Modern software packages such as the MATLAB R2024b Communications Toolbox [19], GNU Octave 10.1.0 [20], Python Libraries v0.8 [21], and Simulink v0.8 [22] offer powerful tools for analyzing and simulating error-correcting codes. Although MATLAB and Simulink provide very rich analysis and visualization capabilities, their high prices often make them inaccessible to individual users or educational institutions with limited budgets. GNU Octave is a free alternative that provides quite similar functionality to MATLAB, though it may be limited in the number of libraries and documentation available. Otherwise, Python libraries such as CommPy and PyFinite are popular owing to their open ecosystem and flexibility, though they do require a high level of programming knowledge, which could be a problem for inexperienced users. While these tools give powerful simulation capabilities, the lack of an interactive interface may make them less effective in teaching students entering the field.

2. Materials and Methods

2.1. A Methodology for Designing and Developing an Interactive Software Model for Solving Tasks in the Field of Coding Theory

Each of the envisaged interactive program models for solving tasks will be designed as a separate software component. For this reason, it is expedient to formulate a general methodology for their construction. The separate stages of the methodology are as follows (Figure 1):

This methodological model uses a structured and comprehensive approach that seeks to provide quality implementation of the software product throughout its life cycle, which is key when implementing software in an educational environment.

(1)

Analysis. During this first stage, detailed analysis is required on the theoretical aspects relating to the Hamming codes. Therefore, it entails:

-

A detailed analysis of the theoretical foundations of the functioning of Hamming codes, including the error-detection and correction approach that this code implements.

-

A deep summary of the mathematical computations and logical constructs inherent in the code, including the mechanisms for calculating check bits and identifying the locations of errors.

-

An understanding of the Hamming code’s constraints and capabilities is necessary to determine what the tool should include to provide the best possible training on the subject.

This analysis serves as the basis for the subsequent development of the software, as it defines both the functional requirements and the architectural framework of the tool.

(2)

Scenario. After the analysis process, a scenario is created to solve problems using the Hamming code. A scenario is an overall structure or a guide that includes the following steps:

-

Description of tasks that users need to be able to perform with the tool. For example, detecting errors in a message or correcting any errors identified.

-

Defining the sequence of steps that will lead users through the process of solving problems with the Hamming code. It could include instructions for calculating check bits, error detection, and presentation of the result.

-

Creating interactive elements and tasks that will enable a user to put theoretical knowledge into practice. For example, interactive questions, filling in tables, and process visualizations.

-

Outlining the approach to the feedback system that the tool will implement, to help students understand and correct their solutions.

(3)

Requirements. At this stage, the functional and non-functional requirements of the tool are defined. These requirements will serve as a basis for all the other steps in the process of development:

-

Functional requirements: they describe the specific functions and abilities that the tool should be able to perform, such as:

-

Providing interactive exercises for use with Hamming codes;

-

The ability to enter values and see related results;

-

A system that randomly injects errors into code combinations that the user must find and correct.

-

Non-functional requirements: these specifications refer to attributes related to the quality and performance of the software, such as:

-

Processing speed—the tool must work quickly and efficiently;

-

Intuitiveness and ease of use—the interface must be easy to use;

-

Compatibility with different platforms—the tool must be accessible from different devices and browsers;

-

Reliability and security—the data and results entered by the user must be protected.

(4)

Interface. At this stage of the methodology, a prototype of the user interface (UI) is created to determine the appearance (view) of the software from the user’s perspective:

-

Design of the main view, in which the processes of coding, error detection, and correction will be visualized;

-

Navigation and accessibility—the structure of the interface should be simple and easy to understand so that users can be orientated quickly and start working;

-

Interactive elements, such as data entry fields, buttons for starting simulations, data visualizations, and feedback on correct or incorrect decisions;

-

Color scheme and design elements that make the interface attractive and intuitive, without unnecessary complexity, especially for younger users or beginners in the field.

(5)

Code. At this stage, the program code of the software tool is compiled:

-

Selection of a programming language and technologies (e.g., PHP, JavaScript, HTML/CSS, if it is a web-based application), tailored to the needs of the software and technical requirements;

-

Implementation of the basic algorithms necessary for working with the Hamming code—calculating the check bits, detecting errors, correcting them, and providing the result;

-

Development of user interaction modules, such as visualizing the error-correction process and providing data entry capabilities;

-

Integration of the algorithms and logic with the user interface to ensure smooth and functional interaction.

(6)

Test. Testing is a critical stage that ensures the quality and reliability of the software:

-

Functional testing—checking that all the functionalities set out in the requirements work correctly. This includes:

-

Checking the algorithms for encoding and decoding, and whether they successfully detect and correct errors;

-

User interface tests for interactivity and ease of use;

-

Error testing and debugging—identifying and fixing errors in the code that can cause crashes or incorrect operation of the software;

-

Performance and security tests—measuring the execution time of basic operations and ensuring the security of user data.

(7)

Integration. The final stage is the integration of the software tool into a common virtual laboratory:

-

Integrating the tool with other educational software in the laboratory, if any, which may include a common user interface or database;

-

Creating easy access to the tool for users, for example through a centralized platform or web portal;

-

Testing the integration in a real learning environment to ensure that all components work together properly and interact seamlessly;

-

Post-integration support and monitoring to ensure that the tool continues to work properly in real-world conditions and is updated as needed.

2.2. Designing an Interactive Software Model for Solving Problems with the “Hamming Code—General Method”

2.2.1. General Concepts of Error Control Codes

• Error control codes, also known as channel (noise-tolerant) codes, serve to detect and correct (or only detect) any errors received during data transmission or storage at the expense of adding information redundancy to the data [23]. Channel codes can be error-detecting-only codes or error-detecting and error-correcting codes. On the other hand, they are divided into block and convolutional (continuous) codes. Block codes are those in which each character of a given message corresponds to a precisely defined code combination. They are divided into separable (when it is known which bits in the code combination are information and which are control) and inseparable (all bits are both information and control) [24].
• In the theory of channel coding, the following concepts are defined [24]:
• Information combination (IC)—these are the information bits that will be coded, and the number of bits in one IC will conventionally be denoted by $m$.
• Control bits ($X$)—these are the bits that are added to the information bits and thus form the code combination. The number of control bits will conventionally be denoted by $k$.
• Code combination (CC) or code word $\left[X\right]$—this is the coded combination, including the information and control bits. The number of bits in one code combination (CC) will conventionally be denoted by $n$, as:

  $$n=m+k.$$

  (1)
• Multiplicity of errors ($t$)—number of erroneous bits in one code combination.
• Code (Hamming) distance between two combinations ($d$)—number of bits by which the two combinations differ. For codes without redundancy, it is characteristic that $d=1$, and for codes with redundancy—$d>1$.
• Minimum code distance of the code ($d_{min}$)—the smallest possible code distance between two code combinations of a given code.
• Information redundancy—extra (check) bits added to the information, with the help of which it is checked whether errors occurred during the transmission/storage of the message.
• Transmission rate of the code combination ($U_m$):

  $$U_m={\displaystyle \frac{m}{n}}.$$

  (2)

  where:
  $m$—number of information bits in the code combination;
  $n$—total number of bits in the code combination.
• Weight of the code combination in binary coding—number of ones (1s) in the code word.

To determine the noise immunity of a code, the concept of error-detection coefficient is also introduced:

$$K_0={\displaystyle \frac{L}{M}}.$$

(3)

where:

$L$—number of wrong combinations in which the errors were detected.

$M$—total number of wrong combinations.

• Correction capability ($l_0$)—the correction capability of a given code is the number of errors that the code can correct and is closely related to the minimum code distance $d_{min}$ with the following dependence [20]:

  $$l_0=⌊{\displaystyle \frac{d_{min}-1}{2}}⌋,$$

  (4)

  where $\lfloor x\rfloor$ denotes the largest integer not exceeding the value of $x$.
• Detectability ($l_n$)—the detectability of a given code is the number of errors it can detect and has the following relationship with $d_{min}$:

  $$l_n=d_{min}-1.$$

  (5)

2.2.2. Analysis of the Theoretical Foundations of the Hamming Code by the General Method

Hamming codes are an important class of block codes characterized by the following structure [24]:

$$\left(n,m\right)=\left(2^i-1, 2^i-1-i\right),$$

(6)

where $i=2, 3,\dots$. These codes have a minimum code distance $d_{min}=3$ and thus, from the dependencies (4) and (5), they have the ability to correct all single errors or detect all double errors in the code combination [25].

The number of control bits $k$ is determined by the following condition [24]:

$$k\ge {log}_2\left(n+1\right).$$

(7)

Dependence (7) can be transformed into a more convenient form for determining the number of control bits in the code combination:

$$2^k-k\ge m+1.$$

(8)

Hamming codes can be defined in two ways: using the general (ordinary) method and using the matrix method. The general method of representation will be shown below.

The control bits can be placed in different positions. In Hamming codes, their placement is at positions $2^0,2^1,2^2,2^3,\dots , 2^i$ ($i=0, 1, 2,\dots$). In this case, each control bit corresponds to a group of information bits, as a result of which, each control bit is formed independently of each other [11].

Table 1. Arrangement of the bits in the code combination in the Hamming code.

Position number	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
Type of bit	$C_1$	$C_2$	$S_1$	$C_3$	$S_2$	$S_3$	$S_4$	$C_4$	$S_5$	$S_6$	$S_7$	$S_8$	$S_9$	$S_{10}$	$S_{11}$

$C-\mathrm{c}\mathrm{o}\mathrm{n}\mathrm{t}\mathrm{r}\mathrm{o}\mathrm{l}\mathrm{b}\mathrm{i}\mathrm{t}$; $S-\mathrm{i}\mathrm{n}\mathrm{f}\mathrm{o}\mathrm{r}\mathrm{m}\mathrm{a}\mathrm{t}\mathrm{i}\mathrm{o}\mathrm{n}\mathrm{b}\mathrm{i}\mathrm{t}.$

shows the location of the control ($C_i$) and information bits ($S_i$) in the code combination for the Hamming code (15, 11).

For a more comprehensive explanation and to trace the functioning of the developed interactive models, two example problems will be solved below, through which the encoding and decoding processes using the Hamming code by the general method will be presented. The examples will refer to a nine-bit information combination ($X=111001011$), which in the first task will be encoded, and in the second one—the received (from the first task) code word will be decoded.

(1)

Encoding using the Hamming code by the general method

Before proceeding with the encoding process, all parameters of the code with $m=9$ must be determined. Since $m$ is known, the number of control bits $k$ is determined from dependence (8):

$$k=4.$$

(9)

From (1), the number of bits in the code combination $n$ is calculated:

$$n=13.$$

(10)

Knowing that for Hamming codes $d_{min}=3$ [24], the correcting capability of the code is determined from dependence (4):

$$l_0=1.$$

(11)

After the parameters of the code are determined and the structure of the code is known, the code combination should be constructed with the notations (labels) of the bits and the values of the information bits (

Table 2. A code combination with the labels of the bits and the values of the information bits.

	1	2	3	4	5	6	7	8	9	10	11	12	13
$\left[X\right]=$	$C_1$	$C_2$	$S_1$	$C_3$	$S_2$	$S_3$	$S_4$	$C_4$	$S_5$	$S_6$	$S_7$	$S_8$	$S_9$
$\left[X\right]=$	$C_1$	$C_2$	$1$	$C_3$	$1$	$1$	$0$	$C_4$	$0$	$1$	$0$	$1$	$1$

).

The check-bit equations should be written down. The general rule for forming the control bit equations is addition modulo 2 is performed on all bits of the code combination participating in groups of consecutive $i$ bits, through $i$ bits, starting from the corresponding control bit, where $i$ ($i=1, 2, 4, 8,\dots$) is the control bit position number.

• Formulation of the equation for calculating the control bit $C_1$ (Figure 2). Following the general rule for the equation of $C_1,$ the grouping will start from $C_1$, one bit at a time, through one bit, yielding:

  Figure 2. Equation of the control bit $C_1.$

  Figure 2. Equation of the control bit $C_1.$

After substitution in the equation, the value of $C_1$ is calculated.

$$C_1=1\oplus 1\oplus 0\oplus 0\oplus 0\oplus 1=1 => C_1=1$$

(12)

The remaining control bits are composed and calculated in a similar way.

• control bit $C_2$ (Figure 3):

  Figure 3. Equation of the control bit $C_2.$

  Figure 3. Equation of the control bit $C_2.$

  $$C_2=1\oplus 1\oplus 0\oplus 1\oplus 0=1 => C_2=1$$

  (13)
• control bit $C_3$ (Figure 4):

  Figure 4. Equation of the control bit $C_3.$

  Figure 4. Equation of the control bit $C_3.$

  $$C_3=1\oplus 1\oplus 0\oplus 1\oplus 1=0 => C_3=0$$

  (14)
• control bit $C_4$ (Figure 5):

  Figure 5. Equation of the control bit $C_4.$

  Figure 5. Equation of the control bit $C_4.$

  $$C_4=0\oplus 1\oplus 0\oplus 1\oplus 1=0 => C_4=1$$

  (15)

And finally, the code combination with the calculated control bits is written:

$$\left[X\right]=1 1 1 0 1 1 0 1 0 1 0 1 1$$

(16)

(2)

Decoding of code combinations using the Hamming code by the general method

In this task, the code combination obtained from the previous task will be decoded. But before that, to show the correcting capability of the code, let’s artificially introduce a single error, say at position № 6, resulting in the following code combination $\left[X^{\ast }\right]$.

$$\left[X^{\ast }\right]=1 1 1 0 1 0 0 1 0 1 0 1 1$$

(17)

For the decoding process, it is necessary to know the parameters of the code, which are determined similarly to the encoding process. The parameters are:

$$m=9, k=4, n=13, \mathrm{and} l_0=1.$$

(18)

The code combination with the corresponding bit labels is given below.

$$\begin{array}{cccccccccccccc}& 1& 2& 3& 4& 5& 6& 7& 8& 9& 10& 11& 12& 13\\ [X]& C_1& C_2& S_1& C_3& S_2& S_3& S_4& C_4& S_5& S_6& S_7& S_8& S_9\\ \left[X^{\ast }\right]& 1& 1& 1& 0& 1& 0& 0& 1& 0& 1& 0& 1& 1\end{array}$$

(19)

All control bits must be checked according to their corresponding equations. The check bit equations are constructed in the same way as in the encoding process, with the difference that instead of equalizing to 0, the calculated value is written.

$$C_1=> C_1\oplus S_1\oplus S_2\oplus S_4\oplus S_5\oplus S_7\oplus S_9=1\oplus 1\oplus 1\oplus 0\oplus 0\oplus 0\oplus 1=0$$

(20)

$$C_2=> C_2\oplus S_1\oplus S_3\oplus S_4\oplus S_6\oplus S_7=1\oplus 1\oplus 0\oplus 0\oplus 1\oplus 0=1$$

(21)

$$C_3=> C_3\oplus S_2\oplus S_3\oplus S_4\oplus S_8\oplus S_9=0\oplus 1\oplus 0\oplus 0\oplus 1\oplus 1=1$$

(22)

$$C_4=> C_4\oplus S_5\oplus S_6\oplus S_7\oplus S_8\oplus S_9=1\oplus 0\oplus 1\oplus 0\oplus 1\oplus 1=0$$

(23)

After the checks have been made, the error syndrome should be recorded, which is a binary combination indicating the presence or absence of an error in the resulting code combination. If only zero values are obtained for the error syndrome, this means that there is no error in the resulting code combination. Nonzero values of the syndrome are an indication of the presence of a single error, with the syndrome specifying the position of the erroneous bit in a binary number that must be converted to decimal. If there is more than one error in the code combination, the error syndrome will not give correct information. Hamming codes also can detect double errors, but this will be discussed in the next point.

To determine the error syndrome for the particular task, the check results should be recorded in descending order of the control bit index as shown below:

• Error syndrome: $C_4{C}_3{C}_2{C}_1$ => $0 1 1 0$ => error indication
• Error position: ${(0 1 1 0)}_2={\left(6\right)}_{10}$

After converting the syndrome into decimal format, it can be seen that the wrong bit is in position № 6, which is proof of the correctness of the solution because an artificial error was made exactly in the sixth position at the beginning of the problem. To obtain the correct code combination, the value of the bit at this position should be corrected (inverted).

$$\begin{array}{cccccccccccccc}& 1& 2& 3& 4& 5& 6& 7& 8& 9& 10& 11& 12& 13\\ [X]& 1& 1& 1& 0& 1& 1& 0& 1& 0& 1& 0& 1& 1\end{array}$$

(24)

Finally, the last step remains to be performed—extracting the information bits from the code combination, and this is easy once the positions of the control bits are known.

$$\mathrm{X}=1 1 1 0 0 1 0 1 1$$

(25)

(3)

Extended Hamming codes by the general method

Extended Hamming codes enable the correction of all single errors and the detection of all double errors [11]. This capability is achieved by adding an additional control bit $C_0$. The equation of the additional bit is set as a sum modulo 2 of all the bits of the code combination and is placed in the zero position, i.e., as the most significant bit. The calculation (when encoding) or checking (when decoding) of the additional check bit $C_0$ is done last because the other check bits are included in its equation. The structure of the code combination in this case will look like this (

Table 3. Structure of the code combination for the Hamming code (15, 11).

Position number:	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
Type of bit:	$C_0$	$C_1$	$C_2$	$S_1$	$C_3$	$S_2$	$S_3$	$S_4$	$C_4$	$S_5$	$S_6$	$S_7$	$S_8$	$S_9$	$S_{10}$	$S_{11}$

) for the Hamming code (15, 11).

Table 4. Possible situations when checking the control bits in an extended Hamming code.

(1)	$\left|\begin{array}{l}{C}_0=0\\ C_4 C_3 C_2 C_1=0 0 0 0\end{array}\right.$	there is no error in the code combination
(2)	$\left|\begin{array}{l}{C}_0=1\\ C_4 C_3 C_2 C_1\ne 0 0 0 0\end{array}\right.$	there is a single error in the code combination that can be corrected by the syndrome binary code
(3)	$\left|\begin{array}{l}{C}_0=1\\ C_4 C_3 C_2 C_1=0 0 0 0\end{array}\right.$	in the code combination, there is a single error at the position of $C_0$, which can be corrected
(4)	$\left|\begin{array}{l}{C}_0=0\\ C_4 C_3 C_2 C_1\ne 0 0 0 0\end{array}\right.$	there is a double error in the code combination that cannot be corrected

shows the different situations that can occur in the decoding process when checking control bits.

2.2.3. Compiling a Scenario for Solving Hamming Code Problems by the General Method

To distinguish the processes of encoding and decoding, it is envisaged that when studying the codes, students solve the tasks of encoding and decoding independently, and for this, two separate algorithms for solving the problems should be proposed.

Figure 6 shows the general algorithms, presented in the form of standard block diagrams, for the encoding and decoding modes, respectively.

• Encoding mode (Figure 6a)

Defining the code parameters. Based on the condition of the task, the parameters $m$, $l_0$, $k,$ and $n$ are determined.

Step (1) Determining the type of bits of the code combination. In this step, it is necessary to determine (mark) the bits of the code combination of what type they are (control or information).

Step (2) Write the information bits in the code combination. In this step, the information bits are written to their corresponding positions in the code combination.

Step (3) Defining the control bits. This step is performed in several stages.

Step (4.1) Select the control bit to calculate. The selection can be made from any control bit except the control bit $C_0$ (in the extended code), which must be selected last.

Step (4.2) Formulation of the control bit equation. The check-bit equations are formed following the general rule presented in point 2.2.2.

Step (4.3) Calculating the check bit. The operations in this step consist of substituting the binary values of the information bits involved into the equation being composed and performing a modulo 2 addition.

Steps 4.1 to 4.3 are performed for each control bit.

• Decoding Mode—Figure 6b

Step (1) Corresponds to step (1) of the encoding mode.

Step (2) Matches step (2) of the encoding mode.

Step (3) Checking control bits. This action is performed in several stages:

Step (3.1) Select the control bit to check. The selection can be made from any control bit.

Step (3.2) Formulation of the control ratio equation. They are composed similarly to the equations of the control bits.

Step (3.3) Calculation of the ratio. The values from the code combination are substituted into the control ratio, and addition modulo 2 is performed.

Steps 3.1 through 3.3 are performed for each control bit.

Step (4) Analysis of the result. The error syndrome is written in binary form and then converted to decimal format. Depending on the syndrome, the status of the error is determined (“No error”, “Single error”, and “Double error”). If there is a single error in the code combination, its position is determined and corrected by inverting the bit value of that position.

Step (5) Determining the decoded binary information. From the resulting code combination, only the values of the information bits are written, in case the error status in Step 4 is “No error” or “Single error” (after correcting the erroneous bit); otherwise, the code is unable to decode the code combination.

2.2.4. Formulation of the Requirements for the Interactive Hamming Code Research Model—The General Method

• General requirements for the interactive software models

Interactive programming models for solving tasks for the study of channel codes should have similar characteristics and principles of operation, which means that a unified interface should be designed so that after familiarizing with one model, the user can easily and quickly navigate and adapt to the others.

Solving tasks through these models must follow a previously compiled algorithm of work. After the execution of each step of the algorithm, a check for correctness must be made and a transition to the next step must be allowed only if the previous one has been correctly executed. In case of an error in the execution of a step, an appropriate message should be displayed. Regarding the graphical components in the interface of the models, it is desirable that these components (text fields, buttons, texts, etc.) are visualized step by step with the execution of the steps so that the user’s focus is always directed to the relevant part of the model.

Some of the common functional requirements that any interactive model should have are grouped below.

• Control panel. Through this panel, users should be able to set the code parameters ($m,l_0,k,$ and $n$) and operation modes (encoding or decoding), as well as start and stop the model.
• Information register. In the interactive model, a separate panel should be allocated for setting the information bits in the encoding mode (encoder). The information might be entered in the following ways: automatic generation, manual bit-by-bit input, and direct input into a text field.
• Code combination register. This is a panel that should provide the ability to set the code combination in the decoding mode (decoder). The input might be done in the following ways: automatic generation of a correct code combination, automatic generation of a code combination with a random error, manual bit-by-bit input, and direct input into a text field.
• Algorithm. The software model should contain an interactive block diagram in a separate independent panel that shows the working algorithm for solving the researched task. The idea of this block diagram is to show the sequence of steps in solving the task, and when specifying a given block, a short hint for the required action should be displayed. This panel should only be visible in “Training” mode. Individual elements of the flowchart will be visualized in different colors depending on whether the given step has been completed, is currently being completed, or has not yet been completed, i.e.,

  -

  No coloring—the step has not yet been completed;

  -

  Yellow color—the step is currently being executed;

  -

  Green color—step passed successfully.

• Encoder/decoder. A separate panel should be provided where the main actions of the encoding process, resp. decoding process will be carried out, with the corresponding code.
• Statistics. During the operation with the model, statistics must be kept, including the following data:

  -

  Time to solve the task;

  -

  Number of errors made;

  -

  Error history.

• Requirements for the Hamming code research model—the general method
  For the encoding and decoding modes:
  • To allow the code combination bits to be marked with appropriate labels (for example, $S_i$ and $C_i$).
  • To be able to select a control bit, construct an equation with it, and calculate (when encoding) or check (when decoding) its value.
    For the decoding mode only:
  • To be able to set the error syndrome in binary and decimal format.
  • To set the error status as one of the following possible situations: “No error”, “Single error”, or “Double error”.
  • To be able to determine the decoded binary combination.

2.2.5. User Interface Prototype

• Graphic layout for the encoding mode

Figure 7 presents the proposed prototype of the user interface of the interactive Hamming model by the general method in the “Encoder” mode. It consists of four panels:

Panel 1. Control panel.

Panel 2. Information register.

Panel 3. Hamming encoder—a simple (general) algorithm. It represents the actual part of the model. In it, the calculations of the control bits are performed. The main actions that will be performed in this panel are as follows:

–

Marking the bits of the code combination. Initially, the bits of the code combination are undefined and have no values. From a list of pre-generated labels ($S_i$ and $C_i$), the label is selected and placed on the corresponding bit of the code combination by dragging. After correctly marked bits, the bits from the information register are loaded, using a special button, and the control bits have no values at this stage.

–

Selecting the control bit. The desired control bit is selected from the code combination by clicking on it.

–

Compiling an equation. By clicking on the corresponding bits of the code combination, an equation from the selected labels is automatically filled in a special field, and at the same time after the equation, the bit values are also substituted.

–

Calculating the check bit. By clicking on the field with the equation, the value of the expression is written with the substituted values from the equation and the corresponding value is inverted with each click.

–

Writing the control bit. Once calculated, writing the value from the equation is done by clicking on the same control bit of the code combination that was selected earlier.

Panel 4. Algorithm. It is based on the algorithm of Figure 6a.

• Graphical layout for the decoding mode

The prototype of the user interface in the decoding mode is presented in Figure 8. It consists of four panels, similar to the encoding mode interface.

Panel 1. Control panel.

Panel 2. Code combination register.

Panel 3. Hamming decoder—the general algorithm. Checks of the control bits are performed in it. The main actions that will be performed in this panel are as follows:

–

Select the control bit. The desired control bit is selected from the code combination by clicking.

–

Formulating an equation. By clicking on the corresponding bits of the code combination, the equation of the selected bit is automatically filled in a special field, while at the same time, the bit values are replaced after the equation.

–

Check bit calculation. After the equation is created, clicking on its field displays the value of the control bit, inverting it with each click.

Panel 4. Algorithm. It is based on the algorithm of Figure 6b.

2.3. Creation of the Software Model Code

Writing the code implements the algorithms underlying the principles of Hamming codes that form the basis of the tool. This stage integrates the algorithms with the user interface to ensure accessibility and intensity for learners. It also includes the selection of technologies and programming languages that will ensure the implementation of the software product so that it meets the set functional and non-functional requirements. In addition, the programming includes interactive and visual elements to improve user engagement and understanding. The description of this stage in the article emphasizes the technical implementation of the model and creates a basis for future improvements and adaptations of the software.

HTML5 and JavaScript (ES2024) [26,27,28,29] are fundamental technologies for the development of web-based interactive software applications, such as the current software model for studying Hamming codes. HTML5 provides the structure and semantic basis of the web application, allowing the construction of an intuitive and accessible user interface. Thanks to its advanced capabilities, such as the integration of multimedia content (video, audio) and built-in interaction elements (forms, tables, graphics), HTML5 significantly facilitates the implementation of complex learning scenarios. JavaScript, in turn, provides dynamism and interactivity to the application, allowing the development of functionalities for data processing, user input validation, and visualization of Hamming code algorithms in real time. By synchronizing these two technologies, the creation of software is achieved that is both functional, fast, and easy for learners to use, regardless of the device or operating system, which makes it extremely suitable for the needs of modern digital learning.

The use of the jQuery [30] and Konva [31] libraries helps to build a functional and interactive software tool, simplifying it considerably and saving much time. DOM manipulation, event handling, and animations are simplified in jQuery; hence, it assures compatibility among browsers and makes development easier. On its side, Konva allows the creation and management of interactive 2D graphics, which is quite useful in the visualization of algorithms for Hamming codes. These libraries have a key role in creating user-friendly, efficient training software, and hence the best user experience. UML diagrams [32] provide a standard way of visually representing the architecture, behavior, and interactions of software applications, which helps to understand, build, and maintain systems. Figure 9 shows the object diagram of the interactive software tool, which shows specific instances of classes at a given point in time, as well as the relationships between them. It shows a special “Error” component. It is used when solving a task in the decoding mode, and its main functions are to enable recording the checks of the control bits, recording the binary and decimal error code, setting the error status, and recording the decoded message. In addition to these capabilities, all the necessary functions for checking the set values are also available. For recording the error code in binary and decimal form, an additional component called “SUB” has been developed, which is used for recording in text format with an index; for example, (0111)₂ and 7₁₀.

The process of solving a problem with Hamming codes by the general method in the encoding mode is presented in Figure 10 through the activity diagram. It shows all the steps that the student must go through to solve the problem, as well as the moments when a given step is checked.

Figure 11 shows the activity diagram for solving the problem in the decoding mode. The first part of the diagram (the left part) coincides with that of the encoding mode from Figure 10 (the left part) and is therefore not shown in Figure 11. The main steps in this mode are related to the analysis of the result of checking the control bits, namely: recording the error code in decimal and binary form, determining the error status, and recording the decoded message, as well as all the necessary functions for checking the input data.

3. Results

3.1. Implementation of a Software Training Model for Learning Hamming Codes by the General Method

When implementing the interactive software model for learning Hamming codes by the general method, all requirements are met—both general and specific for the model (Section 2.2.4). Figure 12 shows a screenshot of a stage of solving a task with the implemented interactive model in the encoding mode. The graphical interface of the model is consistent with the proposed layout prototype presented in Figure 7. The process of solving a task with the model is fully consistent with the scenario presented in Section 2.2.3. The “Algorithm” panel presents interactive information about the steps in solving the task, with the different colors of the blocks indicating the status of the steps (in green—the completed step; in yellow—the current step), and when a given step is indicated, brief information about the action required to complete the step is visualized. At the bottom of the “Algorithm” panel, a field with three buttons called “Model control” for controlling the model can be seen, through which one can solve the task step by step or completely automatically from the beginning to the end. This field is accessible only by teacher profiles for the purpose of explaining a given task step by step or to obtain the final value during verification.

At the top of Figure 12, the field for the task condition can be seen. There are several types of task-solving modes. The first mode is called “Practice”, which serves to familiarize oneself with the model in the first-time work, in which students solve tasks without a specific condition. This mode of operation also provides a link to a video guide for working with the model. The second mode of working with the model is solving tasks under a specific condition (Task1, Task2, …). The third mode of working, which is not visible in Figure 12, is “Control work”, which is identical to that of tasks under a specific condition, but with a limited number of attempts to start the model.

Figure 13 shows a screenshot of the model in the decoding mode. The steps in the algorithm for working with the model are based on those in the scenario for solving problems with the Hamming codes by the general method (Section 2.2.3).

3.2. Software Tool Effectiveness Assessment

The effectiveness of the introduced training software model needs to be evaluated to determine its real-world significance and effectiveness in education. The evaluation focuses on how well the software meets the training objectives, supports the understanding and retention of instructional material, and helps students acquire practical competencies. It also examines compliance with the functional requirements defined by the client, assesses the intuitiveness of the user interface, and measures overall user experience. The test results may become a groundwork on which to pursue further refinement of the model by improving its efficacy and sensitivity toward the needs of various user groups.

To assess the effectiveness of the developed software tool, an experimental study was conducted, including three independent analyses (Figure 14). First, a pedagogical experiment was conducted, aimed at measuring student success when using the tool, and descriptive statistics and covariance analysis (ANCOVA) were used for statistical processing of the results. Second, data from the actual use of the software tool (from the software tool database) were analyzed, including the number of solved tasks, average time for solving, and the number of errors made, which allows an objective assessment of its practical applicability. Third, a survey was conducted among students, aiming to establish their satisfaction and their subjective perception of the usefulness of the tool in the learning process.

3.2.1. Pedagogical Experiment for Student Success

Conducting a pedagogical experiment is necessary to objectively establish the influence of the used software tool on student success. Two groups of students were formed—a control group and an experimental group. The traditional written method, which was applied in the control group, will serve as a basis with which the results of the innovative training using the software tool in the experimental group can be compared.

These codes are studied in the course “Reliability and Security of Computer Systems” in the third year by students in the specialty “Computer Systems and Technologies” at the University of Ruse “Angel Kanchev”. It is important to note that the students from both groups studied the course at different times. The data for the students from the control group are from 2019 and 2020, and for the experimental group—from 2021 and 2022. In both groups, the number of students is 59. In the control group, the number of males is 51, and of females—eight. In the experimental group, the gender distribution is 53 males and six females.

The collected data on the initial academic level of the students (average grade from the previous two semesters) will ensure equality between the two groups, minimizing the impact of external factors on the results of the experiment. The grades from the control work on tasks with Hamming codes by the general method will serve as a quantitative measure of success, allowing for an objective analysis of the differences between the groups. This will verify whether the use of the software tool has a statistically significant impact on the understanding and skills for solving tasks with Hamming codes by the general method, by comparing the achievements of the two groups and determining the specific pedagogical impact of the technology used on the learning process. The grades from the previous two semesters of the students were received from the faculty office of the university, and the grades from the control works—from the teachers who conducted the practical exercises of the discipline “Reliability and Security of Computer Systems”.

• Basic statistics

Descriptive statistics allow the identification of the main characteristics that the data reflects. It also serves as an initial step for analysis and interpretation since, through this, a better understanding of results, and proper planning for more complex statistical analysis, is possible. The software product used in this study, SPSS v26. SPSS, or Statistical Package for the Social Sciences, is a highly efficient software program for statistical processing and analysis; it finds broad applications in scientific fields. It supports the following methods of analysis: descriptive statistics, regression models, ANOVA, ANCOVA, cluster analysis, and factor analysis [33].

Table 5. Descriptive statistics results for the previous two semesters (initial academic level).

Descriptives Average Grade from the Previous Two Semesters
Group		Control		Experimental
		Statistic	Std. Error	Statistic	Std. Error
Mean		4.5829	0.10109	4.6810	0.08408
95% Confidence Interval for Mean	Lower Bound	4.3805		4.5127
	Upper Bound	4.7852		4.8493
5% Trimmed Mean		4.5778		4.6699
Median		4.5000		4.6700
Variance		0.603		0.417
Std. Deviation		0.77649		0.64586
Minimum		3.00		3.20
Maximum		6.00		6.00
Range		3.00		2.80
Interquartile Range		1.34		1.00
Skewness		0.209	0.311	0.131	0.311
Kurtosis		−0.878	0.613	−0.554	0.613

shows the results of the descriptive statistics for the previous two semesters, i.e., for the initial general academic level for the two groups. The data in the table suggest that the two groups have similar distributions of results, but there may be small differences in the consistency of the results. This requires additional analysis to verify the existing differences.

Table 6. Results of the descriptive statistics from the control works using the Hamming codes—the general algorithm (final state).

Descriptives Hamming Code GA Average Test Scores
Group		Control		Experimental
		Statistic	Std. Error	Statistic	Std. Error
Mean		5.1271	0.11297	5.6398	0.06818
95% Confidence Interval for Mean	Lower Bound	4.9010		5.5033
	Upper Bound	5.3533		5.7763
5% Trimmed Mean		5.1879		5.6926
Median		5.0000		6.0000
Variance		0.753		0.274
Std. Deviation		0.86773		0.52373
Minimum		3.00		4.00
Maximum		6.00		6.00
Range		3.00		2.00
Interquartile Range		1.50		0.50
Skewness		−0.735	0.311	−1.274	0.311
Kurtosis		−0.332	0.613	0.661	0.613

shows the results of the descriptive statistics for the grades from the control works using the Hamming codes—the general algorithm. The results show that the students from the Experimental group who used the software tool showed a higher average grade (5.64 compared to 5.13 for the control group) and a smaller variation in the results compared to the control group.

Figure 15 shows the distribution of the average grades from the previous two semesters for the control group (Figure 15a) and the experimental group (Figure 15b) in the form of a histogram.

Figure 16 shows the histograms of the grades from the control works using Hamming codes—the general method for the control group (Figure 16a) and the experimental group (Figure 16b).

• ANCOVA analysis

ANCOVA (analysis of covariance) is a statistical method that assesses the influence of independent variables on a dependent variable, while at the same time reducing the influence of external variables (covariates) that may have an impact on the dependent variable, thereby isolating the effect of the main independent variable [34]. In the present case, it is suitable for studying the influence of the software tool on the success of students (grades from control works using Hamming codes—the general method), considering their previous academic success (average grade of the previous two semesters). This allows for the correction of differences in initial levels of knowledge, providing a more accurate assessment of the effectiveness of the tool compared to the traditional method.

The definition of the ANCOVA variables for the current situation is as follows:

• Dependent variable: Assessment (grade) from the control work.
• Independent variable: Group, i.e., learning method (traditional method vs. interactive software).
• Covariates:

  o

  Average grade from the previous two semesters.

  o

  Period (2019–2020 vs. 2021–2022).

One of the important conditions for using ANCOVA is that there is equality of variances of the dependent variable [34]. The results of the test for equality of variances are given in

Table 7. Results of the Levene’s test for equality of variances for test grades using Hamming codes—the general method.

Levene’s Test of Equality of Error Variances a
Dependent Variable: Hamming Code GA Average Test Scores
F	df1	df2	Sig.
3.128	1	116	0.080

Tests the null hypothesis that the error variance of the dependent variable is equal across groups. ^a. Design: Intercept + AverageGrade + Gender + Year + Group.

using the Levene’s test. In the Levene’s test, the hypotheses are formulated as follows: $H_0$ (null hypothesis)—the variances of the two groups are homogeneous; $H_1$ (alternative hypothesis)—there is a violation of the homogeneity of variances in the groups.

From Table 7, the p-value (in SPSS it is denoted by Sig.) is 0.080, which is above the standard level of significance (usually 0.05). This means that there is not enough evidence to reject the null hypothesis, i.e., the assumption of homogeneity of variances is met.

Table 8. Results of the ANCOVA analysis.

Tests of Between-Subjects Effects
Dependent Variable: Hamming Code GA Average Test Scores
Source	Type III Sum of Squares	df	Mean Square	F	Sig.	Partial Eta Squared
Corrected Model	20.328 a	4	5.082	12.216	0.000	0.302
Intercept	0.072	1	0.072	0.172	0.679	0.002
AverageGrade	7.610	1	7.610	18.294	0.000	0.139
Gender	2.463	1	2.463	5.922	0.017	0.050
Year	0.067	1	0.067	0.160	0.690	0.001
Group	2.171	1	2.171	5.218	0.024	0.044
Error	47.008	113	0.416
Total	3487.188	118
Corrected Total	67.335	117

^a. R Squared = 0.302 (Adjusted R Squared = 0.277).

shows the results of the ANCOVA analysis for the dependent variable “Hamming Code GA Average Test Scores”, in which the influence of various factors on the students’ results can be observed.

The meaning of the individual measures in ANCOVA can be explained as follows:

Sum of Squares: it shows the variation in the dependent variable explained by the model. A larger value means that the model explains more of the variation.

Degrees of freedom—df: The number of degrees of freedom for the “Corrected Model” depends on the number of independent variables and covariates included in the analysis.

F-value and p-value: The F-value and p-value assess whether the “Corrected Model” is statistically significant. If $p<0.05,$ at least one independent variable significantly affects the dependent variable.

Partial Eta Squared (η²): The value of the Partial Eta Squared indicates how much of the total variation in the dependent variable is explained by the model. This value ranges from 0 to 1, with higher values indicating a stronger effect of the model on the dependent variable.

• Corrected Model:

In ANCOVA results, the term “Corrected Model” expresses the total effect of all independent variables (factors) and covariates included in the model on the dependent variable. This includes the individual effects of each factor (such as “Group”, “Year”, “Gender”) and covariates (such as “AverageGrade”), as well as possible interactions between them.

o

Type III Sum of Squares: 20.328

o

df: 4

o

Mean Square: 5.082

o

F-value: 12.216

o

p (Sig.): 0.000

o

Partial Eta Squared: 0.302

The overall model is statistically significant because $p<0.05$, which means that the factors included explain a significant portion of the variance in the test scores. $Partial Eta Squared=0.302$ indicates that 30.2% of the variance in the dependent variable can be explained by this model.

• Intercept:

  o

  p (Sig.): 0.679.

The intercept shows the predicted value of the dependent variable when all independent variables are equal to zero [35]. The intercept is not statistically significant in this model because $p>0.05$. This means that the baseline level of the dependent variable (the mean value with the independent variables set to zero) is not significantly different from zero.

• AverageGrade:

  o

  Type III Sum of Squares: 7.610

  o

  F-value: 18.294

  o

  p (Sig.): 0.000

  o

  Partial Eta Squared: 0.139

The average grade has a significant effect on test scores, explaining about 13.9% of the variance in scores. This indicates that students with higher grades before the Hamming codes training tend to have better test scores.

• Year:

  o

  p (Sig.): 0.690, which is above 0.05.

Year of training is not a significant factor, meaning that there is no significant difference in test scores depending on the year the training was conducted.

• Gender:

  o

  Type III Sum of Squares: 2.463

  o

  F-value: 5.922

  o

  p (Sig.): 0.017

  o

  Partial Eta Squared: 0.050

Gender is a significant factor (p < 0.05), explaining about 5% of the variance, but it should be noted that the uneven distribution of males and females in the groups (51 males and eight females in the control group, and 53 males and six females in the experimental group, respectively) may affect the results. This imbalance may lead to a distortion of the interpretation of gender differences, since the small number of females in both groups may not be sufficient to reliably conclude about the influence of gender on the dependent variable.

• Group:

  o

  Type III Sum of Squares: 2.171

  o

  F-value: 5.218

  o

  p (Sig.): 0.024

  o

  Partial Eta Squared: 0.044

The training method (group) is also a significant factor, explaining about 4.4% of the variance in the results. This shows that the use of the software tool (the experimental group) has a positive effect on the results.

• Error and Total:

  o

  Error: the unexplained variance is 47.008, and the value of the Mean Square Error is 0.416.

  o

  Total: the total sum of squares is 3487.188.

Figure 17 shows a comparative graphical dependence of the scores (Estimated Marginal Means) between the control group and the experimental group with the covariates taken into account. The graph clearly shows that the experimental group (students who used the interactive software) had higher scores compared to the control group. This supports the claim that the software model has a positive effect on success, according to the data from the ANCOVA analysis.

The results of the ANCOVA show robust evidence that the proposed interactive software-based training method significantly affects the performance of the students (p < 0.05). The overall model accounts for 30.2% of the variation in test scores, which means that although other external variables could affect learning outcomes, the chosen independent variables contribute significantly to determining the success of the students.

The other key predictor of final performance is students’ pre-existing knowledge, as indicated by their pre-training grades, which accounts for 13.9% of the variance. This indicates that students who have a better knowledge base are more likely to achieve greater levels of performance post-training irrespective of the instructional method. Nevertheless, the experimental group, while their pre-existing knowledge differed, still maintained significantly higher final scores, thereby substantiating the additional advantage offered by the software tool.

Gender accounted for 5% of the variance in test scores, suggesting an influence on learning outcomes. Care must be taken, however, to interpret this finding since the study had a disproportionate male and female sample in the various groups. This may cause bias in the results, making additional research with a balanced sample needed to see if gender differences still hold across various settings.

It is interesting to note that the training year was not identified as a statistically significant factor, which suggests that variations between groups of students or potential variations of curriculum across years did not have a detectable impact on learning outcomes. This stability over several years also adds to the validity of the proposed methodology.

The most important finding was that the training method (control vs. experimental group) was a determining factor in student success. The use of the interactive software explained 4.4% of the variance in test scores, thus depicting a noteworthy effect on learning efficiency. Experimental group students outperformed their counterparts in the control group consistently, as per the analysis of results. This variation in performance indicates the effectiveness of the software tool in establishing theoretical concepts and strengthening problem-solving skills in coding theory.

3.2.2. Analysis of Statistical Data on the Usability of the Developed Training Software

Statistical data analysis of solved tasks is a fundamental method for evaluating the effectiveness of software training models. It allows the detection of weaknesses, gives evidence for the pedagogical objectives, and permits targeted model improvements. Besides, statistics prove the scientific reliability of the model and can serve as one more motivational tool for learners to let them see the progress achieved. This approach is essential for developing effective and adaptive learning solutions [36].

The interactive software model for learning Hamming codes using the general algorithm has been successfully implemented in the learning process since 2021. The total number of solved tasks with the model at the time of writing the article is 3097. Figure 18 provides general information on the solved tasks by year. This statistic shows a significant increase in the activity of solving tasks over the years, which may indicate that the software successfully engages users and supports their learning.

Figure 19 illustrates the error rates of tasks completed with the Hamming model for the experimental group. The data show that a large proportion of the tasks were done correctly, with 63% of the encoding tasks (Figure 19a) and 59% of the decoding tasks (Figure 19b). Moreover, the proportion of the tasks having more than seven errors in either mode is rather small. The distribution shown suggests that the model is proficient in task handling, with a tendency to reduce the occurrence of errors. However, since this data set represents only the experimental group and does not include comparable data from a control group, no further conclusions can be made about the overall effectiveness of the model.

The average times for solving tasks have an important statistical value in analyzing the effectiveness of the model because they provide information about the speed with which students learn and apply their knowledge. Figure 20 illustrates box-plot diagrams of the average times to complete tasks using the Hamming model through the general algorithm. To minimize the influence of random factors or outliers, averages were calculated based on three tasks for both the initial (first three tasks) and final (last three tasks) stages of the student’s performance. The trend, as can be seen in Figure 20, shows a decreasing direction of average times for encoding and decoding tasks. In the computation of data presented in Figure 20, tasks of approximately the same complexity were taken into consideration. To this extent, complexity was a function of the number of check bits (k). The first three tasks and the last three tasks are comparable in complexity since all of them use the same number of check bits (k = 4). This means that with time, students master the concepts better and solve the problems faster, and it can be concluded that there are gains from training with the model developed.

The analysis of statistical data shows that the interactive software model for studying Hamming codes using the general algorithm successfully supports learning. During the time interval of the study, 3097 tasks were solved, with an increasing trend in activity. The majority of tasks were solved without errors (63% in encoding and 59% in decoding), and the minimal number of serious errors confirms the effectiveness of the model. The average solving times decrease, which indicates that students master the concepts faster and more effectively. All this gives reason to claim that students gradually master the concepts better and solve the tasks faster, which confirms the positive effect of the software tool on the learning process.

3.2.3. Student Satisfaction Assessment Through Survey

Student satisfaction surveys play a crucial role in evaluating the effectiveness and acceptability of interactive simulation software as educational tools. The surveys provide broad insights into students’ personal perceptions of the usefulness, ease of use, and impacts of the tool on their learning experiences. Such information from the surveys can also present both the strengths and weaknesses of the software, along with possible areas for improvement. Moreover, satisfaction levels correlate directly with students’ motivation and engagement, which in turn reflects in their learning efficiency.

A survey was conducted to assess students’ satisfaction with the use of an interactive software model for learning Hamming codes by the general method. The total number of students who participated in the survey was 54. The students were given the opportunity to rate their satisfaction with the software model on various criteria on a five-point Likert scale, as follows: “Strongly Dissatisfied”, “Dissatisfied”, ”Neutral”, “Very Satisfied”, and “Satisfied”. The students rated the software tool on the following criteria: “User Interface Design”, “Easy orientation”, “Website Speed Performance”, “Task-solving Guide”, “Description of the Mathematical Algorithm”, “Practicing and Reinforcing Problem-Solving Skills”, “Error Statistics”, and “XP Reward Points”. The results of the survey are given in Figure 21.

The results in Figure 21 show that the software is positively evaluated on most criteria, especially practical skills and navigation abilities. However, there are also ways to improve it, mostly regarding the parts dealing with error analysis and the reward system. This data can be used as a base for further improvements to improve both users’ satisfaction and the overall effectiveness of the training process.

4. Discussion

The present study provides a basis for future developments, as the applied methodology can be expanded and adapted to other complex mathematical disciplines. Such an expansion would allow for a broader validation of the systems approach in the design of interactive learning environments and confirmation of its effectiveness in different educational contexts.

For a more reliable statistical confirmation of the results, the collection of additional data from student tasks is currently ongoing. The expansion of the sample will contribute to a more accurate analysis of the effectiveness of interactive software and will allow to draw conclusions applicable to different groups of learners.

The following improvements can be applied in future studies:

–

Expansion of the data set—a collection of more data from different cohorts and educational institutions. This will allow us to assess the effectiveness of interactive software in different educational contexts and to identify the factors that most strongly influence the results.

–

Application of advanced statistical methods—using more complex statistical tests for a deeper analysis of the impact of interactive elements on the learning process. More precise measurement of the effect will help to better adapt the methodology to different groups of students.

–

Research on additional factors—analysis of the role of cognitive learning styles and the effects of gamification on student motivation and results. A better understanding of these aspects will allow adapting the learning process to the individual needs of students.

In addition to improving the methodology, a new mode for solving tasks is being developed, which will integrate more game elements to increase student engagement. In this mode:

–

Students will be able to earn badges and medals based on the results achieved.

–

Theoretical test questions will be included, which, if answered correctly, will facilitate obtaining higher honors.

–

Rankings will be created, reflecting individual achievements and stimulating the competitive element in learning.

This approach is expected to encourage more active participation and to support a better understanding of theoretical concepts through game elements.

We believe that future improvements will contribute to the development of interactive teaching methods in coding theory, as well as in other disciplines requiring a high degree of mathematical abstraction. The successful implementation of this approach can lead to more effective learning processes that combine theory, practice, and student engagement.

5. Conclusions

This article presents a general methodology for the design and development of interactive software models for studying coding theory. The methodology is implemented through a web-based tool for working with tasks related to Hamming codes. The main advantage of this approach is the structured development of training modules that can be integrated into a single learning environment with a unified user interface.

The conducted pedagogical experiment (ANCOVA) confirms the effectiveness of the developed software model. The results show that the proposed methodology has a statistically significant positive effect on student success—the experimental group using the software achieves higher results compared to the control group. The analysis also confirms that previous academic results are a good predictor of future success, while the influence of gender is statistically significant, but requires additional research due to the uneven distribution of students.

In addition to academic results, data from the use of the software confirm its effectiveness in increasing engagement. An increase in student activity is observed over time, and the error analysis shows that a significant proportion of the tasks are solved correctly, with solutions with more errors remaining low. The reduction in the time to solve the tasks with the accumulation of experience further demonstrates the effect of the model on strengthening practical skills.

Student feedback through a survey provides additional evidence for the perception of the software as a useful learning tool. The most highly rated are improved practical skills and intuitive navigation, but areas for improvement have been identified, such as expanding the error analysis and improving the reward system.

The following main contributions can be highlighted:

–

Presentation of a universal methodology for designing interactive training tools for coding theory.

–

Development and validation of web-based software for working with tasks related to Hamming codes.

–

Conducting an experimental study confirming the statistically significant effect of the proposed methodology on learning outcomes.

–

Analysis of real data from the use of the software, showing increased engagement and improvement in students’ skills.

Despite the positive results, the present study has some limitations:

–

The sample size in the experiment limits the generalizability of the results.

–

The uneven distribution of students by gender makes it difficult to analyze this factor.

–

The lack of long-term follow-up of student results does not allow conclusions about the long-term impact of the method.