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 a talk with demos that introduces the use of Chapel to program GPUs in a vendor-neutral manner.

This lightning talk illustrates Chapel implementing several variants of Bale IndexGather—a random access computation: serially, for multicore processors, for GPUs, and on supercomputers. It touts the benefits of parallel languages in making such computations straightforward, yet fast and scalable.

This talk demonstrates how, as a parallel language, Chapel's standard library can easily support parallel implementations, permitting codes that are as succinct as other popular languages to outperform them by 10x–400x. It is also unique among the talks here in that it includes a live demo of programming using Chapel and Arkouda.

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 talk gives an introduction to Chapel's support for GPU programming, including live demos on AMD and NVIDIA GPUs.

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

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

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

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 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 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 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 10-minute talk provides a very brief introduction to Chapel, highlighting recent advances such as support for GPUs and user applications.

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 summarizes Chapel's use in CHAMPS and Arkouda, including some recent scaling results, and summarizes the use of traditional Chapel features to target GPUs in a vendor-neutral manner.

This keynote demonstrates how Chapel's support for task-parallelism is being used to express a wide variety of computations while also generating good performance and scalability.

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 talk describes Chapel's recently added support for GPU programming, detailing the programming model and code generation strategy.

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 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 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 describes the Chapel memory consistency model and how it enables two communication optimizations that have been implemented for Chapel.

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 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 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 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 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 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.