ACCU 2017 Full-day Pre-Conference Workshops

In this tutorial workshop, I’ll present an introduction to Chapel through a combination of short presentations and hands-on programming sessions (i.e., bring your laptop!).

Over the course of this workshop, you’ll be introduced to Chapel’s unique language features for tasking and data parallelism, as well as those for specifying locality and affinity to enable scalability on clusters, the cloud, and HPC systems. I’ll also provide a brief introduction to Chapel’s rich base language, designed to simplify serial programming as in modern scripting languages (e.g., Python) while preserving the performance and type safety properties of traditional languages like C and C++.

In the hands-on sessions, you’ll be free to explore Chapel features through a combination of prepared exercises and/or free-form programming – on your laptop and, with luck, even a modern Cray system.

The fine print: Chapel requires a C++ compiler, POSIX threads, and a UNIX-like environment. Thus, attendees with Linux/*nix, MacOS, or Windows 10 with the Linux bash shell will have the best results. Alternatives include ssh-ing into such a system, Docker, or Windows with Cygwin. In short, if you arrive with access to a system (local or remote) where you can do a 'make'-based compile of a C/C++ hello world, you should be good to go.

Brad Chamberlain is a Principal Engineer at Cray Inc. where he works on parallel programming models. He serves as the technical lead for the Chapel project which is developing a portable, open-source language for parallel programming on large-scale systems. In this role, Brad focuses primarily on leading the design and implementation of the Chapel language with his team at Cray and members of the open-source development community. Brad received his Ph.D. in Computer Science & Engineering from the University of Washington in 2001 working on the ZPL parallel array language. In the past, he has also worked on languages for embedded reconfigurable processors and on algorithms for accelerating the rendering of complex 3D scenes.

If you want to get best performance on today’s hardware, and you are not just working with the GPGPUs, using the multiple cores of the (possibly multiple) CPU is effectively mandatory. Thus for best performance software you have to write concurrent (and parallel) code. But writing concurrent code is hard. Writing concurrent code that is correct and has minimal contention is even harder.

In this hands-on tutorial we will see how to utilise available CPU cores efficiently in a simple way by using higher level abstractions like futures and CSP channels, instead of manually managing threads and using other low level synchronization primitives such as atomics and mutexes.

We will not dive into lock free data structures, sequential consistency, or ABA problems, etc. Instead, after laying some theoretical foundations, we will start with simpler problems, advance to complex use cases and then move on to abstraction techniques to write safe, readable, and fast code. You are encouraged to bring problems from your domain so that we can together discuss them.

The content of the tutorial is a follow up on Sean Parent’s concurrency talks in his series of goals for better code. We will utilize an open source library that he and I have developed.

You will need to bring a laptop with these minimal requirements: a recent C++14 compliant compiler (clang 3.7, gcc 6.1, or Visual Studio 2015 Update 3), boost 1.60.0 and cmake 3.5.1.

Felix Petriconi is working as professional programmer since 1993 after he had finished his study of electrical engineering. He started his career as teacher for intellectually gifted children, freelance programmer among others in telecommunication and automotive projects. Since 2003 he is employed as programmer at the MeVis Medical Solutions AG in Bremen, Germany. He is part of a team that develops and maintains radiological medical devices. His focus is on C++ development, training of modern C++, application performance tuning and process improvement. He is a regular speaker at the C++ user group in Bremen, a blog editor at https://isocpp.org and became recently a member of the ACCU’s conference committee.

C++17 is the next evolution in modern C++ programming. Although it is not as big a step as C++11, it contains a large number of small and valuable language and library features, which will change the way we program in C++.

This one-day tutorial presents all the new language and library features in C++17. We’ll cover the motivation and context of each new feature with examples and background information. We’ll focus on how these features impact day-to-day programming and how to benefit from them in practice.

Contents:

Nicolai Josuttis (www.josuttis.com) is an independent systems architect, technical manager, author, and consultant. He designs mid-sized and large software systems for the telecommunication, traffic, finance, and manufacturing industries.

He is well known in the C++ Community for speaking and writing with authority about C++ (being the author of 'The C++ Standard Library' and 'C++ Templates') but is also an innovative presenter. He is an active member of C++ standardization committee for almost 20 years now.

Automated tests and executable specifications can only work with software that has a testable architecture.

A testable architecture enables fast and reliable tests that are easy to write, execute and maintain. Many organisations have the opposite – slow and unreliable tests that are difficult to write and expensive to maintain.

During this workshop, we will teach you how to decouple your domain logic from your infrastructure so that you can test at different levels, with maximum confidence and minimum cost.

You will learn advanced techniques such as ports and adapters (hexagonal architecture), contract testing and test pyramid – all essential for a testable architecture.

You will learn how these techniques can be applied to different kinds of architectures such as microservices, SOA or monolithic systems.

The practical work will be carried out using Cyber-Dojo, an online training environment – all that is needed is access to a modern web browser. Delegates will work in pairs, so not everyone will need to bring their own laptop. The training material will be available in C++, C# and Java.

Learning Outcomes:

Seb Rose

Consultant, coach, designer, analyst and developer for over 30 years.

Seb has been involved in the full development lifecycle with experience that ranges from Architecture to Support, from BASIC to Ruby. He’s a partner in Cucumber Limited, who help teams adopt and refine their agile practices, with a particular focus on collaboration and automated testing.

Regular speaker at conferences and occasional contributor to software journals. Contributing author to “97 Things Every Programmer Should Know” (O’Reilly) and lead author of “The Cucumber for Java Book” (Pragmatic Programmers).

He blogs at cucumber.io and tweets as @sebrose.

Jon Jagger

I’m a software consultant specializing in practice, process, test driven development, and complex-adaptive systems-thinking. Hire me! I’m 30 years old (hex) and I’ve loved software since I was 10 (decimal). I built cyber-dojo.org to promote deliberate practice for software developers. I’ve worked with Accenture, Aviva, Cisco, Ericsson, Friends Provident, HP, Microsoft, Opera, Ordnance Survey, RBS, Reuters, Renault F1, Schlumberger, Tandberg and many many more. If you don’t like my work I won’t invoice you. I’m the co-author (with Olve Maudal) of the Deep C/C++ slide deck (over 600,000 views) I’m the ex ECMA Task Group 2 C# convenor. I’ve had some C# books published. I’m the ex ACCU conference chairman. I’m married to the beautiful Natalie, and proud father of Ellie, Penny and Patrick. I love coarse fishing and salmon fishing. I live in Somerset, England. On twitter I’m @JonJagger