Meeting Embedded and Meeting C++ 2018

Contents[Show]

Last week I was at two conferences in Berlin: Meeting Embedded and Meeting C++. Here are my impressions from both conferences.

 

Meeting

Meeting C++ is with the CppCon the most important C++ conference worldwide. It started 2012, and it went this time from Thursday to Saturday. One day before, Jens launched his new conference Meeting Embedded.

Meeting Embedded

This conference had one track and, besides the keynote, the talks were 35 minutes long.

Keynote by Dan Saks: Writing  Better Embedded Software

DanSaks 200

Dan Saks is well known in the C++ community. He is a C++ consultant and trainer since the 80ths. Dan is in particular known because he was the first secretary of the C++ Standards committee and he wrote about 400 articles to C++ in the embedded domain.

Due to his experience, Dan talks about teaching C++ to people who are C developers. The first observations he made was that the most embedded programmer have no software but an electrical engineer background and C knowledge. This may be the reason that their primary focus is to get the stuff to run. Afterwards they can do the real work: debugging. This is different from the mindset of the C++ programmers: Compile and run. Meaning, C++ programmers are focused on type-safe code such that a possible error will be detected by the compiler.

When the C programmer switch from C to C++, his main concern is not what he gains(templates, object-orientation) but what he losses. Due to his experience, he changed its approach to teach C++ and makes now a slow progress. Meaning, Dan, for example, explains the benefits of user-defined types and a type-safe pointer to functions from the interrupt pointer table.

Here are the last perls of wisdom from Dan. Embedded developer have a greater concern about hardware and are aware of resource constraint. You should apply steady, gentle pressure to improve their software. The main goal should be: transform runtime errors to compile time errors.

For me, this was an extraordinary precious talk because my day to day job is it, to teach embedded people to use C++. In case you work in a similar environment, this is just a must watch talk.

To get a better idea of Meeting Embedded here are the remaining talks:

  • Continuous Integration of C/C++ for embedded and IoT with Jenkins, Docker and Conan by Diego Rodriguez-Losada and Daniel Manzaneque
  • We stopped teaching C by Wouter van Ooijen
  • The Core Guidelines for Safer Code by Rainer Grimm
  • std::map<code,performance> myMCU{?} by Daniel Penning
  • Remoteprocs in Rust by Jonathan Pallant
  • How to mock in the 21st Century by Paul Targosz
  • Spread the Love for IoT - How I Created a Full-Day IoT Workshop by Dafna Mordechai
  • A Possible Future of Embedded Software Development by Odin Holmes
  • Turning MQTT v5 inside out by Maurice Kalinowski

Meeting C++

First of all. Meeting C++ went from Thursday to Saturday. It had 44 talks in for tracks, three keynotes by Andrei Alexandrescu, Lisa Lippincott, and Nicolai Josuttis. Nicolai also gave a pre-conference workshop to modern C++ template programming. Here is the exact schedule: Schedule of Meeting C++2018.

Here are a few impressions of the talks. 

First, I have to write about the keynote from Andrei. Andrei is well known in the (C++) community for being the author of Modern C++ Design. This book was published 2001 and was the starting point for policy-based design in C++.

The Next Big Thing by Andrei Alexandrescu

andreialexandrescu

Disclaimer: I don't totally agree with the prediction he made about the future of programming in C++ but I enjoy his way of reflecting about the way we program.

Okay, now you know it. Andrei made a prediction of the future regarding in particular C++.

The first observation he made was that our code size is growing bigger and bigger. But there is an issue with code size. Indepent of the programming language used, we can expect 10 - 15 error per 1000 lines of codes; therefore, a big code size is bad. Now, the question is: How can we fight our code size? Three answers are on the horizon.

  1. Concepts
  2. Metaclasses
  3. Introspection

Andrei's observation is that neither concepts nor metaclasses will decrease our code size. Both are not part of the solution but part of the problem. Introspection or as he called it Design by Introspection (DbI) is the only viable way. Design by Introspection is a technique to assemble the entire system by adaptable components. This means, you fight the combinatorial complexity of the world by arbitrary combinatorial components which you can stick together. 

Design by Introspection has a history.

  1. Interfaces used in object orientation helps to fight the combinatorial explosion, but cannot be reused. Design Pattern encapsulates this idea.
  2. Policy-based design, which was invented by Andrei in his already mentioned book Modern C++ Design. They are a kind of semi-automatic design pattern, assembled at compile out of templates. They provide code reuse.

Andrei answered the questions: What are the prerequisites of DbI?

  • Input:
    • What are the methods of an object? Or: Does the object support the method xyz?
    • Does this code compile?
  • Processing :
    •  Evaluate arbitrary expressions a compile-time.
  • Output:
    • Generate arbitrary code at compile-time.

In the end, Andrei presented checked integrals, written in the programming language D.

I want to emphasise it once more. Andrei's talk was my favourite one. First, it was very entertaining and, second, it was very enlighting.

Have to watch

From now one, I will make it short. Here are the talks you should listen if they are available online. All talks form Meeting Embedded and from Meeting C++ were recorded and will be published here: Meeting Cpp - YouTube.

  • Regular Types and Why Do I Care ? by Victor Ciura: My next post is about regular and semiregular types; therefore, you have to be patient for one week.
  • Taming Dynamic Memory - An Introduction to Custom Allocators by Andreas Weis: Andreas presented very well all that you want to know about different allocators. This includes in particular, their pros and cons. To be honest, I learned a lot about allocators.
  • Coroutine TS: A new way of thinking by Andreas Reischuck: Andreas gave a quite nice and easy to get introduction in coroutines. His introducion was based on generators, a state machine, and asynchronous calls.
  • Keynote:  50 shades of C++ by Nicolai Josuttis: C++ is a successful programming language with more than 40 years, driven by a community of volunteers. Nicolai presented very well which challenges arise out of this constellation.

Here is my talk: Best Practices for Concurrency (Or: What went wrong in the last 10 years during my classes.)

Last words

As ever, Meeting C++ was a hug but astonishingly familiar conference and I enjoyed the personal conversations between or after the talks at most. My thanks go to Jens and his team.

What's next?

 I think you already know. The next post will be about regular and semiregular types.

 

Thanks a lot to my Patreon Supporters: Eric Pederson, Paul Baxter,  Meeting C++, Matt Braun, Avi Lachmish, Roman Postanciuc, Venkata Ramesh Gudpati, Tobias Zindl, Dilettant, Marko, and Ramesh Jangama.

Thanks in particular to:  TakeUpCode 450 60

 

Get your e-book at Leanpub:

The C++ Standard Library

 

Concurrency With Modern C++

 

Get Both as one Bundle

cover   ConcurrencyCoverFrame   bundle
With C++11, C++14, and C++17 we got a lot of new C++ libraries. In addition, the existing ones are greatly improved. The key idea of my book is to give you the necessary information to the current C++ libraries in about 200 pages.  

C++11 is the first C++ standard that deals with concurrency. The story goes on with C++17 and will continue with C++20.

I'll give you a detailed insight in the current and the upcoming concurrency in C++. This insight includes the theory and a lot of practice with more the 100 source files.

 

Get my books "The C++ Standard Library" (including C++17) and "Concurrency with Modern C++" in a bundle.

In sum, you get more than 600 pages full of modern C++ and more than 100 source files presenting concurrency in practice.

 

Get your interactive course

 

Modern C++ Concurrency in Practice

C++ Standard Library including C++14 & C++17

educative CLibrary

Based on my book "Concurrency with Modern C++" educative.io created an interactive course.

What's Inside?

  • 140 lessons
  • 110 code playgrounds => Runs in the browser
  • 78 code snippets
  • 55 illustrations

Based on my book "The C++ Standard Library" educative.io created an interactive course.

What's Inside?

  • 149 lessons
  • 111 code playgrounds => Runs in the browser
  • 164 code snippets
  • 25 illustrations

Add comment


Subscribe to the newsletter (+ pdf bundle)

Blog archive

Source Code

Visitors

Today 1412

All 1407600

Currently are 189 guests and no members online

Kubik-Rubik Joomla! Extensions

Latest comments