Abstract:

The average number of new Computer Science (CS) students per department in the United States has been dropping since 1999, and 30% to 40% of attrition rate was reported by many CS programs. To attract and keep more students, some CS programs choose to use some 3D programming language (e.g., Alice) in their CS1 and CS2 courses, believing that students can be better motivated by creating animated movies or video games. some educators sticks to using traditional programming languages, but they have started to use more effective ways, such as games, to convey the programming concepts to students.

There is no doubt that the above teaching evolutions have been successful, but one problem may have been overlooked – some programming concepts (e.g., multi-threading) are just too difficult to master for some students even if they are motivated and dedicated, and how to teach those complicated computing concepts is worth being studied by educators. The author believes that effectively teaching complicated computing concepts should be studied case by case, so instead of proposing any methodology in general, the author focuses on how to help students master multi-threaded programming for multi-core processors in this paper.

Due to the popularity of multi-core processors in off-the-shelf computers, most CS programs have put multi-threaded programming in their introductory courses since multi-threading is necessary in order to simultaneously utilize the multiple processing cores of a multi-core processor. However, coding a multi-threaded program can be very challenging even for experienced parallel programmers, let alone inexperienced students. Two major challenges exist for students – The first one is to correctly understand how the synchronization primitives of a language work. For example, many of the author's students had the misconception that a waiting thread held the critical section. Furthermore, correctly design a parallel algorithm is inherently difficult, and careless synchronization may lead to runtime errors incurred by race conditions or suboptimal performance caused by unnecessary thread waiting or context switch.

These challenges lying in multi-threaded programming has motivated the author to develop a software tool named FootprintTrax that tracks the footprint of a multi-threaded code and visually demonstrates how threads interact behind the scene. FootprintTrax can serve two roles – As an instructional tool, it visually shows what happens internally when a synchronization statement executes, thus helping students understand the fundamental concepts of multi-threading and master the multi-threading features of a programming language. FootprintTrax is also able to facilitate parallel programmers to fix runtime bugs or optimize the performance by recording the state changes of and interactions between threads as well as their execution statistics.

FootprintTrax consists of two standalone components – Footprint Tracking and Footprint Rendition. The Footprint Tracking component is implemented in C++ and composed of a number of tracking agents that are activated when the corresponding events (i.e., actions) occur in the running code and then record the runtime states of the code as a sequence of snapshots. The Footprint Rendition component is coded with Java for portability and offers a graphical interface for programmers to look into the code (e.g., checking out what happens internally when a synchronization statement executes).

Keywords:

retention rate, cs1/cs2, multi-threaded programming, footprint, synchronization, sub-.