An official website of the United States government
Classic synchronization problems are often used to introduce students to the subtleties of concurrency and synchronization mechanisms, such as semaphores, monitors, locks, and condition variables. The Dining Philosophers, Producers-Consumers, and Readers-Writers are all classic problems in which a correct solution requires the actions of multiple processes or threads to be synchronized. In this paper, we present visualizations for these three problems and describe their use as pedagogical tools to help students build accurate mental models of concurrency abstractions such as starvation, deadlock, livelock, and correct execution. We also present the results of an experiment that indicate students find using these visualizations to be significantly more engaging than reading a textbook, with no significant difference in learning. We do not claim that our visualizations should replace a course text; rather we present them as engaging pedagogical tools to complement the textbook in courses on Operating Systems, Programming Languages, and other courses where concurrency and synchronization are covered.
more »
« less
Visually Introducing Freshmen to Low-Level Java Abstractions for Creating, Synchronizing and Coordinating Threads
We have developed and experimented with an approach to teach low-level Java concurrency abstractions in our first required course for CS majors, which assumes knowledge of procedural programming. The driving problems are visualized simulations of multiple physical objects in motion that may (a) be confined to a shared space and (b) coordinate with each other. Such simulations do not require any domain-specific knowledge such as sorting and image processing for driving problems and exercises, and their implementation demonstrates the benefits of object-based programming. They allow focus on both the performance and programmability benefits of concurrency, provide analogies for an abstraction-independent explanation of concurrency concepts, and can be used to incrementally motivate all low-level concurrency abstractions and visualize the effect of using and not using these abstractions. Layered simulation-based worked examples illustrating the abstractions were presented and easily understood in multiple offerings of a course that implemented this approach. Students implemented non-trivial assignments based on these abstractions, even when they were optional, did not face major obstacles because of visual error feedback, and were excited by concurrency as they felt it empowered them to implement arbitrary applications early.
more »
« less
- Award ID(s):
- 1924059
- PAR ID:
- 10190357
- Date Published:
- Journal Name:
- 2019 26th International Conference on High Performance Computing, Data and Analytics Workshop (HiPCW)
- Page Range / eLocation ID:
- 56 to 63
- Format(s):
- Medium: X
- Sponsoring Org:
- National Science Foundation
More Like this
-
-
Introducing concurrent execution, forking, joining, synchronization, and load balancing of Java threads to trainees allows them to (a) create arbitrary concurrent algorithms, and (b) be exposed to the underpinnings of concurrency concepts. However, it requires the sacrifice of some existing concepts in the course in which such training is added. To keep this sacrifice low, we ambitiously explored if such concepts can be effectively introduced and tested in a single class period, which is approximately an hour, without a live lecture. Students were asked to learn the concurrency concepts by reading, running, fixing, and testing an existing concurrent program, and taking a quiz. They had varying knowledge of concurrency and Java threads but had not implemented concurrent Java programs. Both in-person and remote help were offered. They were allowed to finish their work after class, within a week. The vast majority of them who started on time finished the coding correctly and gave satisfactory quiz answers in ninety minutes. This experience suggests that such hands-on training can be usefully added to courses for training students and instructors that provide no other training in concurrency or training in declarative concepts. Our key ideas can be applied to languages other than Java.more » « less
-
Personalized recommendation of learning content is one of the most frequently cited benefits of personalized online learning. It is expected that with personalized content recommendation students will be able to build their own unique and optimal learning paths and to achieve course goals in the most optimal way. However, in many practical cases students search for learning content not to expand their knowledge, but to address problems encountered in the learning process, such as failures to solve a problem. In these cases, students could be better assisted by remedial recommendations focused on content that could help in resolving current problems. This paper presents a transparent and explainable interface for remedial recommendations in an online programming practice system. The interface was implemented to support SQL programming practice and evaluated in the context of a large database course. The paper summarizes the insights obtained from the study and discusses future work on remedial recommendations.more » « less
-
null (Ed.)Knowledge Tracing (KT), which aims to model student knowledge level and predict their performance, is one of the most important applications of user modeling. Modern KT approaches model and maintain an up-to-date state of student knowledge over a set of course concepts according to students’ historical performance in attempting the problems. However, KT approaches were designed to model knowledge by observing relatively small problem-solving steps in Intelligent Tutoring Systems. While these approaches were applied successfully to model student knowledge by observing student solutions for simple problems, such as multiple-choice questions, they do not perform well for modeling complex problem solving in students. Most importantly, current models assume that all problem attempts are equally valuable in quantifying current student knowledge. However, for complex problems that involve many concepts at the same time, this assumption is deficient. It results in inaccurate knowledge states and unnecessary fluctuations in estimated student knowledge, especially if students guess the correct answer to a problem that they have not mastered all of its concepts or slip in answering the problem that they have already mastered all of its concepts. In this paper, we argue that not all attempts are equivalently important in discovering students’ knowledge state, and some attempts can be summarized together to better represent student performance. We propose a novel student knowledge tracing approach, Granular RAnk based TEnsor factorization (GRATE), that dynamically selects student attempts that can be aggregated while predicting students’ performance in problems and discovering the concepts presented in them. Our experiments on three real-world datasets demonstrate the improved performance of GRATE, compared to the state-of-the-art baselines, in the task of student performance prediction. Our further analysis shows that attempt aggregation eliminates the unnecessary fluctuations from students’ discovered knowledge states and helps in discovering complex latent concepts in the problems.more » « less
-
In chart-based programming environments for machine knitting, patterns are specified at a low level by placing operations on a grid. This highly manual workflow makes it challenging to iterate on design elements such as cables, colorwork, and texture. While vector-based abstractions for knitting design elements may facilitate higher-level manipulation, they often include interdependencies which require stitch-level reconciliation. To address this, we contribute a new way of specifying knits with blended vector and raster primitives. Our abstraction supports the design of interdependent elements like colorwork and texture. We have implemented our blended raster/vector specification in a direct manipulation design tool where primitives are layered and rasterized, allowing for simulation of the resulting knit structure and generation of machine instructions. Through examples, we show how our approach enables higher-level manipulation of various knitting techniques, including intarsia colorwork, short rows, and cables. Specifically, we show how our tool supports the design of complex patterns including origami pleat patterns and capacitive sensor patches.more » « less
- Free Publicly Accessible Full Text
-
Accepted Manuscript1.0
- Conference Paper:
- https://doi.org/10.1109/HiPCW.2019.00022
