DESCRIPTORS: distance learning, information technology, third generation educational standards, development of new methods of teaching on-line, teaching techniques.
SYNOPSIS: The author describes some new ways of making presentation of course material in the digital form using comments in run-time modules or their parts. A few cases are given as well.

***

Implementation of third generation educational standards for Russian colleges and universities is currently changing the class/self study ration towards increased emphasis on self-study. Recommended academic workload in class is 23-25 hours (undergraduate school) and 18-20 hours (graduate school)¹. Among the key measures to intensify students’ self study activity are optimization of teaching methods and IT application. Up-to-date teaching and learning courses must be, at least partially, in digital form and contain links to online resources. Computer-based learning resources may be used both for class activity and self study either in computer labs or via distant access. New educational process requirements generate new ways of student-teacher interaction. While a traditional lecture or workshop allowed real time correction of class based on the students’ reaction, computer-based courses imply delayed feedback and hence adjustment of teaching methods. That is why development of digital educational resources demands that the teacher should not only demonstrate computer proficiency but apply his or her own didactic (teaching) experience to work out new teaching methods, but also analyze the practice of other colleagues who are using IT in their professional activity.

We believe that presentation of course material in the digital form (which involves programming languages) may become more efficient and methodologically valuable if the developers offer comments in run-time modules or their parts. As a rule, comments in software realize a purely informative function, they are used to describe and explain various subprograms, operators, data, etc. Most experts share the opinion that comments must explain the programmer’s intention. Thus, Donald Knuth², the author of “Literate Programming”approach, suggests in his earlier article (which carries the same title) that the main paradigm should be modified, “Instead of imagining that our main task is to instruct a computer what to do, let us concentrate rather on explaining to human beings what we want a computer to do.”³ From the didactic standpoint, the use of comments makes it possible to understand how to proceed from natural language phrasing, which describes a problem solution algorithm, to the formal language commands which realize this algorithm.
Let us illustrate the use of comments for teaching purpose in presentation of the “Information science and programming” course studied by graduate students majoring in applied information science.

The “Information science and programming” virtual course was developed in the Moodle Open Source Course Management System. The course contains lectures, assignments, tests, etc. The lectures and assignments include executive modules and parts of programs. Now we will describe how the subject of “Recursion” is presented in the “Information science and programming” virtual course. The course materials were prepared according to A.I. Marchenko’s teaching guidelines “Programming in Borland Pascal 7.0.”⁴

Application of recursion to realize Charles Hoare’s quick sort method

Task: to perform quicksort on a linear array by using recursive procedure.

First, the quicksort algorithm is described verbally and by means of graphic illustration followed by the program text with detailed comments. In the following program text, the comments precede the operators.

ProgramSort;
UsesCrt;
Const
n = 20;   {              number of array elements }
Var
                A : array [1..n] of integer;
                i: word;
{              quicksort procedure           }
procedure Qsort ( L, R : word );
{              L и R – parameters-values,                                                                                                                }
{              L – index of the left array element, R – index of the right array element }
var
B, Tmp : integer;
{              variableВ is used to store the central array element  }
{              variable Tmpis used to rearrange array elements                       }
i, j : word;                            
begin
{              select the central array element and write it to  В                        }
B := A [(L+R) div 2];          
{              scan the array by turn from left to right and from right to left                  }
i := L;  j := R;                       
                while      i <= j       do
                begin
{ if while going from left to right we find an element >=B, then we remember its location}
while A[i] < B do i := i+1;
{if while going from right to left we find an element <=B, then we remember its location}
while A[j] > B do j := j-1;
{              the found elements are swapped, and then we proceed in the same way                 }
{              until upon the next iteration opposite indexes i и jintersect                                     }
if i <= j then
                                begin
                                                Tmp := A[i];
                                                A[i] := A[j];
                                                A[j] := Tmp;
                                                i:= i + 1;
                                                j := j-1;
end;
end;
{              the first sorting stage is over;                                                                                           }
{              the array is divided into two sections in relation toВ – all elements which          }
{              are smaller or equal to В will be placed to the left of the interaction of iindexes                }
{              andj, while all elements which are greater or equal to В will be placed               }
{              to the right of the border; thus, the array has been sorted in relation to В,}
{              but its left and right parts have not been sorted yet.                                                   }

{              Sorting the left part of array            }
ifL < jthenQsort ( L, j );
                {              Sorting the right part of array         }
ifi < RthenQsort ( i, R );
end;

{              Master program   }
Begin
ClrScr;
Writeln (‘Input array elements:’);
For i:= 1 to n do Read ( A[i] ); Readln;
{              Activate the sorting procedure                                         }
               {               Actual values of left and right array elements go to the procedure         }
Qsort ( 1,n )
{              The sorted array is displayed on the screen  }
Writeln (‘Sorted array:’);
                For i := 1 to n do Write ( A[i] : 8);
                Writeln;
End.

Let us consider another interesting teaching technique for students to learn programming languages. It is also based on comments and essentially comes to the following. The student receives the source program code which does not contain any comments. His task is to add comments, formulate the task which is solved in this program, and describe the algorithm verbally. Such assignments may be offered in the essay format of Moodle. Here is a small example of such an assignment.

The student receives the following assignment: Here is the source program code.  Add comments, formulate the task which is solved in this program, and describe the algorithm verbally.

Program                Pr;
Uses Crt;
Const
                n = 20;
Type
                Tvector = array [1..n] of real;
Var
                Vector : Tvector;
                X : real;
                L, R : integer;
                i : integer;
Begin
                ClrScr;
                Writeln (‘’);
                For i := 1 to n do read (Vector[i]); Readln;
                Write (‘’);
                Readln (X);
{-------------------------------------------------------------------------------------------------------------}
                L := 1; R := n;
                while ( L <= R ) do
                begin
                                i := ( L+R ) div 2;
                                if Vector [i] = X then
                                                Break
                                else
                                                if Vector [i] < X then L := i + 1
                                                                                   else R := i – 1;
                end;
                if Vector [i] = X then
                                Writeln (‘’)
                                                Else Writeln (‘’,i);
{-------------------------------------------------------------------------------------------------------------}
End.

Note that the text in output procedures is intentionally missing.

The solution of the assignment starts with the attempt to understand the actions executed by the operators; then the task is formulated and a verbal description of the algorithm is provided. In our case, the solution may look as follows:

ProgramPr;
UsesCrt;
Const
n = 20;                   {              dimension of array              }
Type
                Tvector = array [1..n] of real;
Var
                Vector : Tvector;
                X : real;
                L, R : integer;
                i : integer;
Begin
                ClrScr;
                Writeln (‘Enter array elements’);
                For i := 1 to n do read (Vector[i]); Readln;
                Write (‘Enter the required element’);
Readln (X);
{-------------------------------------------------------------------------------------------------------------}
L := 1; R := n;                       {L – left index, R – right index           }
while ( L <= R ) do
begin
i := ( L+R ) div 2;                 {find the pivot index           }
ifVector [i] = Xthen{if pivot is equal toX, }
Break{ then quit the cycle as the element is found }
else{ otherwise continue the search       }
ifVector [i] < XthenL := i + 1         { in the left part of array    }
elseR := i – 1;   {in the right part of array  }
end;
                if Vector [i] = X then
                                Writeln (‘The required element is located at’,i)
ElseWriteln (‘’);
{-------------------------------------------------------------------------------------------------------------}
End.

This program executes search of the required value in the ascending order one-dimensional array. 

Of course, the above teaching techniques may be also applicable in the orthodox way of teaching. However, we should not forget that orthodox ways of teaching involve direct student-teacher contact. The teacher controls the situation and is able to adjust the presentation. If the learning material is presented in the digital form, each tiny detail must be thoroughly planned, as students do not have constant opportunity to contact the teacher for explanation.

We sometimes hear the opinion that modern IT will cut traditional methods and techniques out of educational process. This is not the case. Informational technologies equip the teacher with a powerful tool to further develop teaching methods according to present-day conditions. On their own, information technologies do not exclude either teaching methods or teachers. Just like computers took over the abacus and not the accountant, advanced computer technologies will take over the traditional blackboard and chalk and not the teacher. In the IT age, teacher’s functions – as presentation of theoretical material, practical skills development, intermediate and final control, etc. – will belong to teachers even if realized indirectly. Creative approach to development of computer-based courses will only increase the role of teaching methods and teacher’s mastery. Information technologies as a teaching tool are offering a new impetus to further develop teaching methods.