Experimental IT education for
lower secondary school using
Windows and Comenius Logo


Monika Tomcsányiová
Peter Tomcsányi
Comenius University Bratislava,
Slovak Republic,
tel: +421 7 724 826,


A new type of secondary schools is being introduced in Slovakia – eight year secondary school. These schools cover lower and upper secondary education (ages from 10 to 18). These schools prepare students for further university-level education, but they have often also their own specialisation. Some of them are oriented to foreign languages, in other ones more mathematics or information technology is taught. Our paper describes our experience in an experimental information technologies education in a lower secondary school in Bratislava (ages 10 to 14). We introduce the main ideas of our conception used in these experimental classes. We also show several themes of projects for children and finally we show one bigger project oriented towards co-operation between pupils in the classroom.


Information technology education, open-ended projects, projects for younger schoolmates, communication between pupils, Logo


1 Introduction

In our paper we will describe our experiment which is currently being carried out on an eight year secondary school on Kosicka street in Bratislava, Slovakia. We already reported about our experiment after its first year in [1]. Now the experiment is running for the fourth year. At its beginning there was an idea of unconventional education of IT for lower secondary classes (ages 10 to 14). This idea developed gradually to actual lessons and particular activities for pupils were developed.

Our goal is to let the children gain an experience with a computer which is different than that with computer games. And this experience has to be attractive and interesting and of course, not self-centred. After introducing IT to schools in our country, children were taught to operate some programs and to use some commands and procedures of existing operating systems because there was no better conception. The pupils usually learn what to push or click in a particular program to achieve some action, to enumerate all the external MS-DOS commands etc. As if this were that what they needed for real life. But this is not IT teaching (at least not for this age group)! The number of useful programs and their functionality extends incredibly rapidly! Therefore we think that it is more important to teach the children to explore, invent and to think creatively. And the computer can assist us excellently.

2 Our experiment

The experimental IT teaching begins in the first grade of the eight-year secondary school and lasts until the fourth grade. As it has begun four years ago, we have now for the first time pupils in the fourth grade and for the fourth time pupils of the first grade.

During the experiment we instigate the children to make friends with the computer, to learn interesting programs, to learn to request from the computer what they need for reaching their goals and to learn which kind of goals they can set. The pupils have the IT lesson once in a week and it takes two hours. Each class is divided to three groups each of 10 to 12 pupils. We can use two PC computer classrooms. Each computer is used just by one pupil. The third group stays in a classroom without computers. The first two years all the three groups do the same activities. After that some of the pupils find out that they want to use the computer as an assistant (a tool) to achieve their own goals. Other pupils want to instruct the computer to behave according to their wishes and ideas. We suppose that two years can be enough time for the children to develop their relation to computers as a tool to create something apart from information technologies (like a painting, a poem, an experiment in physics) or to create something within information technologies (a computer program, a piece of software). So at the beginning of the third grade each pupil has to decide if he or she wants to be educated more as a computer user or as a computer programmer. According to their decision we divide them again to three groups (one for programmers and two for users or vice versa - it depends on the situation in a certain class). It can seem that it is too early to differentiate so young children, but our experience shows, that we made a good decision. Why should we force a pupil who does not like programming to learn special features of a programming language? And why force other pupils to learn just ready-made programs while they would like to create their own ones?

In the next paragraphs we describe our approach in each of the four years. As in each year there are 33 lessons planned, it is not enough space here to mention all of the activities. Therefore we would like to highlight some of them which are characteristic to our approach.

2.1 Prima (First grade)

In the first grade 10 to 11 year old pupils are introduced to computers in such a manner that the teacher imposes tasks and together with the pupils looks for a helper to fulfil the task. The helper is usually a computer program. However, sometimes it is "just" pupil’s own intellect and facile hands. This way the pupils drew a butterfly and a Japanese girl, designed their own visiting-cards and a logo of their class, they assembled animal shapes from the magic egg, encoded secret messages, created a maze, scanned their photos to use them for an identity cards or for a ‘forged banknotes’ with their own faces on them. They have got acquainted with the clock and calculator accessories and also with the games which come with Windows.

Later we introduced them to Comenius Logo. They have got acquainted with the turtle, with the environment in which it lives and with commands which it recognises. They controlled the turtle to reach its home, built a village [1], played and finalised a game (Cold-Warm-Hot), completed a crossword puzzle, corrected faulty programs, and accomplished many other simple task and tasks of moderate complexity. Our meetings with Comenius Logo in the first grade end with the knowledge of the basic turtle commands forward, back, left, right, setpc, setpw and repeat, the pupils are able to use the Buttons Window and they are able to define their own commands.

2.2 Secunda (Second grade)

In the second grade of the eight-year secondary school (11-12 year old pupils) we attempt to continue the activities from the first grade - we are doing interesting activities. Just in this year more Comenius Logo programming is done. Such basics of Logo are used which should be understood by most of the 11 year old pupils. The Logo projects are oriented so that after two hours work the children have something ready in their hands. They must have the feeling that they completed something serious - they programmed their own simple game or they finished an incomplete project (prepared by the teacher). We use again also the painting program (Paintbrush). We paint a timetable and also many other pictures which serve as backgrounds (screens) for the Logo programs.

Inspired by the experiment from Hennigan School [2], the pupils try to create programs for younger children (school fellows). As an example of this approach a Logo project was created in which the user - a first grade pupil of a basic school (6 - 7 years old) must set the hands of the clock according to a story.

In the Jungle project the pupils create animated pictures using the Image editor (part of the Comenius Logo environment). More kinds of painting and colouring puzzles which are common in magazines for children can be programmed in Comenius Logo easily.

The most attractive activities are those where the pupils can create their own simple games. They are not so perfect as the professional games, but they are their own ones. They contain their own pictures and they behave exactly as wanted. And if they get a new idea how to enhance the game, they can do it! And this is a big challenge for the children. At the beginning of the lesson they did not believe, that at its end they would be able to play with their own tic-tac-toe. And all of them managed!

The pupils have programmed more games and also some other Logo projects and they learned some more basic Logo commands. Not because the teacher just handed the list of new commands to them, but because they needed the new commands to complete the game.

Figure 1 A tic-tac-toe game programmed by pupils of second grade

2.3 Tercia (Third grade)

As we already said, in the third grade the pupils (12-13 year old) decide whether they want to go on with programming or they will become "only" more advanced users of programs and will create some graphical designs for the programmers. Each class is divided to three parts. Sometimes the class splits to two groups of programmers and just one group of users/designers, sometimes just the opposite happens. Until now it did not happen in any class that all pupils wanted to be programmers or all pupils wanted to be users/designers.

All the education is then adopted to the above mentioned division of pupils. While the users/designers group goes on with using some more ready-made programs, the programmers continue with activities which concentrate on creating their own programs. Most of them are again games. We can dispute if it is wise to concentrate on games, but it is a fact that computer games are the most attractive things on computers for many pupils. Of course, we do not create any war games.

When the pupils have enough new knowledge, we sometimes return to projects which they have seen or which they created in the previous year and which can be enhanced by using the new knowledge.

The programmers create analogue clock, teach the turtle to react on the keyboard keystrokes, teach the computer to guess a number, or they create a simple painting program which is even able to paint a mirrored version of our picture. They also create new games and also some educational projects oriented to younger pupils, like a program which develops children’s counting abilities by counting things on the screen.


Figure 2 A game from the third grade - the computer paints the playing field and throws the dice

2.4 Quarta (Fourth grade)

In the fourth grade (ages 13-14) the class remains to be split to users/designers and programmers in the same way as in the previous year. The users/designers go on with getting acquainted with standard PC software. They see programs which they can use in mathematics and physics lessons. They study in more details a text editor and a spreadsheet program, receiving thus some computer literacy. We do not forget to show them also programs written in Comenius Logo which were programmed by their classmates from the programmers group.

The programmers try to develop programs which are closer to professional ones than the programs created in the previous years. For example we created with them a small database program. Of course, Comenius Logo is not specially fitted for such tasks and the program cannot be so perfect as if the students were using specialised database tools. But in this case we wanted to stress some conceptual facts. The data must be represented in some data structures. It must be easy to search and sort the data according to a key. The pupils are now skilled enough to understand the problems which arise from leaving the data unsorted - they have to search trough all the items, and also the problems when more data records have the same key. And this is our intention! This is the knowledge which they will use to solve also other similar problems. They learn general concepts of information technology. It does not matter in which programming language they will implement these ideas after some years.

From more technical point of view, the programmers learn in this year more about recursion and Logo-like data structures (words and lists). At the end most of them will be able to implement a complete project in Comenius Logo based on a description of somebody else or based on their own wish. And thus we reached the goal which was defined at the beginning. They learn to estimate their abilities, correctly define the goal and the sub-goals and they also extend their metacognitive skills (see [2]).

The users/designers know at the end of the year to recognise a problem, they know how the computer can help to solve it and to choose a particular program which is applicable for that problem. They are able to compare the capabilities of two or more computer programs of the same type. They know what are the abilities of programs used in several subjects in school, what kinds of programs their parents use. They also know the fundamentals of text processing and spreadsheet programs. They understand computer software as helpers to solve their own tasks. They know which kind of software is suited for which kind of tasks.

3 A big project for the whole class

3.1 Project specification and distribution of sub-tasks

Now let’s look closer at a bigger project in which the whole class took part. Both the users/designers and programmers worked together to achieve the goal.

As it is usual for such projects, at the beginning the teacher talked to the pupils about the reasons why the project should be created and about its goals. Therefore all pupils were in a classroom without computers and together prepared the working plan.

The reason to start the project was that a teacher of the first grade of the basic school asked us to create a program for her pupils, which should help them to read. Her idea was that the program would show a full screen picture (scene) with more objects on it. At the bottom of the screen the names of the objects would be written. The pupils would have to locate each object on the scene and drag it using the mouse to its name. There should be more scenes with topics from various areas. Each scene should contain quite a lot of objects and the pupil would have to select just some of them. Other things were not specified, so it was our task to think them over.

We divided the tasks. At first we together devised several topics, which may be interesting for first grade pupils. We discussed this in the classroom and several topics were suggested: a farm, near a forest creek where the animals drink, in a classroom, in a supermarket, in the kitchen, in a computer classroom, on a meadow, on the street. The pupils got also the idea that the same program can be used also for foreign languages teaching, just the words at the bottom of the screen must be in a different language. Or even the user could set the language when he or she starts the program.

The designers designed the scenes for each topic and also the small pictures for each object and devised where to put them on the scene. They also design the shapes of buttons which will be used to proceed to the next scene, to the previous scene and to finish the program. The programmers will write the program which will show the scenes with the pictures and the words at the bottom of the screen. Then the program must allow the user to drag the pictures to their names and should also evaluate the actions.

After such a planning session the class was divided to the usual groups. Each group had its task assigned. The designers went to the computer room to paint the scenes and pictures.

3.2 The programming part

Let’s take a closer look to the programmers’ task. They stayed in the room without computers and began to develop the program. The first step was to devise such a representation of our data, which will allow to work with them easily. It was obvious, that the scenes will be bitmaps stored in .bmp files. Comenius Logo can read them easily. Other data to deal with are the pictures of the objects. Those will be turtles with replaced shapes.

In The program we have to fulfil these tasks:

After dividing our task to these sub-tasks, we can return to our data structures and try to write some parts of the program. If there were just one scene, it would be easier. But for more scenes, we need to know the filename of each scene, the pictures needed for that scene (in an image variable) and the names of the pictures. The pupils already know the list data structure, so it is not a big problem. So we will devise some names for the variables containing the data. The list containing the filenames of the scenes will be "scenes. Each scene can have its own number of pictures. Therefore we need another variable to hold the number of pictures for each scene. Its name will be "pictures.on.scene, it will be a list of numbers, the first number says how many pictures are on the first scene, the second number says how many pictures are on the second scene etc. Then we need the pictures themselves. All the pictures will be represented in one variable "pictures. Its value will be an image (in Comenius Logo an image is a sequence of pictures - frames, images are often used for animation purposes, but now we use an image value just as an array of pictures). Some number of first frames will consist of the pictures for the first scene (their number is given in the first member of "pictures.on.scene), next frames will belong to the second scene etc. Next we need the words for each picture. These will be represented by a variable "picture.names. Its value is a list of lists. The first list gives the picture names for the first scene, the second list for the second scene etc. The most complicated data structure is the list of initial co-ordinates for each picture. The variable will be named picture.coordinates and is a list of lists of co-ordinates. For each scene there is a sub-list. Each member of a sub-list is a co-ordinate on the graphic screen, which is in fact a list of two numbers. The last variable in our design is named "current.scene. It holds the number of the scene which is currently shown.

After devising the data structures we began to write Logo procedures for each of the above mentioned tasks. This was done without computers. The teacher suggested the procedure name and described its functionality. The pupils wrote the body of the procedures.

The command begin shows the scene which number is in the "current.scene variable. After loading the screen background from a .bmp file, the turtles for all its pictures must be created (this sub-task will be performed by the command create.pictures) and their names must be written to the bottom of the screen (command write.the.names). The command begin is therefore quite simple. At its end, we call the drag command which will allow to drag the pictures. This command was known to the pupils from preceding activities.

to begin
loadscreen item :current.scene :scenes

The command create.pictures must create several turtles which represent the objects on the screen. The shapes for the turtles are defined by frames from the variable "pictures. The turtles must be created at places, where the designers wanted to have them. The co-ordinates are stored in the variable "picture.coordinates. As :pictures contains all the pictures for all the scenes, we have to compute the number of the first picture which belongs to the current scene. The numbers of pictures on each scene is stored in "pictures.on.scene, so we have to sum these numbers from the first one to the :current.scene - 1 (for this purpose the local variable "beg is used) - this sum is the number of pictures which belongs to the preceding scenes. The variable "coord.list will hold the list of co-ordinates belonging to the current scene. It is simple the :current.scene-th member of "picture.coordinates. The variable "n.rep will hold the number of pictures in the current scene. After this preparation is completed, we can just create the turtles using the maketurtle command.

to create.pictures
let "n.rep item :current.scene :pictures.on.scene
let "beg 0
repeat :current.scene - 1 [let "beg :beg + item repc :pictures.on.scene]
let "coord.list item :current.scene :picture.coordinates
let "n.rep item :current.scene :pictures.on.scene
repeat :n.rep [maketurtle repc ~
( list first first :coord.list last first :coord.list 0 ~
"st "pu item :beg + repc :pictures ) ~
let "coord.list bf :coord.list]

The command write.the.names is really easy. In direct mode we created a turtle called "writer. It will write the names. We also set the pen colour and font for "writer in direct mode. So inside the write.the.names command we extract the names belonging to the current scene from the list "picture.names. Then we shuffle the names and write just the first 5 of them.

to write.the.names
tell "writer
let "pic.list item :current.scene :picture.names
let "pic.list shuffle :pic.list
repeat 5 [ttext first :pic.list setx 130 + xcor let "pic.list bf :pic.list]
tell []

There are two special turtles on the graphics screen: "next and "previous. Both of them have button-like shape which was designed by the designers. When the user clicks to "next then the next scene is shown, similarly if the user clicks to "previous then the previous scene is shown. The actions which take place after clicking the turtles are programmed in commands next.scene and previous.scene respectively. They are very similar to each other, just the second one must react to the situation, when the user is on the first scene.

to next.scene
ask "next [setphase 2 wait 100 setphase 1]
repeat item :current.scene :pictures.on.scene [erturtle repc]
make "current.scene :current.scene + 1
if :current.scene > count :scenes [make "current.scene 1]

Finally, we created the commands start and finish to initialise the project and to finish it (after pressing the ESC key or click the turtle named "finish).

to start
if member? 0 all [erturtle 0]
gs cs
ask [next previous finish][st]
let "current.scene 1

to finish
ask "finish [setphase 2 wait 100 setphase 1]
let "n.pic item :current.scene :pictures.on.scene
repeat :n.pic [erturtle repc]
tell all ht
setbg 7 ss

At the end we will mention three commands which implement the dragging of the pictures. As we already mentioned, these commands were used also in previous activities at that class, so the pupils already knew them. The first of them – the command "drag waits until a key is pressed. Because in Comenius Logo mouse actions are also recognised as pressing special keys (with codes 0, -1 and -2), it tests namely for these values and also for value 27 (the ESC key). The code 0 means that a mouse click was done. Then the program tests if it was on a turtle (testing if touched is not an empty list) and if yes, then start.dragging is called. This command tests for special turtles ("next, "previous and "finish) and if an other turtle is clicked then initialises the dragging process. The value -1 means that the mouse is moved with the left button pressed (this is called dragging), therefore we call the follow command which moves a turtle according to the mouse movement. The code -2 means that the left button of the mouse was released, so our program calls follow and clears the variable "p.

to drag
let "i readkey
if :i = 0 [make "p touched if :p <> [][start.dragging]]
if :i = - 1 [if :p <> [][follow mouse]]
if :i = - 2 [if :p <> [][follow mouse make "p []]]
if :i = 27 [finish throw "toplevel]

The command start.dragging at first tests for special situations - whether the click has not occurred on our special button-like turtles. If not, then a picture was clicked. At first a new maketurtle is invoked for that turtle. It just re-creates the turtle making it the youngest one. This means that when overlapping with other turtles during the dragging process, it will be always on the top of them. Then variables "x and "y are initialised to hold the difference between the point where the mouse was clicked and the hotspot of the turtle. These values will be used during the dragging process.

to start.dragging
if :p = "next [next.scene stop]
if :p = "previous [previous.scene stop]
if :p = "finish [finish throw "toplevel]
let "m mouse
( maketurtle :p ) tell :p
make "x ( first :m ) - xcor
make "y ( last :m ) - ycor

The command follow moves the turtle which name is stored in "p according to the movement of the mouse. There could be some tests added to restrict the user to drag the pictures outside the scene.

to follow :m
setxy ( first :m ) - :x ( last :m ) - :y

3.3 Finalising the project

As most of our projects, also this one is an open project. The user can add a scene, add the pictures for that scene and the corresponding picture names. Therefore the pupils created a small user manual, which summarised which variables can be changed to add scenes and pictures.

4 Conclusion

The project described in part 3 shows how skilled are our 14 years old pupils from the programmers group. Of course, not all of the pupils would be able to write the program alone. But with some support from the teacher all of the pupils in the group took part actively on the program development and afterwards they were able to debug all the commands to a successful final stage.

We think that this kind of IT education in the lower secondary school is a good start to the future education for these children. All the pupils benefit from it regardless of their future professional career. Those pupils, who have chosen the user/designer approach in the third and fourth grade have used many real software packages, have positive experience with use of computers and they know how computers can be used to help them in the future. Those, who have chosen the programming approach have deeper insight to the real software and know that they even could develop some similar but more simple programs. Some of them may be professional software developers in the future.


  1. Blaho, A., Kalas, I., Matusova (Tomcsanyiova), M.: Experimental curriculum of informatics for 11 year old children. In: Tinsley, J. D. and Weert, T. J. (eds.): World Conference on Computers in Education VI, 1995, pp. 829-841
  2. Harel, I. and Papert, S.: Software design as a learning environment. In: Harel, I. (ed.): Constructionist Learning. Cambridge, MA, 1990
  3. Kalas, I. and Blaho, A.: Not All Birds Are Turtles. Developing Teaching/Learning Environments in Initial Teacher Training as Comenius University. In: Collis, B., Nikolova, I. and Martcheva, K. (eds.): Information Technologies in Teacher Education, UNESCO publishing, 1995, pp. 222-235