Could We Be Role Models in
teams, and especially when they are learning basic concepts and skills. This, on the
other hand, helps teachers to enrich the
face-to-face time with students, because
there is less need for using time to lecture
the basics. Instead, more time can be used
to discuss advanced content, problem
solving, design, etc.
Finally, during the decades when we
computer scientists have used online and
blended learning, we have gained quite a
lot of tacit knowledge about which methods and practices work and which do not.
This is also something we can share with
our colleagues in other fields. Moreover,
much of such knowledge has its origin in
research in computing education, which
can offer evidence for what kinds of tools
are beneficial and what their impact is.
1. Aalto Online Learning; https://onlinelearning.aalto.fi/.
Accessed 2019 Jun 27.
2. Aalto University, CS-A1110 Programming 1; https://
plus.cs.hut.fi/o1/2018/. Accessed 2019 Jun 27.
3. Center for Digital Education CEDE, https://moocs.
epfl.ch/about-us/. Accessed 2019 Jun 27.
4. CSLearning4U; http://web.eecs.umich.edu/~mjguz/
csl/ home.cc.gatech.edu/csl/28. Accessed 2019 Jun 27.
5. ECAR Study of Faculty and Information
Technology, 2017; https://library.educause.edu/
information-technology-2017. Accessed 2019 Jun 27.
6. EDUCAUSE: 2019 Key Issues in Teaching and
key-issues-in-teaching-and-learning. Accessed 2019
7. HarwardX; https://harvardx.harvard.edu/. Accessed
2019 Jun 27.
8. Kauppinen, T., Malmi, L., Aalto Online Learning - a
pathway to reforming education at the Aalto
University. Proceedings of EUNIS 2017 conference,
2017, pp. 212–221.
9. Malmi, L., Kauppinen, T., Keltikangas, K., Kinnunen, P.;
Transforming the learning and educational culture
at a university. Proceedings of 46th SEFI Annual
Conference 2018, pp. 1040–1047.
10. MI T Open learning; https://openlearning.mit.edu/.
Accessed 2019 Jun 27.
11. Stanford | Online; https://online.stanford.edu/.
Accessed 2019 Jun 27.
12. TU Delft, Online course development process;
https://onlinelearninghub.tudelft.nl. Accessed 2019
13. Web Courseworks, 2016 eLearning Predictions –
Hype Curve; https://webcourseworks.com/elearning-
predictions-hype-curve-2016/. Accessed 2019 Jun 27.
Department of Computer Science
P.O. Box 15400
00076 AALTO Finland
DOI: 10.1145/3350742 Copyright held by author/owner
by John P. Dougherty,
One of my favorite courses to teach involves concurrency. It reminds me of the concept of recursion
in that both are elegant and, if applied
thoughtfully, effective. As a necessary
(but not sufficient) condition for parallel
computation, it is wonderful to introduce
this particular concept to undergraduates.
After so many courses using a sequential
platform to study algorithms and data
representations, relaxing the sequential
constraints feels natural but is often
difficult to correctly express and a
challenge to teach.
The concurrency course is taught as
an upper-level system elective (i.e., in the
context of operating systems as well as
in distributed systems) that satisfies a
requirement for the major in computer
science, though we try to introduce
the notion of concurrency throughout
the curriculum. For example, one of my
favorite kinesthetic activities in CS2 is
watching students immersed in their
own “race conditions” as they sprint
to the board to place their name in the
appropriate bin for a closed hashing
exercise (and just like the Bob Dylan
lyric, “And the first one now/Will later be
last”). I define concurrency as “order does
not matter,” and repeat this definition
in as many courses as appropriate (e.g.,
high performance scientific computing,
computer organization and architecture).
We investigate how to work with
concurrency in much more depth in the
present course. This exploration includes
uncovering concurrency in code (or in
any collection of project tasks), realizing
when concurrency is easy and should
clearly be exploited, and when it is more
challenging and possibly should be
exploited or perhaps avoided altogether.
Figure 1 depicts an example of this last
point. It is an execution trace of the
Fibonacci recursive definition used in other
courses. I note it appears to have plenty
of concurrency, but in practice it is not a
candidate for naïve multithreading.
Concurrent programming is often the
first chance for students to see correct
code that outputs different results
during a sequence of executions of the
same code. This set of differing results
may include some that are correct, and
some that are not. Even the definition
of “correct” is a challenge since we want
students to extend the standard “meets its
specification” for a sequential program to
now include such aspects as fairness and
Then there is the topic of debugging,
already a challenge for a sequential
program, that is made more troublesome
by the concurrent execution of a program.
In other words, it “doesn’t always not
work.” Yes, one can rerun the program until
it (hopefully?) fails again, but are you sure
it is the same failure as previously seen?
Furthermore, if using a debugger, might
not the debugging tool itself change the
execution of the concurrent program? I
have witnessed student experiences in
the lab where they believe the debugger
fixed the problem because the code works
each time while debugging. This is an issue
not only in education, but one we hope to
address before professional programmers
get into industry and research.
I propose using mathematical reasoning