, but this code // executes before the first paint, when

is not yet present. The // classes are added to so styling immediately reflects the current // toolbar state. The classes are removed after the toolbar completes // initialization. const classesToAdd = ['toolbar-loading', 'toolbar-anti-flicker']; if (toolbarState) { const { orientation, hasActiveTab, isFixed, activeTray, activeTabId, isOriented, userButtonMinWidth } = toolbarState; classesToAdd.push( orientation ? `toolbar-` + orientation + `` : 'toolbar-horizontal', ); if (hasActiveTab !== false) { classesToAdd.push('toolbar-tray-open'); } if (isFixed) { classesToAdd.push('toolbar-fixed'); } if (isOriented) { classesToAdd.push('toolbar-oriented'); } if (activeTray) { // These styles are added so the active tab/tray styles are present // immediately instead of "flickering" on as the toolbar initializes. In // instances where a tray is lazy loaded, these styles facilitate the // lazy loaded tray appearing gracefully and without reflow. const styleContent = ` .toolbar-loading #` + activeTabId + ` { background-image: linear-gradient(rgba(255, 255, 255, 0.25) 20%, transparent 200%); } .toolbar-loading #` + activeTabId + `-tray { display: block; box-shadow: -1px 0 5px 2px rgb(0 0 0 / 33%); border-right: 1px solid #aaa; background-color: #f5f5f5; z-index: 0; } .toolbar-loading.toolbar-vertical.toolbar-tray-open #` + activeTabId + `-tray { width: 15rem; height: 100vh; } .toolbar-loading.toolbar-horizontal :not(#` + activeTray + `) > .toolbar-lining {opacity: 0}`; const style = document.createElement('style'); style.textContent = styleContent; style.setAttribute('data-toolbar-anti-flicker-loading', true); document.querySelector('head').appendChild(style); if (userButtonMinWidth) { const userButtonStyle = document.createElement('style'); userButtonStyle.textContent = `#toolbar-item-user {min-width: ` + userButtonMinWidth +`px;}` document.querySelector('head').appendChild(userButtonStyle); } } } document.querySelector('html').classList.add(...classesToAdd); })(); NSF grant spurs innovation in parallel computing - News & Stories | 鶹

Skip to main content

Calvin News

NSF grant spurs innovation in parallel computing

Wed, Jan 23, 2019
Connor Bechler

When Calvin  professor Joel Adams launched Calvin’s first parallel computing course in the late 90s, the field was “an esoteric elective kind of thing.” Supercomputers, the main devices at the time to rely on parallel computing, were few and far between.

In 2005, however, computer processor developers started making multi-core processors for the general market.  “Now, even most phones have eight cores,” said Adams, “it’s no longer an esoteric thing—it takes a whole different kind of programming to make use of those multiple cores, which makes it critically necessary to teach every computer science student about parallel computing.”

Innovative teaching tools for a changing field

This increasing need has led Adams to collaborate with several institutions in an effort to advance parallel computing instruction, beginning with a 2012 NSF grant to host workshops for computer science professors across the country and to launch a website——for distributing educational materials.

This past fall, Adams—together with colleagues at United States Military Academy, West Point, and St. Olaf College in Minnesota—received a $595,131 grant for the development of new parallel computing teaching tools.

“We’re looking for real world analogies to parallel behavior so that we can create the equivalent of those analogies in software,” said Adams. “With this grant, we’re specifically aiming to help students understand parallel computing through sight, sound, and touch.”

While St. Olaf College is researching possible touch-based approaches, and West Point is attempting to build an interactive online textbook, Adams and two student researchers will work this upcoming summer on building several tools to provide students learning parallel computing with direct audio and visual feedback. 

Adams says the audio tool will mimic music ensembles: each separate computational task will produce a distinct tone, allowing “students to hear the parallelism” as the program executes, demonstrating audibly what parts of the program employ multiple cores. The visual side of the project will involve graphic rendering in which each core renders a different part of the image in a different color than the other cores, showing students how tasks are distributed among cores.

Advancing instruction nationally

Adams has worked with several students on similar projects in the past. Computer science student Elizabeth Koning has worked with Adams on parallel computing visualizations since 2017, recently conducting an experiment on how well introductory students learned programming concepts from working with visualizations compared to textbook reading.

“There was a statistically significant difference in how engaging the students found each activity,” said Koning. “Based on their responses, I’m very optimistic about the potential of these visualizations to aid students’ understanding of parallel computing.”

Sarah Hendriksen, a computer science and psychology double major, worked with Adams the summer of 2018. “The purpose was to create an augmented reality teaching tool for parallel computing, as many of the concepts are highly abstract,” said Hendriksen.

Collaborating with Adams and a researcher from the University of Auckland, she helped build an application which teaches parallel computing concepts through an interactive office simulation. “Through the research, I was able to better grasp the different complexities and uses for different types of parallel computing,” she added.

Adams noted that a diversity of resources is ultimately the goal: “At the end of the grant we’ll have all these different pedagogical materials publicly available on csinparallel.org, and instructors around the country will be able to download them and integrate them into their courses.

“If you give students enough examples of how parallelism is used to solve problems, they start thinking and understanding the underlying patterns of parallel behavior.”