Public portfolio - Lauri Malmi Updated August 2008
Contents
- Introduction
- Pedagogical training
- Teaching experience
- Prepared learning resources
- Evaluations
- Other activities related to teaching and evaluations
- My view of teaching and learning
- Examples of course implementations
Introduction
This document summarizes my teaching merits. I have been teaching
and organizing computer science courses at Helsinki University of
Technology
(TKK) since 1986, except for 3 years period in 1992-1995 when I was
preparing
my doctoral thesis. For all this time, I have been involved in
teaching
introductory programming courses and data structures and algorithms,
even
though I have taught a number a advanced courses, as well. During
this time I have put a lot of effort in developing new teaching and
working
methods, and building software to assist learning on large courses. At
TKK, the sizes of introductory programming courses range from 150 till
more than 500 students per course per year. As the human teaching
resources are very limited, it has been highly important to develop
activating
working methods and automatic software to provide enough feedback for
students
on their work. After year 2000 this development work has more and
more turned to research that falls into the field Computing Education
Research.
This is beneficial for education because we can immediately apply our
research
contributions to develop our courses. On the other hand, the
large
courses provide excellent possibilities to test new tools and
approaches
as well as evaluate them. Our contributions have been
recognized.
Finnish Higher Education Evaluation Council has twice chosen my unit
"Basic
Computing Education unit" at TKK as a national Center of Excellence in
Education (2001-2003 and 2004-2006).
This document is structured into two parts. Sections 1-5 list
mostly factual information about my experience as a teacher, and the
course
material I have prepared. A highly important part here is the
automatic
assessment and visualization software for supporting programming
education
that has been implemented in my COMPSER research group.
The software is only listed here, and my reserch work is described in a
separate document. The latter part of this document includes my
vision
about learning and teaching and a few examples of implementing the
vision.
1. Pedagogical training
I have taken the following courses on pedagogics of teaching in a
university.
- Course on pedagogy in university education, organized by
Education Aid
committee of Helsinki University of Technology
(opetuspalvelutoimikunnan
järjestämä korkeakoulupedagogiikan kurssi), in 1986-87,
3 study weeks. The course dealt with the cognitive theory of learning.
- Course in communication and interaction in teaching and learning,
organized
by Education Support Committee of Helsinki University of Technology
(opetuspalvelutoimikunnan
järjestämä kurssi: Viestintä ja vuorovaikutus
opetuksessa
ja oppimisessa), in 1987, 1.5 old credits. The course dealt with
various
communication methods, and how to structure and give a good
presentation.
- Workshop of pedagogical expertise in teaching technological
sciences,
organized
University of Jyväskylä and University of Oulu
(teknistieteellisen
pedagogisen asiantuntijuuden workshop), in 1997-1998, 6 old credits.
The
course concentrated on methods how to improve scientific thinking of
students
and how to develop and evaluate own teaching. My target course
for development was Data structures and algorithms.
- Pedagogical courses for the teaching staff of TKK
(YOOP-koulutus),
15 old credits, in 1999-2000. This pedagogical program included
introduction to basic educational theories, teaching and interaction
methods in lectures and web-based education, designing and evaluating
education, a personal project for developing one's own course(s) and
preparing a public portfolio. My target course was an introductory
programming course for Information Networks Curriculum. During the
program I took a course of Problem-Based Learning method, which I
applied on the target course (for more information, see publications
A11, B33 and E3).
Note. One old credit corresponds to 40 hours of work, and is about
1.5 ECTS credits.
In addition, I have three times given courses for the TKK faculty
members on academic portfolio work
and how to prepare a public portfolio.
2. Teaching experience
Here are included only those facts about my working career, which are
related
to teaching. My other working experience is included in my Curriculum
vitae.
2.1 Positions as a teacher
When I worked in the Computing Center I gave several one or two-day
courses for researchers on using the presentation graphics programs and
I also gave them personal advice in their problems.
In the Laboratory of Information Processing Science (current name:
Laboratory of Software Technology), I have worked as
a lecturer (assistant professor) 9 years, full time teacher (4 months)
and acting associate professor (6 months) or acting professor (2
years).
In November 2001 I was appointed as a professor (field: Computer
Science and Engineering, especially
Education methods of basic programming) for a five year period. The
period was extended till fall 2007. In December 2008 I was appointed
as a tenured professor (field: Modelling, analysis and visualization
of programs).
2.2 List of courses I have given and my role as the teacher
The extent of the courses are given in old credits.
Courses related to introductory
programming (1st - 2nd year studies)
- Basic course of programming (Pascal), (2-3 old credits), in years
1986-1991.
- Basic course of programming in C language, (5 old credits), in
years
1995-1997
- Basic course of programming in Java (7.5 old credits), a PBL
version in
years 1999-2000 (co-teachers: Esko Nuutila and Seppo Törmä)
- Basic course of programming in Java (3 old credits), 2004
(co-teacher:
Otto Seppälä)
- Intermediate course in programming (Java) (3 old credits), 2004
(co-teacher: Otto Seppälä)
- Intermediate course in programming (C) (5 ECTS credits), 2006
- C language, (1.5 old credits), in years 1991 and 1992
- Fortran language, (1.5 old credits), in years 1991 and 1992
- Data structures and algorithms, (3-5 old credits), in years
1990-1992
and
1997-2001, 2003, 2005 (since 1999 two parallel versions, one for CS
majors
and another for CS minors), since 2003 co-teacher: Ari Korhonen
Advanced courses for 3rd-4th year
students.
- Programming laboratory course (2-5 old credits), in 1999-2001,
2003,
2005-2006
- Course in computer graphics (3 old credits), in years 1987-1988.
- Advanced course in computer graphics (2 old credits), 1988.
- Course in interactive computing, (2 old credits), 1989
Post-graduate seminars and other doctoral education
- Post-graduate seminar on data structures and algorithms in
database
systems,
(5 old credits), 1992.
- Advanced Visual Interfaces (2-6 old credits), 2003 (co-teacher:
Ari
Korhonen)
- Research seminar in learning programming (2-3 old credits), 2005
- Doctoral seminar on Adaptive Learning Environments
(5 ECTS credits, co-teacher: Ari Korhonen), 2006
- Doctoral seminar on Computer Science Learning Environments (5 ECTS, co-teacher, Ari Korhonen), 2008
- I have been involved in organizing and designing doctoral research methods courses in computing education
research:
- Methods and Results in Computing Education Research, 2007
- Quantitative Methods in Computing Education Research, 2008
Other courses
I have given several times short versions of programming courses and
the course of data structures and algorithms for classes of students
working
in the industry.
My role in the courses
In all listed courses, I have been the teacher in charge taking
care of lectures and course material. As most introductory
courses
have had several hundreds of students yearly, I have also
supervised
a group of 3 to 15 part time teaching assistants (typically 2nd-3rd
year
students) who have instructed students in closed labs and evaluated
course
projects and some examinations under my instructions. For largest
courses, there has also been a part time chief assistant taking care of
course organization, implementation of assignments on some automatic
assessment
tool and web pages.
For some courses, as listed above, the course has been designed and
given jointly with some of my colleagues. This has been highly
fruitful
form of collaboration in developing the courses. We have
reflected
together, how the course succeeded and should be improved in the
future.
2.3 Supervised theses
Doctoral theses
- Ari Korhonen, Visual Algorithm Simulation, 2003
- Sami Surakka, Needs Assessment of Software Systems Graduates, 2005
- The thesis was cross-disciplinary. The instructor was professor
Veijo
Meisalo
from University of Helsinki, Faculty of Educational Sciences
Both theses above were prepared in my own research
group.
Licentiate's theses
- Ari Korhonen, Algorithm Animation and Simulation, 2000.
- Ali Hosseini,Framework for M-learning System Based on Education
Components
- In co-operation with professor (pro tem) Marko Nieminen, 2004
- Päivi Kinnunen, Interaction and Experiences in PBL groups of
University
Students
- This degree was granted from University
of Helsinki, Faculty of Education. The supervisor was prof. Juhani Hytönen, and
I was the instructor.
- Ville Karavirta, Visualizer's Point of View to Algorithm
Animation, 2008
Korhonen's, Kinnunen's and Karavirta's theses were prepared in my
own research group.
Master's theses
I have supervised 33 MSc theses and instructed 4 theses (before I
had
professorship). Fifteen out of these have been
completed
in my own research group, including the following:
- Rosi Keskinen, Computer-Aided Instruction at Helsinki University
of
Technology,
1992
- Asko Eerola, Kelvin - Style Analysis Tool for C programs, 1995
- Kenneth Oksanen, Memory Reference Locality in Binary Search
Trees, 1995
- Ari Korhonen, World Wide Web in
Computer-Aided
Learning of Algorithms and Data Structures, 1997
- Jan Lönnberg, Visual Software Testing, 2003
- Otto Seppälä, Visual Java Debugger for Computer Science
Education,
2003
- Panu Silvasti, Collecting Statistical Data of Usage of
Algorithmic
Exercise
Applets, 2003
- Petteri Torvinen, Statistical Analysis of Usage of Algorithmic
Exercise
Applets, 2004
- Markku Rontu, Visual Queries for a Student Information System,
2004
- Juha Sorva, Ox - A Tool For Testing
Java
Exercises, 2005
- Ville Karavirta, XAAL - Extensible Algorithm Animation Language,
2005
- Jussi Nikander, Managing Automatically Assessed Exercises in
TRAKLA2,
2005
- Petri Ihantola, Automatic Test Data Generation for Programming
Exercises with Symbolic Execution and Java Path Finder, 2006
- Jouni Karppinen, Data Warehouse for programming courses, 2007
- Ahmad Taherkhani, Static Program Analysis for
Recognizing Sorting Algorithms, 2008
For
a number of thesis (Karavirta, Lönnberg, Nikander, Rontu,
Silvasti,
Torvinen, Ihantola) the other instructor has been Ari Korhonen.
All other theses have been prepared in a number
of companies.
The topics here have varied a lot.
- Kristian Ukkonen, UMTS Network Simulator Implementation Using
Parallel and Distributed Computing
to Optimize Runtime, 2001
- Teemu Halmu, Simulation
of
Real-Time Properties of the Dental Unit from the Viewpoint of the
Product
Development, 2001
- Jari Nopanen, Applicability of Open
Source Operating System
as a Platform for Standard Enterprise Resource Planning Application,
2001
- Yu Zhang, Java Performance Research, 2002
- Kaarlo Eno, The Use of a Simulator in Teaching Engineering
at Vocational Schools, 2004
- Mikko Soikkeli, Terminal Service for
Electronic Documents, 2005
- Leo Wikström, Reengineering
Process:
Tool and Method Support, 2005
- Simo Ojanen, Mobile Data Communications
in an
RFID Based Supply
Chain Asset Management System, 2005
- Aki Vainio, Measurement Visualization
Algorithms, 2005
- Samuli Lehto, Performance Management
in
the J2EE-environment
of Tekes, 2005
- Samuli Kärkkäinen, Form Description Languages for
Current Web Browsers, 2005
- Liisa Selkäinaho, Collection and Analysis of Usage Data in a
Massively Multiplayer Online
Game, 2006
- Ilari Lähteenmäki, Interface
Definition and Techonology Selection
for an Integration of a Software System, 2006
- Mikko Veijonen, Towards Service-oriented
Architecture, 2006
- Pekka Hirvonen, Hierarchical,
requirement-Driven Approach for Automating Module Testing of Graphical
User Interfaces, 2006
- 7 other works in 2006-2008
Currently supervising 8 doctoral
theses and 2 MSc theses in my own group and 8 MSc thesis projects
carried out elsewhere.
About my role in the thesis projects
My role during the thesis projects depends on whether the
work is carried out in my own reseach group or whether it is carried
out in external companies or organizations, which is very
common at TKK. In all cases I supervise how the thesis report is
written, which includes defining
the structure of the thesis, formulation of research questions,
discussion
of relevant literature, selection of applied methodology and reporting
and analysing the results. For my own group members I typically
have weekly or biweekly informal meetings with the student where we
discuss current issues and problems in the thesis, and I comment the
manuscript. The need for instruction depends, however, heavily on
the student. In external thesis projects there is typically a
local instructor at the company/organization who instructs in technical
details and guides the working process locally. In these cases I
typically meet the student 4-6 times during the project and give
comments on the report.
Since 2003 Dr. Ari Korhonen has co-instructed most theses in my
group, typically giving more feedback on technical solutions.
2.4 Other assessed theses
Dissertation assessment
- Anders
Berglund, Learning Computer Systems in a Distributed Project Course -
The What, Why, How and Where. Member of examination committee, Uppsala
University, Sweden, 2005.
- Kirsti Ala-Mutka, Automatic Assessment Tools in Learning and
Teaching Programming. Tampere University of Technology, Finland.
Pre-examiner and opponent, 2005.
Assessment of Licentiate’s theses
- Päivi Hurri, Identifying Similarity in Hypertext Documents,
University of Helsinki, 2001.
- Anu Moisio, Implementing ICT-supported Training in Organizations
– a Service and Relationship Management View, Helsinki University of
Technology, 2005.
3. Prepared learning resources
3.1 Book
I wrote a text book of programming in Pascal (publication G1,
433 pages) in 1988. The key motivation for this task was that at that
time
almost all available text books written in Finnish were more or less
language
manuals. I wanted to present a different pedagogical view of teaching
programming
and Pascal. Thus I applied cognitive theory of learning in this book
trying
to give a clear motivation for different programming structures, to
orientate
the students to the basic problems and principles behind computer
programs
and to make them apply their skills to solving problems. The book was
sold
over 10000 copies in Finland and it was adopted in a large number of
universities
and polytechnics as the basic programming text book in
later
80's and early 90's. When Pascal has been replaced by C, C++ or Java as
the basic programming language, the book is not used any more.
3.2 Static learning resources
Static resources include web pages and printed material delivered to
the students.
Course web pages typically
include a number of topics.
- Course description
- Learning goals
- Requirements
- Course material
- Learning tasks and instructions
- Contact information
- See, for example,
- Intermediate
course in programming T2, spring 2006, for CS majors ,
(http://www.cs.hut.fi/Opinnot/T-106.3100/K2006/index.shtml)
- Laboratory
of Software Technology spring 2006, for CS majors,
(http://www.cs.hut.fi/Opinnot/T-106.4000/index.html)
- Introduction
to
Programming
T1, fall 2004, for CS majors,
(http://www.cs.hut.fi/Studies/T-93.211/)
- Lecture
material or data structures and algorithms course, spring 2003,
both
for CS majors and minors
(http://www.cs.hut.fi/Opinnot/T-106.250/k2003/luennot.html, in Finnish)
- Note:
- Complete versions are only in Finnish. The english
pages
summarize
the most important issues due to small number of foreign students on
the
course.
- The pages are partially prepared by my co-teachers or the
chief
assistant.
In these cases, my contribution includes course requirements, parts of
course material and parts of instructions of learning tasks.
For data structures and algorithms we have developed an electronic
textbook (in Finnish, http://trakla.cs.hut.fi/ebook_fi/index.html)
covering most topics on the course. The material includes descriptions
of the algorithms, facts about their performance and a number of
algorithm
animations. See especially graph
algorithms part
(http://trakla.cs.hut.fi/ebook_fi/ebook-Graafit_l_verkot.html)
for the animations. They were prepared with Flash by Miika
Korhonen
under my and Ari Korhonen's instructions. I have written most
parts
of the following chapters: basic concepts, linear structures, tree
structures,
dictionaries
and graph algorithms, and edited some parts of the others.
3.3 Educational software
The basic courses that I have given at TKK have been very large
courses,
each having 200 to 1200 students per year. Because of the lack of
personnel resources I have put a lot of effort in developing various
software
tools to support teaching and evaluation of student work. The
tools
include:
- TRAKLA (in production use 1991-2003)
- This was an email-based system for automatic assessment of
algorithm
simulation
exercises. A typical such exercise is "Insert the following keys
X D F O W P E A I L T one by one into an initially empty AVL
tree.
Show the intermediate phases of the tree". In TRAKLA, the
exercise
was sent to students by email and the solutions were returned by email
to TRAKLA server in a predefined textual format. Highlights of
the
system include:
- There were some 25 exercises covering basic structures,
sorting,
searching
and graph algorithms and priority queues.
- All assignments were personally tailored (initial set of keys
to be
inserted
or sorted was randomly tailored to each student)
- The submitted solution was compared to model solution
generated by a
real
implemented algorithm and immediate feedback was given, how well they
compared
to each other (points).
- A small number of resubmisions was allowed for the same task.
- Personal model solutions were sent to students after the
deadline of
submissions
was over.
- The system was implemented within a student project (Jarkko
Hietaniemi,
Juha Hyvönen, Elina Juvonen, Jari Nopanen) that I supervised in
1990-1991.
The system was originally my idea, and I mostly contributed to
designing
the exercises and the system functionality.
- For more information, see publications B6 and D7.
- WWW-TRAKLA (in production use 1997-2003)
- This system added a graphical front-end to submitting the
solutions.
The front-end allowed graphical construction of the solution in terms
of
GUI operations, and converted the graphical representation to textual
format
that was sent to TRAKLA server.
- An initial version of this was called TRAKLA-Edit and was
implemented
for
Macintosh by Juha Hyvönen (1992-1994).
- Ari Korhonen re-implemented the concept for WWW in Java in his
MSc
thesis
that I supervised.
- For more information, see publications B6.
- TRAKLA2 (in production use 2003-)
- TRAKLA2 is implemented using the Matrix application framework
that Ari
Korhonen designed in his Licentiate's and doctoral theses that I
supervised.
It extends the properties of WWW-TRAKLA in several ways.
- More exercises of various types and topics
- Personalization of each problem instance (initial data is
changed
always
when the exercise is restarted)
- Dynamic model solution (in terms of algorithm animation) is
provided
for
each problem instance.
- Unlimited number of allowed submissions for the same exercise
- Extensive logging of user operation
- Several people have contributed to TRAKLA2
- Ari Korhonen has designed parts of its architecture
- Panu Silvasti has implemented the data logging feature in his
MSc
thesis
under my supervision.
- Jussi Nikander has implemented the teacher's user interface
in his MSc
thesis under my supervision
- Panu Silvasti, Otto Seppälä, Harri Salonen,Petri
Ihantola and
Ville Karavirta have implemented a number of exercises.
- Pekka Mård has instructed the user interface design.
- My contribution has mostly been in designing new exercises
and writing
their manuscripts as well as giving feedback on their user interface.
- For more information, see publications A6, A7, B9, B12, B14,
D11 and
URL: http://www.cs.hut.fi/Research/TRAKLA2/
- MatrixPro (in production use 2003-)
- MatrixPro is a teacher's tool for visual algorithm
simulation. It
allows the teacher freely to demonstrate the behavior of a large number
of data structures in terms of visual algorithm simulation.
- The tool was implemented by Ville Karavirta.
- I contributed to the system by preparing the specifications,
what is
needed
by the teacher, and giving feedback on its user interface.
- For more information, see publication B18 and URL:
http://www.cs.hut.fi/Research/MatrixPro/
- Ceilidh (in production use 1994-)
- Ceilidh is an automatic assessment tool for programming
exercises.
It was originally implemented in University of Nottigham, UK. I
adopted
it for our introduction to programming course in C in 1994.
- The tool needed a lot of local modifications and fixes.
Many
parts
of it has been totally rewritten by several course assistants in
introductory
programming courses.
- My role has been in designing the exercises and the policy of
using the
tool on my own courses. As the results have been positive, the tool has
been used in several other programming courses in my laboratory
(Fortran,
Java)
- Ox (in production use 2004-)
- Ox is a Java testing tool that gives automatic feedback on
execution of
Java methods in such exercises where students have to implement a
specified
interface or single methods.
- Ox was implemented by Juha Sorva in his MSc thesis under my
supervision.
- For more information, see publication B25.
- Visual debugger for Java (in test use in 2004)
- This tool visualizes program execution and object structures in
memory.
It is designed for introductory programming education.
- The tool was implemented by Otto Seppälä in his MSc
thesis
under
my supervision. However, it reached only prototype level and was
not taken into wider use, as Seppälä's doctoral research
concerns
other topics.
- For more information, see (Seppälä, 2004)
- Scheme-Robo (in production use 1999-2003)
- For CS majors the introductory programming course used Scheme
language.
The courses teacher's did not want to use Ceilidh, but implemented a
new
system that allowed more versatile analysis of submitted programs.
- This tool was implemented by Riku Saikkonen and Timo
Lilja. I did
not contribute to this tool personally. However, it used TRAKLA
server
for book keeping and was obviously inspired by our previous experiences
with TRAKLA and Ceilidh.
- For more information, see publication B8.
4. Evaluations
4.1 Personal evaluations
The Finnish Society of Electronics Engineers gave me the EEE
award
(Excellent Education in Electronics), 21.3.2000.
The Study committee of TKK nominated me as the teacher of the
year
in the university in 1999.
4.2 Center of Excellence in Education
The unit in which I work (a part of the Laboratory of Software
Technology)
gives
basic computing courses at TKK. It has been selected twice (for periods
2001-2003
and 2004-2006) as a Center of Excellence in Education in Finland.
Selection
has been carried out by FINHEEC, Finnish Higher Education Evaluation
Council. Before this the unit was a local Center of Excellence in
Education at TKK for the period 1999-2000.
I have been coordinating and supervising the work in the unit since
late 1990's.
5. Other activities related to teaching and evaluations
5.1 Coordination of introductory programming
Since 1999 I have been formally coordinating the basic programming
courses at the Laboratory of Software Technology, and since 2008
in the Department of Computer Science and Engineering. However, in practice
I have been carrying out this since early 1990's.
This
work includes the following tasks, all of which, of course, in
collaboration
with my teacher colleagues:
- Defining the courses, their syllabi and interfaces to each other
- Coordinating the work of teachers in the courses
- Following the quality of education
- Developing the teaching and assessment methods
In 1999-2002 I also coordinated of software tools courses (Word, Excel,
web, ...).
5.2 Activities in a larger scope in education
During my career as a teacher I have acted as a member of several
committees
related to education in computer science. The translations are my own,
since typically internal committees work only in Finnish.
Administration
committees
- Member of Committee of Institute of Information Technology
(Tietojenkäsittelytekniikan
laitosneuvosto), 1988-1990
- Member of Council of Department of Computer Science and
Engineering
(Tietotekniikan
osastoneuvosto), 1999
Committees for developing education
- Member of Committee of Degree Programme of Computer Science and
Engineering
(Tietotekniikan osaston koulutusohjelmatoimikunta), 1990-1992
- Member of Committee of Development of Education at TKK (Opetuksen
kehittämistoimikunta),
1991-1993
- Member of Committee of Educational Merits at TKK (Opetuksen
meritointityöryhmä),
1998
- Chairman of Committee of Promoting Education in Department of
Computer
Science and Engineering (Opetuksen kehittämistoimikunta,
informal),
1999-2002.
- Chairman of Committee of Degree Programme of Computer Science and
Engineering
(Tietotekniikan osaston koulutusohjelmatoimikunta), 2003-2004
- Member of Committee of Degree Programme of Computer Science and
Engineering
(Tietotekniikan osaston koulutusohjelmatoimikunta), 2005-
Committes for implementing the
Bologna Process at TKK
- Member of Committee or Renewal of the Degree Programme of
Computer
Science
and Engineering , 2002-2005
- Member of Committee of Basic studies at TKK, 2004-2005
Committees for teacher education at
TKK
- Member of Committee of Pedagogical Training of Teachers of TKK
(TKK:n
opettajien
pedagogista koulutusta suunnitteleva työryhmä), 1999-2005.
- Member of Board of Education Support Unit at TKK, 2006-
The Committee of Degree Programme of Computer Science
and Engineering prepares all decisions of the curriculum structure and
requirements, and gives instructions to many administrational processes
related to the curriculum. The Committee of Educational Merits at TKK
prepared
the instructions, how teaching merits should be reported and evaluted
when
people are nominated to teacher positions at TKK. One important
consequence
of this was launching the pedagogical program (15 old credits) for
teachers
since 1999. I have been a member of the committee supervising this
program
since 1999.
I have also coordinated the Bologna process of renewing the advanced
courses of Software Systems major.
In 2002 I was in the organizing committee of IPN Seminar on Staff
and Faculty Development in Scandinavia. For more information, see
publications B16 and 17 and proceedings F1.
6. About learning and teaching
In this section I present my understanding of what learning is, and
what
are my aims in my work as a teacher.
Learning is a highly complex process, where a student gathers and
processes
new information and gradually builds new cognitive structures and/or
modifies
his/her existing cognitive structures. These structures are
called
mental models (Norman,1983). The goal of learning is to
construct
viable
mental models that allow the learner to apply the knowledge
successfully,
for example, to explain phenomena or solve real-life problems.
Mental
models are personal. Often they are not accurate and complete models of
reality. However, they may be tuned to better fit the reality by
testing them and tuning them based on observations and feedback.
This model obviously has similar features as constructivism
(Glaserfeld, 1989).
However, I do not accept the philosophical implications of Glaserfeld's
theory. My understanding is that there is objective world around
us and we can say things that are true.
Teacher's main role is to design the learning process for
students
and give guidance and feedback for them during their studies. In
practice this means several things.
- A major effort is designing the course syllabus, what information
the
students
should grasp and what skills they should train during their
learning.
This also implies setting priorities, i.e, deciding on what is the most
essential information, what is important and what is less
important.
For each topic, the teacher should define how deep understanding should
be achieved during the course. Here, for example, Bloom's
taxonomy
(Bloom, 1956) is a useful aid for setting up goals.
- Teacher should define all learning tasks for the course, and how
they
relate
to the whole learning process. Learning tasks may include, for
example,
reading textbook sections, solving exercises, following lectures, team
work, etc. One useful model for this design work is the
cognitive
learning process (Engeström, 1986) including several phases
(motivation
- orientation - internalization - externalization - evaluation -
control).
- In practice, it is impossible to design an ideal learning process
that
would fit to all students. They have different learning styles
and
preferences. Therefore an important point is to include
enough variation
to the course contents and learning tasks. The same topics can be
presented in various ways using, for example, textual and visual
explanations
or discussing the issue from different points of view.
- The learning tasks should include such exercises / demonstrations
/
quizzes
etc. which force students to test their mental models. The
feedback
should be designed so that it supports active thinking and
reflection.
Thus, presenting plain model solutions is not often the best feedback
for
learning.
- Teacher must design appropriate forms of assessment, i.e., what
is the
role of formative assessment and what kind of summative assessment is
needed.
Some practical guidelines supporting the overall goals are:
- Students have to be active during the whole course. By this I
mean that
the courses should be arranged so that students must solve and submit
exercises
during the whole course. Some students are able to grasp the course
contents
by reading to the exam only, but most of them need exercising. I
believe
that compulsory exercises are beneficial. However, we should not
overload
students with compulsory work. It is better to set a reasonable lower
limit
compulsory, and give bonus to those who work more. We have applied this
approach in the data structures and algorithms course, T-106.250 for a
long time, and our research has pointed out the efficiency of such
arrangements. See publications A13 and B11.
- Students should get feedback from their assignments. I do not
believe
that
showing model solutions to students' assignments is a good method,
since
many of them do not understand where they failed in their own solution,
if they did. Personal feedback is much better. However, this is not
feasible
on large courses without automation due to the huge need of human
teaching
resources. Therefore we have put a lot of effort in developing
automatic
assessment software. For more information, see Section 3.3 above.
- Co-operation in groups is beneficial. We have implemented an
introductory
programming course using the Problem Based Learning method (especially
the seven step method), in which group working is very important. Our
experience
since 1999 implies that group work is beneficial in problem solving,
program
design and conceptual analysis of the problem domain. In addition, it
provides
a social environment that reduces students' anxiety when encountering
difficult topics. However, this is not due to group work only. An
important
issue is to set personal goals, as well, so that weaker students do not
fall into side track in the group. For more information, see
publications A11 and B31.
The
vision above is not easy to achieve. In Section 7 I give two
examples,
how I have tried to implement it in actual education.
7. Example courses
7.1 Data structures and algorithms (DSA)
This course is a second course of programming at TKK. The general
aim is to give a broad overview of data structures and algorithms
covering topics such as basic data structures, priority queues, sorting
algorithms, search trees, hashing methods, and graph algorithms. The
main learning goals is to understand how they work and where are they
applicable.
A number of highlights of the course:
- Lectures cover issues on different Bloom levels, as follows:
- Introduction of important concepts and explaining their working
(levels 1-2), and examples of their implementation (level 3)
- Analysis of a number of algorithms (level 4)
- Examples of solving practical problems with basic and combined
algorithms (level 5)
- Discussion on the pros and cons of algorithms solving the same
task (level 6)
- Lectures are just one source of information for the
students. Other sources include textbook, course on-line book in
the web, and the TRAKLA2 tool. The same information is presented
in various ways (orally in lectures, written in course material,
visually in static figures and animations).
- Algorithm simulation exercises using
TRAKLA2 are used to train understanding of basic algorithms covered in
the course.
- In the design exercise
(compulsory for CS minors, voluntary for CS majors) students have to
apply their acquired
knowledge to design solutions to realistic problems by combining or
modifying the basic algorithms they have learned. They work in small
teams, where they have to present a design (data structures and
algorithm needed) for the target application, and argue the pros and
cons of their solutions. Peer review is used to give more
feedback for the teams, and to learn critical assessment and reflection
of one's own work. After getting the feedback, students can
revise their
solution before final assessment is carried out by course staff.
- CS majors solve analytical
exercises in which they analyze given algorithms and construct
new algorithms using pseudocode.
- These learning tasks work
on different Bloom levels.
- The algorithm simulation exercises using TRAKLA2 train their
skills on levels 2 and 3 (understanding how algorithms work and
applying them to solve a problem).
- The design exercise (see below) trains skills on levels 3-6
(analysing a
problem, applying their knowledge on basic algorithms to solve it,
synthesizing new algorithms and data structures for solving the
problem, and evaluating both their own result and their peer's results).
- Analytical exercises (see below) work similarily on levels 3-5.
- Examination controls learning on all levels. Thus assignment
may include:
- Definition of concepts and algorithms
- Simulation of given algorithms on a given set of data
- Analysis of given algorithms
- Construction of new algorithms
- Comparison of a number of algorithms
- The course discusses the topics on a conceptual level instead of
implementation level, i.e., the focus is on the principles of the
working of algorithms instead on their implementation in a programming
language. Such an approach has also been proposed by Aharoni [1].
In practice, this is carried out, as follows:
- During the lectures the teacher demonstrates the working of
algorithms using conceptual visualizations (which act as conceptual
models of the topic to be learned) either using static figures or
MatrixPro demonstration tool.
- The students are given simple assignments during the lecture
where they manipulate (on paper and pencil) a simple structure
according to the algorithm that the teacher has just explained.
The teacher answers any comments and questions and finally presents the
model solution.
- Students are solving similar algorithm
simulation assignments, but with somewhat larger initial
data, with the TRAKLA2 environment. Each student gets
personal initial data and after submitting the solution receives
immediate feedback and a dynamic model solution. After studying
the feedback and model solution they can restart the exercise with new
initial data, resubmit, get feedback, etc. The tool thus supports testing their
mental model of the operation of the algorithm. The
feedback, however, is not detailed - thus they need to think themselves
to understand what went wrong, if any.
- Algorithm code is visible in the assignment, and the students
can use it to check how they should proceed when solving the assignment.
- Implementation exercises including writing program code are
purposefully postponed to later courses since the course extent would
not allow time for many implementation exercises.
- Additional learning goals include
- Exercise in evalution and argumentation in the peer review
phase of the design. It is important to review different
solutions to the same task and give constructive feedback on it.
This process also teaches students to argue better, what are the key
points and contributions in their own solution.
- Working in teams in the design exercise.
- For more information, see publication B32.
7.2 Laboratory of Software Techniques
This course is an advanced course for CS majors taking Software
Techniques
as their specialization. The course has two major goals:
- It gives basic understanding on experimental research work.
This is implemented as an experimental algorithm research task where
students compare the perfomance of a number of different algorithms
solving the same problem, e.g, sorting or string searching
algorithms. Instead of algorithms they can also evaluate the
performance of some software tools such as databases on some
transaction loads.
- It gives an experience of the process of writing and publishing a
scientific paper.
To implement these goals the course includes the following phases.
- Literature survey.
Students search relevant literature for the given topic and write a
summary report where they present the working of algorithms, analytic
and experimental results they have found.
- Experimental design plan.
They prepare a plan, how they are going to compare the performance of
the target algorithms. This includes identification of parameters
and factors which they consider interesting and arguing their
significance for the task. They might look for real data to use
as input load for the tests, or they might model the test loads using
parameters and factors only. The design is discussed with the
course staff to give feedback on it.
- Implementation and
experimentation. In this phase students implement all
algorithms and other necessary test code. They carry out the
experiments and apply some statistical methods to analyse the
reliability of their results.
- Writing the report.
The literature part, test plan and the results and their analysis, and
final conclusions are written as an article, typically 10-20 pages.
- Peer review. In
this phase students review the works of 2-3 of their peer groups and
give feedback on their works. The guidelines for the review are
similar as used in conferences and journals.
- Camera-ready report.
Based on the feedback the students prepare the final version of the
article, which is assessed by course staff.
- Mini conference.
Best papers are selected by course staff, and the students give a 20
minute conference presentation for their peers. Typically a number of
other faculty members also participate the conference as the
audience. The course staff (typically doctoral students or
students at the end of their MSc studies) works as a program committee
and discusses the pros and cons of each paper. All papers are
reviewed by two people.
As a whole the students get a good hands-on experience on the
challenges of experimental work and how scientific community works.
For more information, see publication B32.
References
/Bloom, 1956/ B. S. Bloom, Taxonomy of Educational Objectives, Handbook
1: Cognitive Domain, Addison-Wesley, 1956.
/Engeström, 1986/. Y. Engeström. Perustietoa
opetuksesta. Valtion painatuskeskus, 1982. (in Finnish)
/Glaserfeldt, 1989/. E. Glaserfeldt, Cognition, Construction of
Knowledge, and Teaching. Synthese, vol 80, 1989, pp. 121-140.
/Norman, 1983/. D.A. Norman. Some Observations on Mental Models.
In: Mental models. Lawrence Erlbaum Associates, 1983, pp. 7-14.
/Seppälä, 2004/. O. Seppälä, Program state
visualization tool for teaching CS1. Proceedings of Third Program
Visualization Workshop. Research Report
CS-RR-407, Department of Computer Science, The University of Warwick,
UK, 2004. pp. 118-125.