---
tags: seminar series

title: Chapel: Making Parallel Programming Productive, from laptops to supercomputers
---

:::danger
**General info**
- **Video connection details:**
- Zoom ID: 66209075434
- Zoom password: rse
- Zoom invite link: <https://uwasa.zoom.us/j/66209075434?pwd=VmRBaFRVOXNKNFRYb1NDRGY5SXZndz09>
- **Date and time**: 2022-11-30, 16:00 CET
- **This page:** <https://hackmd.io/@nordic-rse/seminar-november-2022>
:::

# Chapel: Making Parallel Programming Productive, from laptops to supercomputers

## Ice breaker question

- What are your biggest struggles with parallel programming? (in general, not necessarily in Chapel)
- ...
- the debugging of it
- the profiling of it
- the "boilerplate" of it (lots of typing to get something done)
- rapid change in architectures used by supercomputers
- changing floating point rounding mode in a thread safe way :/
- going beyond one compute node

## About the series

This is an event in the Nordic RSE seminar series.
* Reminder about starting recording
* Find out about future events:
* Check https://nordic-rse.org/events/seminar-series/.
* Previous seminar talks videos available at [Youtube channel](https://www.youtube.com/channel/UC8OyVrmJEuT2lrH7zXoBrhQ)
* Follow [@nordic_rse](https://twitter.com/nordic_rse) on Twitter for announcements
* Join the [Nordic RSE stream](https://coderefinery.zulipchat.com/#narrow/stream/213720-nordic-rse) of the CodeRefinery chat
* Suggest speakers:
* on the [Nordic RSE stream](https://coderefinery.zulipchat.com/#narrow/stream/213720-nordic-rse)
* by creating an issue on the [Nordic RSE website repository](https://github.com/nordic-rse/nordic-rse.github.io/issues)

## About the Nordic RSE

* Represents Research Software Engineers in the Nordics.
* Check out [nordic-rse.org](https://nordic-rse.org/) for other activities.
* Registereed as an association in Fall 2021.
* To become a member, fill in the [membership form](https://forms.gle/qCVVRGXPi3Hq7inW6).

## Speaker: Speaker name

Short bio

## Abstract

Over the past few decades, a gulf has existed between 'mainstream' programming languages—like Python, Java, C++, Rust, or Swift—and technologies used in practice for programming supercomputers—like MPI, OpenSHMEM, OpenMP, CUDA, OpenCL, or OpenACC.
This gulf results in making High Performance Computing something of a specialized skill that may not be readily available to the general programmer or applied computational scientist.
In some ways, the problem has even gotten worse over time, as the end of Moore's law has led to building supercomputers using manycore processors and computational accelerators like GPUs.

In this talk, I will introduce Chapel, an open-source language created to bridge this gulf.
Chapel strives to support code that is similarly readable/writeable as Python, yet without sacrificing the portability and scalable performance required to utilize supercomputers effectively.
Specifically, I will provide motivation for Chapel, present some of its unique features and themes, introduce flagship applications of Chapel, and give a glimpse into our team's current priorities.

## Ask your questions here

- is this a question?
- yes, and this is an answer

- is Chapel cool?
- yes!!

- it is really nice that it is so portable. For quite some time I thought, without checking, that it was only running on supercomputers and only on some vendor(s). it is nice that I was really wrong

- (maybe this will come later ...) do we need Makefiles/CMake/Autotools to configure/build the code when there are several files?
- currently typically done with Make but some people use CMake for this.
- to build Chapel from sources, under hood it uses and requires Make and also some CMake (if I understood correctly)

- Arkouda
- https://github.com/Bears-R-Us/arkouda

- does restricting types affect efficiency or binary size? or is this to help humans and catch errors
- combination of both (but here not distinguishing type inference and restricting types)
- does annotating types compared to type inference affect efficiency?
- no performance difference since the compiled code ends up being the same

- [hello world variants in Chapel](https://chapel-lang.org/docs/examples/index.html)

- are domains a unique feature of Chapel? or is there equivalent in other languages?
- I like how they guide me towards not going out of bounds

- what's the logic how indices are distributed over locales?
- domain maps such as "Cyclic" can be used as recipes for that
- one can also write own domain maps/ recipes

- Does Chapel have built-in features/support for GPU programming?
- there is enough functionality for this to be useful and interesting and the core developers are interested in feedback

- could you stick for GPU slides: oooo

- what do you know now about language design/development that you wish you knew when you started with Chapel 15 (?) years ago?

- Chapel is known for its welcoming community. what was or is the most effective "trick"/approach/tip when building the Chapel community?
- responsiveness in user interaction
- patience, friendliness, kindness in virtual interaction

- yay for Advent of Code! tempted to try at least some of it in Chapel
- great idea to do a blog post series. this is a great way to help learning the language