One step at a time: Parallelism in an introductory programming course

https://doi.org/10.1016/j.jpdc.2016.12.024Get rights and content

Highlights

  • It is better to cover a few PDC topics well than try to cover many in a shallow way.

  • Active PDC programming exercises generate greater interest and motivation in students.

  • Java thread programming has many smaller challenges that should be addressed first.

Abstract

By introducing parallelism in introductory programming courses, all computer science students can receive a basic understanding of this crucial topic. Such an early introduction, however, has many challenges. This paper first presents a fall 2013 comparison of two Computer Science I (CS1) sections, leading to a conclusion emphasizing the importance of devoting sufficient time to a sufficiently small set of parallelism topics. Six additional CS1 sections are then considered, offered from spring 2014 through spring 2016 by three different instructors. Five of these removed coverage of Java thread programming due to challenges found in fall 2013, only to show measurably reduced effectiveness of the parallelism module. Thus a new thread programming integration strategy is presented, as done in spring 2016. This strategy includes active out-of-class activities that split the disparate challenges of Java thread programming into distinct exercises. Results demonstrate improved student interest and learning.

Introduction

For decades, parallel and distributed computing (PDC) has occupied a place as one special topic among many in the computer science curriculum. Increasingly, however, the computer science education community agrees that PDC is a vital core subject area. The recommendation that all computer science majors be exposed to key PDC concepts before graduation was formally put forth in the ACM CS2013 curriculum guidelines  [1].

The primary discussion now is how these concepts should be integrated into existing curricula. This paper focuses on integration into Computer Science I (CS1). While variations exist, CS1 is defined here as an introductory programming course with no prior programming experience expected, taken by a mix of intended majors and non-majors. Standard topics include iteration, selection, arrays, object use, and basic class construction. One benefit of such early integration of PDC is that students will see it as a natural and common part of programming, instead of an advanced and rarely-used concept. The challenge, of course, is that PDC brings many cognitive and technical problems to programming that can be particularly difficult to tackle early in a curriculum. In addition, it can seem difficult to find room for exploration of PDC concepts in CS1 among many other worthy topics.

This article begins with related work in integrating PDC concepts into CS1. It then examines two sections of a CS1 course offered in fall 2013, sharing detailed strategies used in exploring parallelism. A comparative analysis of pre- and post-test results is presented. The analysis concludes with recommendations for the successful integration of parallelism into CS1 based on these contrasting experiences. This first discussion is repeated from  [6].

This article then extends the results of  [6] with data for several additional course sections by multiple instructors from spring 2014–spring 2016. Further conclusions and challenges are discussed, followed by a deeper approach meeting these challenges in a way that reinforces traditional CS1 topics while measurably garnering greater student interest and knowledge of PDC issues. This is done at a level appropriate for CS1 students, in a very short time-frame (about 4 h in class) designed to be highly adoptable by other instructors. While this study is relatively small in size, it provides useful data on these issues, setting the stage for additional work discussed in Section  12.

Section snippets

Connections to other work

Educators are increasingly working to integrate PDC throughout the CS curriculum. Again, the ACM CS2013 curriculum guidelines  [1] are an authoritative statement of recommended PDC topics for all computer science programs. Another important work in curriculum recommendations is the NSF/IEEE-TCPP Curriculum Initiative on Parallel and Distributed Computing  [30], which outlines many topics and recommended coverage based on Bloom’s taxonomy  [4].

Much work has been done in the consideration of

Overview of two CS1 courses

This section provides an overview of how concepts of parallelism were integrated into two sections of CS1 taught by two different instructors in fall 2013. Section A had 28 students, while Section B had 26. This course is taken by both majors and non-majors. In fact, a sizable number of students take the course to fulfill a general education requirement, with no intention of further study in computer science. Students in both sections took the same pre-test and post-test, as described in

Several analogies and exercises

This section will share some illustrations of the presentation of the material as done in section A, suitable for adoption into other instructors’ CS1 courses. The approach in section A was characterized by many “unplugged” exercises and analogies offset by short periods of lecture.

The pre/post test

Both sections of CS1 used the same pre- and post-tests to measure student opinions and understanding about parallelism. The pre-test was given at the beginning of the semester, before any course material at all had been considered. The post-test was given in the last week of the semester, some time after all planned material on parallelism had been considered. The tests began with four “opinion” prompts, hereafter referred to as Opinion 1 through Opinion 4. Each was answered on a 5-point scale:

Test results

The results for the opinion questions are shown in Fig. 6, Fig. 7, Fig. 8, Fig. 9. Each vertical bar is divided into the number of Strongly Agree (SA) responses on top, followed by Agree (A), Neutral (N), Disagree (D), and Strongly Disagree (SD) beneath. Results are shown for the pre-test for sections A and B, and post-test for sections A and B. Recall that section A spent over four hours of contact time on parallelism, including many active exercises and brief implementation in Java. Section B

Analysis

The test results suggest conclusions both in terms of depth of learning and interest. Students in both sections appear to have learned about parallelism to some extent, as seen in Opinion 2 and the factual questions. However, section A’s learning results are much stronger overall. This is in some sense not surprising, because significantly more contact time was spent on the material (over four hours versus 90 min). It is interesting to note, however, that while time spent varied, the general

Application to subsequent semesters

The discussion above is as reported in  [6]. Since then, this module on parallelism has been taught six additional times by three different instructors, from spring 2014 through spring 2016, with an average of 25 students per section. The eight course sections considered in this paper (including section A and B above) are hereafter referred to with the encoding instructorID-semYear, where instructorID is either A (instructor of section A above), B (instructor of section B above), or C (a third

Results for subsequent semesters

In A-S14 through C-S15, the same pre- and post-tests were given as for A-F13 and B-F13, asking both opinion-based and factual questions. Results are presented in the subsections below.

Reintegrating programming

Thus there are somewhat troubling results in the data for A-S14 through C-S15. Section  9.2 showed there is a reduction in factual scores for most of the non-programming semesters, although the factual questions do not directly measure thread programming ability. However, the most striking observation, measured directly by the opinion questions, is the reduction of desire to learn more (Section  9.1). Recall that the only difference between A-F13 and A-S14 through C-S15 is the coverage of Java

Analysis of the reintegration of thread programming

This section considers student interest, factual question performance, and perceptions of difficulty of various aspects of the parallelism module.

Future work

Given the fairly small number of students and faculty involved in this study, the principal goal of this work moving forward is to support even broader conclusions by applying this approach in more semesters and with more instructors. It would also be interesting to evaluate this approach with other types of student populations: for example, a CS1 only for intended majors versus another for non-majors, or perhaps even an accelerated CS1 for students with some prior programming experience.

Conclusion

The initial study of fall 2013 considered student interest and learning of parallelism topics in two course sections. The main conclusion of that study is that in parallelism it is more effective to consider deeply a smaller set of topics, rather than explore a larger set of topics at a more shallow level. Extending these results, the less-covered Java thread programming discussion was subsequently dropped for several semesters, but this too seemed to lead to less interest and somewhat lower

Steven A. Bogaerts received his Ph.D. in Computer Science from Indiana University in 2007. In his dissertation he developed a rank quality measure for the evaluation of conversational case-based reasoning systems. He is now an associate professor of computer science at DePauw University. His research interests include parallelism education and artificial intelligence/machine learning (AI/ML), particularly in ways that can include undergraduate researchers. In AI/ML, his recent work has been in

References (34)

  • J.C. Adams et al.

    Tsgl a thread safe graphics library for visualizing parallelism

    Procedia Comput. Sci.

    (2015)
  • ACM/IEEE-CS Joint Task Force~on Computing Curricula, Computer science curricula 2013, Tech. rep.

    (2013)
  • T.C. Bell, I.H. Witten, M.R. Fellows, R. Adams, J. McKenzie, M. Powell, CS Unplugged: An Enrichment and Extension...
  • B.S. Bloom et al.

    Taxonomy of Educational Objectives: Handbook I: Cognitive Domain, 19

    (1956)
  • S. Bogaerts

    Hands-on exploration of parallelism for absolute beginners with scratch

  • S.A. Bogaerts

    Limited time and experience: Parallelism in CS1

  • S. Bogaerts, K. Burke, B. Shelburne, E. Stahlberg, Concurrency and parallelism as a medium for computer science...
  • S. Bogaerts, K. Burke, E. Stahlberg, Integrating parallel and distributed computing into undergraduate courses at all...
  • K. Brennan, M. Resnick, New frameworks for studying and assessing the development of computational thinking, in:...
  • R.A. Brown

    Hadoop at home: Large-scale computing at a small college

    SIGCSE Bull.

    (2009)
  • R. Brown et al.

    Modules in community: Injecting more parallelism into computer science curricula

  • R. Brown et al.

    CSinParallel and synergy for rapid incremental addition of PDC into CS curricula

  • R. Brown et al.

    Strategies for preparing computer science students for the multicore world

  • K.B. Bruce et al.

    Introducing concurrency in CS 1

  • R.A. Chesebrough et al.

    Parallel computing: At the interface of high school and industry

  • J. Dean et al.

    Mapreduce: Simplified data processing on large clusters

    Commun. ACM

    (2008)
  • D.J. Ernst et al.

    Concurrent CS: Preparing students for a multicore world

    SIGCSE Bull.

    (2008)
  • Cited by (20)

    • Has the time come to teach parallel programming to secondary school students?

      2022, Heliyon
      Citation Excerpt :

      A research conducted on 180 student solutions [42] found that 23 solutions include a data race mistake, where the variable protection mechanism was not used, followed by 11 solutions in which the program underwent a deadlock, while 11 students unnecessarily used variable locking in programs. Numerous documents, among which are ACM CS2013 curriculum guidelines and NSF/IEEE-TCPP [43], testify that parallel programming should be introduced for all computer science students. ACM CS2013 recommends that parallel programming be dispersed across several courses throughout the studies.

    • A learning experience toward the understanding of abstraction-level interactions in parallel applications

      2021, Journal of Parallel and Distributed Computing
      Citation Excerpt :

      In this sense, following the recommendations of both the NSF/IEEE-TCPP Curriculum Committee [32] and the ACM/IEEE Joint Task Force on Computing Curricula [1], numerous approaches have made an effort to increase the presence or to reinforce Parallel and Distributed Computing (PDC) in CE programs. Recent work distributes PDC topics across different courses through the integration of modules into existing courses [7,20,38], introducing parallel programming in lower-level courses [6,18,42], the proposal of research-oriented teaching methodologies [16,22,30], or the creation of new courses [12,28,35]. A common approach to design and explain a computer system is to split the complexity of the whole system into self-contained levels.

    • A course on big data analytics

      2018, Journal of Parallel and Distributed Computing
      Citation Excerpt :

      This course is the only big data analytics course available to our computer science majors. We are not proposing at this time to integrate PDC topics in first- or second-year programming courses, as explored by Bogaerts [2] and Grossman et al. [12], or throughout the curriculum as done by Swarthmore College and reported by Newhall et al. [19], among other institutions. We agree with these other authors that an integrated curriculum has advantages for student learning and skill development.

    • AI and Parallelism in CS1: Experiences and Analysis

      2023, Proceedings of the 37th AAAI Conference on Artificial Intelligence, AAAI 2023
    • Introducing Parallel and Distributed Computing concepts through the use of Flashcards and a Card Game

      2023, 2023 IEEE International Parallel and Distributed Processing Symposium Workshops, IPDPSW 2023
    View all citing articles on Scopus

    Steven A. Bogaerts received his Ph.D. in Computer Science from Indiana University in 2007. In his dissertation he developed a rank quality measure for the evaluation of conversational case-based reasoning systems. He is now an associate professor of computer science at DePauw University. His research interests include parallelism education and artificial intelligence/machine learning (AI/ML), particularly in ways that can include undergraduate researchers. In AI/ML, his recent work has been in data classification and machine game playing. In parallelism education, he has done much work in integrating parallelism into low-level courses, including CS0, CS1, and a non-major interdisciplinary course.

    View full text