Inverted CERN School of Computing 2020

28 Sept 2020, 14:00 → 2 Oct 2020, 18:00 Europe/Zurich

Online event

Sebastian Lopienski (CERN), Joelma Tolomeo (CERN), Jarek Polok (CERN)

The 13th Inverted CERN School of Computing (iCSC 2020) consists of classes (lectures, exercises, demonstration and consultations) given by former CERN School of Computing students. The Inverted School provides a platform to share their knowledge by turning students into teachers. More information on the Inverted CSC events can be found at https://csc.web.cern.ch/schools/inverted-school/.

Topics covered this year include:

Programming Paradigms and Design Patterns Computational Fluid Dynamics Reconstruction and Imaging

Modern C++ features Heterogeneous Programming with OpenCL Big Data processing with SQL

 

The school took place as an online event on September 28 to October 2, 2020. The event was recorded, and the recordings are published, and linked from the corresponding contributions.

See the Online school guide with more information about different types of classes, guidelines for participation and asking questions, details of the Mattermost chat, requirements for the Certificate of Attendance, and more.

 

                                                             

iCSC 2020 Booklet.pdf

iCSC 2020 Group Photo.png

iCSC 2020 Poster.pdf

Monday, 28 September

14:00 → 14:10 A word from the IT Department Head

Speaker: Frederic Hemmer (CERN)

Recording

14:10 → 14:15 Introduction to the Inverted CSC

Speaker: Sebastian Lopienski (CERN)

2020.09.28 iCSC-2020 Welcome.pdf

2020.09.28 iCSC-2020 Welcome.pptx

Recording

14:15 → 15:15 Programming Paradigms (lecture)

Ever been to the point where even little improvements require large refactoring efforts or dirty hacks? If only one had made the right choices on the way!

This course discusses programming paradigms (functional vs object oriented, imperative vs declarative programming, ...) and introduces common design patterns (reusable solutions to common problems). While theory alone is unlikely to make you a better developer, having an overview of common principles paired with the vocabulary to describe them will make it easier to come up with the right solutions.

In the exercises, we refactor various code snippets using the ideas of the lecture. Different approaches and their applicability to HEP problems are being discussed. Basic familiarity with Python is advised for the exercises.

This series is aimed at scientists with little formal training in software engineering, but veterans are always welcome to join for additional input in the discussions!

Speaker: Kilian Lieret (Ludwig Maximilian University)

Kilian Lieret_programming_paradigms.pdf

Recording

15:25 → 16:25 From the electric pulse to image quality - the analysis chain of imaging detectors (lecture)

Imaging gaseous detectors are the base-technology for many applications, such like Medical Imaging and Airport Security, as they are an upgrade to our biologic eyes.

The objective of this lecture is to join physics and computing concepts to fully understand the analysis chain of an imaging gaseous detector. We will discuss the physics inside the detector, the engineering that processes the electric pulses, the computing skills behind image reconstruction and come back to the physical concepts by extracting meaningful parameters from the final image.

In the exercise session, you will follow these steps yourself by analyzing electric pulses from an oscilloscope, reconstructing an image from a data file and quantifying some important parameters like position resolution and noise.

Speaker: Rita Roque (University of Coimbra)

Recording

Rita Roque_From the electric pulse to image quality_lecture_presentation.pdf

16:35 → 17:35 Modern C++ vs. its legacy: when stability is more important than performance (lecture)

"Leaving no room for a lower-level language", this has always been the declared mantra of the C++ language development. At the same time C++ is an old language and its legacy affects possible performance improvements in the STL due to ABI stability concerns. ABI stands for "Application Binary Interface" and its stability is often put over performance on the one hand while on the other hand, "ABI" or even its stability is not mentioned a single time in the entire C++ standard.

In this talk I will explain what ABI stability means, why it is not mentioned in the standard but is still lethal to many proposals, and discuss some recent implications. I will not be able to present solutions to the dilemma; the hope is to encourage attendees to make their mind and to attend ongoing discussions about this vital topic.

Speaker: Nis Meinert (German Aerospace Center (DLR))

cpp_abi_booklet.pdf

cpp_abi.pdf

Recording

Tuesday, 29 September

14:00 → 15:00 Software Design Patterns (lecture)

Ever been to the point where even little improvements require large refactoring efforts or dirty hacks? If only one had made the right choices on the way!

This course discusses programming paradigms (functional vs object oriented, imperative vs declarative programming, ...) and introduces common design patterns (reusable solutions to common problems). While theory alone is unlikely to make you a better developer, having an overview of common principles paired with the vocabulary to describe them will make it easier to come up with the right solutions.

In the exercises, we refactor various code snippets using the ideas of the lecture. Different approaches and their applicability to HEP problems are being discussed. Basic familiarity with Python is advised for the exercises.

This series is aimed at scientists with little formal training in software engineering, but veterans are always welcome to join for additional input in the discussions!

Speaker: Kilian Lieret (Ludwig Maximilian University)

Kilian Lieret_software_patterns.pdf

Recording

15:10 → 16:25 Modern C++: Everything you (n)ever wanted to know about C++'s Lambdas (lecture)

From a syntactical point of view, the Lambda expression of C++ is nothing but syntactic sugar of a struct with an appropriate call operator overload. On the other hand, this simple syntax is shockingly flexible and allows powerful abstractions in a functional way, while providing elegant and easy to read code in a language that is notoriously famous for being unnecessary clunky and verbose.

I will give an overview about the basic syntax and best practices. I will then talk about stateful Lambdas, Lambda inheritance and their real-world applications.

Speaker: Nis Meinert (German Aerospace Center (DLR))

cpp_lambda_booklet.pdf

cpp_lambda.pdf

Recording

16:35 → 17:05 From the electric pulse to image quality - the analysis chain of imaging detectors (exercise consultation)

Imaging gaseous detectors are the base-technology for many applications, such like Medical Imaging and Airport Security, as they are an upgrade to our biologic eyes.

The objective of this lecture is to join physics and computing concepts to fully understand the analysis chain of an imaging gaseous detector. We will discuss the physics inside the detector, the engineering that processes the electric pulses, the computing skills behind image reconstruction and come back to the physical concepts by extracting meaningful parameters from the final image.

In the exercise session, you will follow these steps yourself by analyzing electric pulses from an oscilloscope, reconstructing an image from a data file and quantifying some important parameters like position resolution and noise.

Exercise instructions:

1. Download the Exercises_files.zip and extract the files
2. Upload files to SWAN (https://swan.cern.ch) for CERN users or Google Colab (https://colab.research.google.com) if you do not have CERN account. You will see 5 different files:
   • 4 .csv files with data for the exercises
   • Student Version.ipynb, with the guided exercises;
   • Solutions.ipynb - if you want to do the exercises on your own, do not open this file for now.
3. Open Student Version.ipynb and follow the instructions.
4. When finished or if stuck, check Solutions.ipynb for the answers.

Speaker: Rita Roque (University of Coimbra)

Exercises_files.zip

Recording

Wednesday, 30 September

14:00 → 15:00 Computational fluid dynamics for physicists and engineers (lecture)

Computational fluid dynamics(CFD) is an interdisciplinary approach involving Physics and Computer Science which deals with solving the governing equation of fluid flow. With the increasing advancement of technology, CFD has gained a lot of popularity in wide ranging topics of Physics and Engineering.

In this lecture we will look into the basic idea behind CFD, the conservation system of equations governing fluid dynamics, physical domain and equation discretization, use of numerical methods such as Finite difference and Finite volume methods, different boundary conditions and Reimann solvers.

Speaker: Ruchi Mishra (Nicolaus Copernicus Astronomical Center)

Recording

Ruchi Mishra Computational fluid dynamics for physicists and engineers.pdf

15:00 → 15:10 Group photo

We will want to take a "group photo" of the school - a picture of the participants connected to the Zoom room. This group photo, containing a lot of small but recognizable pictures of individual participants, will afterwards be published on the school website.

• If you want to be part of it, please enable your camera (or set up a Zoom profile picture) when we will be taking the group photo (technically, screenshots of the Zoom gallery view).

• If you prefer not to be included in this group photo, please just keep your camera off, and have no Zoom profile picture set up.

In any case, your name will not appear in the final edited group photo.

iCSC 2020 group photo.png

15:10 → 16:10 Big Data technologies and distributed data processing with SQL (lecture)

The interest of many users communities in solutions based on the Big Data ecosystem such as Hadoop is constantly increasing at CERN, including physics experiments, monitoring, and accelerator controls.

This lecture will introduce the participant to some of the Big Data technologies that CERN offers for distributed processing. It will cover some history, architecture, and specifics of selected technologies such as the Hadoop, Spark, and Presto for SQL-like data processing.

Moreover, this talk will cover the example of using the Big Data tools to speedup some computations on hundreds of terabytes of events coming from the Atlas experiment at CERN.

Speaker: Emil Kleszcz (CERN)

Emil Kleszcz_Big Data technologies and distributed data processing with SQL__Inverted CERN School of Computing 2020.pdf

Recording

16:20 → 17:20 Modern C++: Everything you (n)ever wanted to know about C++'s Lambdas (demo)

From a syntactical point of view, the Lambda expression of C++ is nothing but syntactic sugar of a struct with an appropriate call operator overload. On the other hand, this simple syntax is shockingly flexible and allows powerful abstractions in a functional way, while providing elegant and easy to read code in a language that is notoriously famous for being unnecessary clunky and verbose.

I will give an overview about the basic syntax and best practices. I will then talk about stateful Lambdas, Lambda inheritance and their real-world applications.

Speaker: Nis Meinert (German Aerospace Center (DLR))

cpp_lambda_exercise.pdf

Recording

Thursday, 1 October

14:00 → 15:00 Heterogeneous computing: Introduction to OpenCL for FPGAs (lecture 1)

This seminar introduces OpenCL as a heterogeneous programming language. We will analyze the structure of an OpenCL program and how to handle the different elements of OpenCL. Examples of parallel computing are presented to illustrate how to write computing programs in OpenCL. Finally, we discuss how these concepts have to be translated into the FPGA context to achieve high performance.

The exercises expand the concepts with example programs. The examples help to understand the role of the host program to allocate memory, schedule tasks, and execute kernels in the OpenCL device. More advanced examples explain optimization decisions made due to hardware particularities.

Speaker: Miguel Astrain Etxezarreta (Universidad Politécnica de Madrid)

Miguel Astrain_OpenCL for FPGA.pdf

Recording

15:10 → 16:10 Modern C++: Demystifying Value Categories in C++ (lecture 1)

Value categories are omnipresent in today's C++ code bases. Since the advent of move semantics the field continuously becomes wider and knowing terms such as lvalue and rvalue only from compiler error messages is not enough anymore.

I will present an overview about C++ value categories and decay rules, the subtle difference between pointers and references, explain why neither std::move moves, nor std::forward forward values and talk about implication on related topics such as RVO.

Speaker: Nis Meinert (German Aerospace Center (DLR))

cpp_valcat.pdf

Recording

16:20 → 16:50 Big Data technologies and distributed data processing with SQL (exercise consultation)

The interest of many users communities in solutions based on the Big Data ecosystem such as Hadoop is constantly increasing at CERN, including physics experiments, monitoring, and accelerator controls.

This lecture will introduce the participant to some of the Big Data technologies that CERN offers for distributed processing. It will cover some history, architecture, and specifics of selected technologies such as the Hadoop, Spark, and Presto for SQL-like data processing.

Moreover, this talk will cover the example of using the Big Data tools to speedup some computations on hundreds of terabytes of events coming from the Atlas experiment at CERN.

Speaker: Emil Kleszcz (CERN)

Recording

17:00 → 17:30 Programming Paradigms and Software Design Patterns (exercise consultation)

Ever been to the point where even little improvements require large refactoring efforts or dirty hacks? If only one had made the right choices on the way!

This course discusses programming paradigms (functional vs object oriented, imperative vs declarative programming, ...) and introduces common design patterns (reusable solutions to common problems). While theory alone is unlikely to make you a better developer, having an overview of common principles paired with the vocabulary to describe them will make it easier to come up with the right solutions.

In the exercises, we refactor various code snippets using the ideas of the lecture. Different approaches and their applicability to HEP problems are being discussed. Basic familiarity with Python is advised for the exercises.

This series is aimed at scientists with little formal training in software engineering, but veterans are always welcome to join for additional input in the discussions!

Speaker: Kilian Lieret (Ludwig Maximilian University)

Recording

Friday, 2 October

14:00 → 15:00 Heterogeneous computing: Introduction to OpenCL for FPGAs (lecture 2)

This seminar introduces OpenCL as a heterogeneous programming language. We will analyze the structure of an OpenCL program and how to handle the different elements of OpenCL. Examples of parallel computing are presented to illustrate how to write computing programs in OpenCL. Finally, we discuss how these concepts have to be translated into the FPGA context to achieve high performance.

The exercises expand the concepts with example programs. The examples help to understand the role of the host program to allocate memory, schedule tasks, and execute kernels in the OpenCL device. More advanced examples explain optimization decisions made due to hardware particularities.

Speaker: Miguel Astrain Etxezarreta (Universidad Politécnica de Madrid)

Miguel Astrain_OpenCL for FPGA.pdf

Recording

15:10 → 16:10 Modern C++: Demystifying Value Categories in C++ (lecture 2)

Value categories are omnipresent in today's C++ code bases. Since the advent of move semantics the field continuously becomes wider and knowing terms such as lvalue and rvalue only from compiler error messages is not enough anymore.

I will present an overview about C++ value categories and decay rules, the subtle difference between pointers and references, explain why neither std::move moves nor std::forward forwards values, and talk about implication on related topics such as RVO.

Speaker: Nis Meinert (German Aerospace Center (DLR))

cpp_valcat_booklet.pdf

cpp_valcat.pdf

Recording

16:20 → 16:50 Heterogeneous computing: Introduction to OpenCL for FPGAs (demo)

This seminar introduces OpenCL as a heterogeneous programming language. We will analyze the structure of an OpenCL program and how to handle the different elements of OpenCL. Examples of parallel computing are presented to illustrate how to write computing programs in OpenCL. Finally, we discuss how these concepts have to be translated into the FPGA context to achieve high performance.

The exercises expand the concepts with example programs. The examples help to understand the role of the host program to allocate memory, schedule tasks, and execute kernels in the OpenCL device. More advanced examples explain optimization decisions made due to hardware particularities.

Speaker: Miguel Astrain Etxezarreta (Universidad Politécnica de Madrid)

Recording

16:50 → 17:00 Closing remarks

Speaker: Sebastian Lopienski (CERN)

2020.10.02 iCSC-2020 Closing remarks.pdf

2020.10.02 iCSC-2020 Closing remarks.pptx

Recording