Presentation Archives (Reverse Chronological)

This lightning talk briefly introduces scalable data analysis in Arkouda, as powered by Chapel.

This is an introduction to Chapel for a broad scientific computing audience, focusing on high-level concepts and applications.

This talk focuses on user accomplishments with Chapel. It then covers some unique features of the language and how they ease scaling from laptop to supercomputer.

This lightning talk recaps elements of Brad's HIPS 2025 keynote in a compressed, 8-minute format.

This talk addresses the question 'Why use Chapel instead of other languages?', covering Chapel characteristics and resources in a bit more detail than most talks

This talk introduces Chapel by example and through key user applications before turning to Chapel on GPUs and a quick look at 20 years of HPC programming.

This talk introduced how Chapel tracks and triages performance over time as input to the HPSF benchmarking group.

This talk demonstrates how Chapel can be used to program most parallel architectures from desktops to supercomputers using code examples, benchmark results, and user stories.

This keynote uses the 30th instance of HIPS as an opportunity to reflect on the past 30 years of HPC programming language design and adoption (or lack thereof)

A gentle introduction to Chapel for a general scientific computing audience, covering motivation, apps, performance, and resources.

A lightning talk introducing Chapel's support for vendor-neutral GPU programming and how it is implemented

A report on a collaboration between HPE and [C]Worthy in support of studying ocean Carbon Dioxide Removal (CDR) leveraging Chapel and its interoperability with Fortran.

A quick introduction to Chapel and its synergies with the goals of the High Performance Software Foundation.

A few slides to kick off a Q&A session in Michelle Strout's CSc 372 class at the University of Arizona.

This poster summarizes how Chapel assists biomedical research using Monte Carlo simulations on GPUs.

This joint talk introduces Chapel and CHAMPS, a multiphysics solver developed at Polytechnique Montreal for aerodynamics research.

This presentation describes the basic functionality of the Chapel runtime, and what goes on behind the scenes when a Chapel program runs.

A technical overview of Chapel for PL types covering language features, apps, optimizations, GPU features, and more

The presentation of our application to HPSF covering Chapel's motivation and synergies with HPSF along with a summary of our development process

A description and demo of Arkouda extensions permitting it to serve as a back-end for XArray.

These are slides that we used for our demo station for Arkouda and Chapel in the HPE Booth at SC24

An introduction to, and interactive demo of, interactively driving HPC systems at scale using Python and Jupyter using Arkouda.

This talk proposes an application-first approach for teaching parallel computing and shares some experiences based on Chapel.

This keynote talk introduces CHAMPS, a multiphysics solver developed at Polytechnique Montreal for aerodynamics research.

A short talk describing early work towards suffix array construction in Chapel with applications to strain detection in metagenomics.

A run-down of highlights from the Arkouda and Chapel projects since CLSAC 2022, the last time I talked to Arkouda PI Mike Merrill before his passing.

An overview of what makes the Chapel programming language unique and how users have benefited from its productivity, speed, and scalability.

An overview of what makes the Chapel programming language unique and how users have benefited from its productivity, speed, and scalability.

This talk introduces many ways in which developers and enthusiasts can contribute to the open-source Chapel project.

This talk demonstrates how Chapel enables developing parallel, scalable real-world applications.

This is a talk with demos that introduces the use of Chapel to program GPUs in a vendor-neutral manner.

This is an in-depth talk about Chapel's GPU programming where concepts of parallelism and locality are covered extensively.

This talk introduces Chapel's support for GPU programming through user codes making use of it today and sample code segments.

A lightning talk illustrating Chapel through several variants of a simple computation: serially, multicore, for GPUs, and on supercomputers.

This keynote introduces Arachne, an open-source framework that enhances massive-scale graph analytics powered by Chapel and Arkouda.

This talk gives an introduction to Chapel's support for GPU programming, including live demos on AMD and NVIDIA GPUs.

This talk and demo show how Chapel's standard library easily supports parallel implementations, permitting succinct codes to outperform popular languages by 10x–400x.

This talk provides an in-depth introduction to Chapel's support for GPU programming from motivation to key concepts, applications, implementation, and ongoing work.

This talk describes the use of Chapel to estimate the biodiversity of coral reefs using satellite image analysis.

This talk describes the use of Chapel to compute exact diagonalization methods on distributed systems, as used when simulating small quantum systems.

This introduction to Chapel provides the language's motivation and brief comparisons with familiar languages and HPC programming models. It then introduces some of Chapel's core features for parallelism and locality, showing how they have recently been extended to also support GPUs. It wraps up by providing a peek into some of the flagship applications that are using Chapel.

This is an introduction to the motivation, capabilities, and performance of Arkouda, supporting interactive data science for Python users at massive scales.

This 10-minute talk provides a very brief introduction to Chapel, highlighting recent advances such as support for GPUs and user applications.

This keynote demonstrates Chapel's support for task-parallelism and its use to express a wide variety of computations while generating good performance and scalability.

This talk describes the use of Chapel's task-based parallel features to optimize communication through compiler analysis and/or user-defined aggregation abstractions.

This talk provides background on Chapel, such as how it compares to other mainstream language and HPC programming models, along with some of its benefits in the Arkouda and CHAMPS applications.

This talk provides an update to the DOE community about recent Chapel progress, along with a retrospective about how we got here and some research challenges going forward.

This talk describes Chapel's recently added support for GPU programming, detailing the programming model and code generation strategy.

This keynote describes various forms of optimized and aggregated communications in Chapel for sparse communication patterns as exhibited by HPCC RA, Bale IndexGather, or Arkouda. Approaches include asynchronous fine-grain communications, manual copies expressed using Chapel's global namespace, and aggregation via user-level abstractions or compiler transformations.

This CHIUW keynote describes CHAMPS, a ~48k-line framework written in Chapel for 3D unstructured computational fluid dynamics (CFD), while also providing an introduction to the role of HPC in Aerodynamics. The productivity benefits that Chapel brings to the CHAMPS team's work are made clear.

This talk gives a peek into what's required to compile some of Chapel's key features, and describes a pair of optimizations that are made possible through its unique features.

This CHIUW keynote describes Arkouda, a Python package that provides a NumPy-like interface implemented using a Chapel server that scales to dozens of Terabytes of data at interactive rates.

This talk describes a use of Chapel to explore dark matter in cosmological models.

This talk describes the role of Chapel in supporting Exploratory Data Analysis (EDA) in Arkouda.

This keynote provided a review of some of the productivity metrics that were pursued under the DARPA HPCS program, but then argued that productivity seems like a very personal/social decision and that it therefore should be studied in forums supporting personal/social decisions. Two specific proposals are made.

This talk surveys past approaches to benchmarking from a language designer's perspective, rating them along various axes of importance. It wraps up by advocating for an HPC equivalent to the Computer Language Benchmarks game.

This keynote by Jonathan Dursi presents a survey of modern parallel computing frameworks as seen through the filter of the speaker's applications background, and describes Chapel's unique position within that landscape.

This keynote talk reflects on some of the successes of ZPL's support for data-parallel array-based programming, lists reasons that ZPL was ultimately limited, and how we addressed those limitations in Chapel's design.

This was the keynote talk at CHIUW 2016, reporting on the personal experiences of an Astrophysics Professor who's been looking at using Chapel in his research.

This talk describes the Chapel memory consistency model and how it enables two communication optimizations that have been implemented for Chapel.

This talk and poster provide an introduction to Chapel's hierarchical locales, a Chapel concept for making the language and user codes future-proof against future changes in node architecture.

This talk briefly summarizes productivity-oriented metrics work undertaken by the Cray Cascade project during the HPCS program, along with a few anecdotal instances of Chapel productivity. It also provides some of Brad's personal takeaways from the experience.

This talk is a fairly comprehensive overview of Chapel's themes, features, and status, with a bit more emphasis on the implementation and multiresolution design of the language than a typical talk allows for.

This talk lists some of the things that we think make HPC programming non-productive today and gives examples of how we are trying to address them in Chapel.

This talk considers five design decisions that parallel language designers should wrestle with and how Chapel's design deals with them.

This is the original Chapel paper which lays out some of our motivation and foundations for exploring the language. Note that the language has evolved significantly since this paper was published, but it remains an interesting historical artifact.