Report from using std::cpp 2019

On March, 7th, we had the sixth edition of using std::cpp (the C++ conference in Spain). The conference was again a on-day free event, and as every other year it was hosted at the Higher Polytechnic School of University Carlos III of Madrid in Leganés.

As many other years roughly 200 participants attended the conference. Most of the attendees were coming from industry.

Who attended using std::cpp 2019?

Around 75% of attendees were from the Madrid region. However, we had attendees from many other areas in Spain (Andalucía, Aragón, Asturias, Balearic Islands, Cannary Islands Castilla y León, Castilla La-Mancha, Catalonia, Valencia, and Basque Country). We als hand around 5% of international participants (Netherlands, United Kingdom, US, Germany, Norway, and Switzerland).

Alomost 84% of attendees were coming from industry.Employers included the following companies: Airbus Defence & Space, Allot, Almis, ArcelorMittal, Arena Consulting, BBVA, Bloomberg LP, BME, Boeing Reasearch & Technology Europe, Booking.com, BSH, Bytech, Coralbits, RTVE, Dassault Systèmes, Desilico Labs, Eagle Telecom, Electronic Arts, Embention, Ericsson, GMV, Grupo R. Franco, GTD, Hotelbeds, IBM Research, IMV, Indizen, Indra, ING, Inntech, Instituto de Astrofísica de Andalucía,  JFrog, JLG Consulting, Lely Industries, MCA, Next Limit Technologies, Nova Notio, On-Dev, Perforce, Proinelca Power, Quasar science resources, S.L., Saber Interactive, Securitas Direct, Sener, Siemens, Te Graffter, Tecteco Security System, Tenokonda, TICSoluciones, Tool, Ubisoft, AmcoSystems, UST Global, Velneo, S.A., Verisure Smart Alarms, Viewtinet Wake Engineering, Werfen Clinical Software, Zhilabs.

10% of them were academics and 6% were students. This included the following universities: University Carlos III of Madrid, Universidad Complutense de Madrid, UNED, Universidad de Alicante, Universidad de Castilla-La Mancha, Universidad de Granada, Universidad Politécnica de Madrid, Universidad Rey Juan Carlos.

We used the evaluation forms to get some information that might be of general interest for the C++ community. Most people (87%) use C++ on a daily basis. We made some questions to industrial attendees. These are the highlights:

  • We tried to understand which versions of the C++ standard they are using. People could make multiple choice to this question. Compared to the answers in 2016 we found that the use of C++11 is stable (70% now versus 74% in last edition). However use of C++98/03 is decreasing (37% now versus 48% in last edition) and C++14 is stable (38,9 % versus 39.2% in last edition). This time, we also asked about C++ 17 (22% now).
  • We also asked about the compilers people were using. GCC got 72.2% (78.8% previous edition), Microsoft got 57.4% (51.2% previous edition), clang++ got 35.2% (35% last edition), Intel C++ got 13% (7.5% last edition). Other compilers reported include IBM XL C++, Sun Oracle C++, Embarcadero C++, and Texas Instruments.
  • Most popular platforms were GNU/Linux 83% (75% last edition), Windows 69% (61.3% last year), MacOS 18.2% (18.8% last edition), Android 9.1% (13.8% last edition), Solaris 9.1% (11.3%  last edition) and iOS 9.1% (7.5%  last edition). Besides that, we also had some individuals working on Arduino, Texas Instruments, ARM, and video-consoles.

Note that this statistics do not mean that we detected any significant trend and might well be derived in a change of our audience.

We also tried to segment our audience by industry:

  • Aerospace / Air Traffic: 20.4%.
  • Finance: 16.7%.
  • Telecommunications: 9.3%.
  • Developer Tools: 9.3%.
  • Security: 7.4%.
  • Research: 5.6%.
  • Tourism: 3.8%.
  • Video-games: 3.7%.
  • Naval: 3.7%.
  • Textile: 1.9%.
  • Government: 1.9%.
  • Consumer Electronics: 1.9%.
  • Internet of Things: 1.9%.
  • Robotics: 1.9%.
  • Healthcare: 1.9%.
  • Transport: 1.9%.
  • Civil Engineering: 1.9%.
  • Industrial manufacturing: 1.9%.
  • Defense: 1.9%.
  • Banking: 1.9%.

As you may see C++ is locally used in many different sectors.

Our talks in using std::cpp 2019

Here is a summary of the talks we had this year. A major change in this edition is that we decided to switch to offer talks in English. Given the success we plan to  keep a wide offering of talks in English.

Here are the talks we had this years. All the videos are available in our YouTube channel. We have a playlist for using std::cpp 2019.

After going through the evaluation forms, this year we have had a tie in the best talk award that goes ex aequo to Axel Naumann (for Reflecting C++) and Joaquín M. López (for Some fun with reactive programming in c++17). Congratulations to both of you, Axel and Joaquín. We hope to see you again here next year!

Acknowledgments

We want to thank many people who helped to make using std::cpp again a reality. First of all, thanks to the audience. Without all of you this full day event around C++ would be nonsense. We hope you got valuable ideas for your work.

Our thanks also go to our gold sponsor Indizen and our silver sponsors Think-cell and Conan/JFrog. Their support was essential for supporting the lunch and coffee breaks, as well as to support some invited speakers.

We also want to express our gratitude to JetBrains. Again this year they have contributed by giving a number of licenses of CLion that we have given out in a draw. The same gratitude goes to Manning books. They contributed with a number of e-books of the great book C++ Concurrency in Action that were also given out in a draw.

We also want to express our thanks to our speakers. They were key to attract the audience. We hope that all the effort they made preparing their talks and coming to Madrid was worth. We hope to see them again in the next edition.

Finally, we want to thank to the volunteers who helped in the organization.

Gold Sponsor:

Indizen

Silver Sponsors:

Conan             Think-Cell

With the cooperation of:

JetBrains
Manning

Publicado en eventos, Sin categoría, Trip Reports

using std::cpp conference becomes bilingual (and remains free)

Yes you got it. The spanish C++ one-day conference, using std::cpp, will be bilingual this year.

The conference will be having this year its 6th edition. The event will be on March 7th 2019 in Madrid. And this year there will be a number of talks in English.

  • Long talks (40 min.): 6 in English and 1 in Spanish
  • Short talks (20 min.): 1 in English and 3 in Spanish
  • Flash talks (5 min.): 2 in English.

As the reader can notice more of the half of the one day conference is offered in English.

Speakers in using std::cpp 2019 include among others Arno Schödl (Think-Cell Software), Guy Davidson (Creative Assembly), Axel Naumann (CERN), Joaquin M. López (author of Boost libraries MultiIndex, Flyweight, PolyCollection) and J. Daniel Garcia (ISO C++ committee member).

You can access the full program here.

The C++ conference using std::cpp 2019 will be hosted at University Carlos III of Madrid, in Leganés. It is a free event, but registration is needed. You can register for the conference here.

Organized by:

          

Gold Sponsor:

Indizen

Silver Sponsors:

Conan             Think-Cell

With the cooperation of:

JetBrains
Manning

Publicado en cpp-posts, eventos, Lenguaje C++

Conferencias de Bjarne Stroustrup en Madrid

El próximo día 25 de enero tendrá lugar la investidura como Doctor Honoris Causa por la Universidad Carlos III de Madrid, del profesor Bjarne Stroustrup, creador del lenguaje de programación C++.
Con este motivo, hemos preparado dos conferencias, que espero que sean de vuestro interés para el jueves 24 de enero.
Las conferencias tendrán lugar en la Escuela Politécnica Superior de la Universidad Carlos III de Madrid, en Leganés.
IMPORTANTE: Es necesario inscribirse para asistir ya que el aforo es limitado.
Además, aprovecho la ocasión para recordaros que el día 22 de enero, se celebra en Madrid un meetup de C++, donde el Profesor Bjarne Stroustrup impartirá otra conferencia. Toda la información sobre dicho evento la puedes encontrar aquí: https://www.meetup.com/es-ES/Madrid-C-Cpp/events/257896267/
Publicado en cpp-posts, eventos, Lenguaje C++

Nuevo curso: Programación avanzada en C++ – C++11/14/17

La fundación Universidad Carlos III de Madrid, organiza un curso avanzado de C++. Este curso está dirigido a desarrolladores con experiencia que quieren actualizarse a las últimas versiones del lenguaje.

Toda la información del curso se puede obtener en el siguiente enlace.

El curso está estructurado en cuatro módulos:

  • Parte I: Lenguaje.
  • Parte II: La biblioteca estándar.
  • Parte III: Concurrencia.
  • Parte IV: Introducción a C++17.

El curso se celebra en marzo, pero la inscripción ya está abierta y las plazas son limitadas.

Publicado en eventos, Lenguaje C++, misc

Using std::cpp está de vuelta y sigue siendo gratis

Si. Ya lo sabemos. Todos esperabais que en noviembre nos viésemos otra vez en la Universidad Carlos III de Madrid (como todos los años) para la sexta edición de vuestra conferencia favorita sobre C++. Sin embargo, no va a ser así, porque hemos retrasado la fecha de la conferencia.

Sin embargo, tenemos dos buenas noticias: using std::cpp va a seguir siendo un evento gratuito y ya tenemos fecha para el evento.

Seguimos siendo un evento gratuito

Después del año pasado hemos estado considerando la posibilidad de hacer de using std::cpp un evento con una cuota de inscripción. Había varias razones para ello: como poder mejorar la calidad del evento, financiar viajes de ponentes internacionales, o evitar que personas se registren y luego cancelen su asistencia en el último minuto.

Sin embargo, vamos a mantener este año el evento en su formato tradicional y como un evento gratuito. Intentaremos suplir esto con la búsqueda de más patrocinadores. Dependiendo del nivel de patrocinio que consigamos, podremos hacer más o menos cosas.

Pero necesitamos patrocinadores

Así que ya sabes. Si has venido otros años. Si crees que este evento es útil, quizás puedas convencer a tu empresa para que colabore como patrocinador de using std::cpp 2019.

Y ya tenemos fecha

Si. Ya tenemos fecha. La conferencia en España de C++ será el jueves 7 de marzo en el mismo lugar que siempre (la Escuela Politécnica Superior de la Universidad Carlos III de Madrid)

Publicado en eventos, Lenguaje C++

Ofertas de empleo interesantes en GMV

Me han llegado dos ofertas de empleo interesantes en la empresa GMV.

Oferta 1: https://www.gmv.com/es/Empleo/Vacantes/827.html

Ingeniero Simulación Misiones Espaciales • Descripción: “Ingeniero de proyecto encargado de desarrollar elementos software (C/C++, Matlab) para la simulación de misiones espaciales de observación de la Tierra (instrumentos, entorno, procesado de datos). La plaza requiere la capacidad de entender, analizar, mejorar y, en algunos casos, diseñar algoritmos físicos complejos para luego implementarlos en C/C++ o Matlab. Las tareas principales que deberá realizar el candidato seleccionado son:

  • Análisis de documentación técnica describiendo la funcionalidad a simular relacionada con la misión espacial.
  • Análisis y/o definición de algoritmos que permiten simular la misión o Codificación y pruebas unitarias en C/C++
  • Matlab de esos algoritmos. o Integración y orquestación de los algoritmos en una o varias aplicaciones.
  • Integración y validación de aplicaciones externas.
  • Pruebas de sistema.
  • Documentación de todo el proceso (desde requisitos/diseño a informes de validación).
  • Formación: Físico, Ingeniero de Telecomunicaciones
  • Aeronaútico, Ingeniero Informático
  • Experiencia: 0-3 años
  • Conocimientos necesarios: C/C++ (medio), Unix (medio), Matlab (medio), Teoría de la señal (medio), Inglés (avanzado)
  • Conocimientos valorados: Misiones Espaciales (básico), Instrumentos de Observación de la Tierra (básico)

Oferta 2: https://www.gmv.com/es/Empleo/Vacantes/818.html

Ingeniero SW para Instrumentos Espaciales • Descripción: “Ingeniero de proyecto encargado de desarrollar elementos software en C/C++ para la simulación de cargas de pago de misiones espaciales de observación de la Tierra. La plaza combina habilidades de ingeniería del software que permitan generar código C/C++ eficiente (los requisitos de carga computacional y prestaciones son estrictos), con la capacidad de entender y analizar algoritmos físicos complejos. Las tareas principales que deberá realizar el candidato seleccionado son:

  • Diseño de arquitecturas software eficientes para el desarrollo de librerías y aplicaciones.
  • Codificación y pruebas unitarias en C/C++ de algoritmos bien definidos y de las librerías de infraestructura necesarias para el sistema.
  • Integración y orquestación de las algoritmos en una aplicación monolítica, incluyendo entrada/salida de ficheros.
  • Pruebas de sistema.
  • Documentar los resultados de la validación y corrección de no conformidades.
  • Formación: Ingeniero Informático, Ingeniero de Telecomunicaciones o Aeronaútico, Físico
  • Experiencia: 2-5 años
  • Conocimientos necesarios: C/C++ (avanzado), Computación Paralela (medio), Unix (medio), Matlab (medio), Inglés (avanzado)
  • Conocimientos valorados: Misiones Espaciales (básico), Instrumentos de Observación de la Tierra (básico)
Publicado en misc | Etiquetado , ,

Jacksonville’18 ISO C++ Report

This week the ISO C++ committee met in Jacksonville, Florida. This is the first meeting of this year. We will meet again in Summer (Rapperswil, Switzerland) and Fall (San Diego, California).

As you may well know the committee is working in what it will be C++20 (and deciding what could end up delayed for C++23).

Let me give a summary of some of the things we decided today in plenary. As always we decided to approve the resolutions solving a number of defect reports both in the library and in the language. Usually this are corner cases and leave to others (or to me in the future) to explain them.

In this post you will find information only about the language and the library for C`20. I defer reporting on TS (technical specifications) to a separate post.

C++20 Language

Language support for empty objects

A new attribute [[no_unique_address]] has been added to indicate that a unique address is not required for a non static data member. Such data member can the share its address with another object if it could have zero size (as in the empty base optimization) and both have distinct types:

template<typename Key, typename Value, typename Hash, typename Pred, typename Allocator>
class hash_map {
  [[no_unique_address]] Hash hasher;
  [[no_unique_address]] Pred pred;
  [[no_unique_address]] Allocator alloc;
  Bucket *buckets;
  // ...
public:
  // ...
};

Then hasher, pred, and alloc may have the same address than buckets (if they have zero size).

Relaxed support for range-based for loops

This solves corner cases for range-based for. Surprise or not, today you cannot write a range-based for loop over data coming for an input stream without writing some adaptor class. The problem is that seekdir::end is found and this makes impossible to properly find begin() and end().

This is an example of code that does not work in C++17, but will work in C++20.

struct X : std::stringstream { /*...*/ };

std::istream_iterator<char> begin(X& x) {
    return std::istream_iterator<char>(x);
}

std::istream_iterator<char> end(X& x) {
    return std::istream_iterator<char>();
}

int main() {
    X x;
    for (auto && i : x) {
      // ...	      
    }
}

Allow structured bindings to accessible members

C++17 introduced structured bindings making it possible to bind only to public data members. C++20 exteds this to the case of accessible data members. This solves problems with using them in friend functions.

struct A { 
  friend void f(); 
private: 
  int x; 
}; 

struct B : private A {
  friend void g();
};

void f() { 
  A a; 
  auto x = a.x; // OK 
  auto [y] = a; // Allowed by this change 
}

void f() {
  B b;
  auto x = b.x; // OK
  auto [y] = b; // Allowed by this change

This change also allows to class access its own data members through structured bindings:

class C {
  int x;
  void f(const C & c) {
    auto [x] = c; // Allowed by this change
  }
}

Note that this has been approved for C++20, but has been also marked as a defect report for C++17.

Relaxing the structured bindings customization point finding rules

This change solves another problem with structured bindings and the get() function that affects to classes that have a non templated get() member function. Note that this is the case of smart pointers.

With this change “if a member get() is found, it must be a member template to be used with a structured binding. If a get() that is not a template is found, that member is not used, and the lookup continues to try and find an ADL get<>().

Down with typename!

You may have got tired of writing typename in places where you think the compiler could do it for you. Have you been there?

Let me show an example from the new text in the standard:

template<class T> T::R f(); // OK, return type of a function declaration at global scope

template<class T> void f(T::R); // Ill-formed (no diagnostic required), attempt to declare a void variable template

template<class T> struct S {
  using Ptr = PtrTraits<T>::Ptr; // OK, in a defining-type-id
  T::R f(T::P p) { // OK, class scope
    return static_cast<T::R>(p); // OK, type-id of a static_cast
  }
  auto g() -> S<T*>::Ptr;  // OK, trailing-return-type
};

template<typename T> void f() {
  void (*pf)(T::X); // Variable pf of type void* initialized with T::X
  void g(T::X); // Error: T::X at block scope does not denote a type
                // (attempt to declare a void variable)
}

Allow pack expansion in lambda init-capture

You may have wanted to pass a variadic argument to lambda by capturing it by move. Now you can!

template <typename ... Args>
void f(Args ... args) {
  auto f = [...x = std::move(args)]() { return g(x...); };
  f();
}

Attributes for likely and unlikely

This is something that different compilers have been doing in a non-portable way. You can now mark which branch is likely to be executed to give that information to your optimizer.

if (a>b) [[likely]] {
  do_something();
}
else {
  do_other();
}

You can also optimize the common case in nested branches:

if (a>b) {
  if (c>d) [[likely]] {
    do_something();
  }
}

Or tell the compiler that a loop usually is not executed:

while (a>0) {
  [[unlikely]] g();
}

Or mark the most common case in a switch:

switch (x) {
  case one:
    f();
    break;
  case two:
    [[likely]] g();
    break;
  default:
    h();
}

Adding symmetry to operator <=> (aka spaceship operator)

You may be aware of operator<=> which allows you to define a single operator for all comparisons in a class.

Currently, if the language finds an expression like b<a (where b and a may be of different types), the following operations are matched:

  1. operator<(b,a) and b.operator<(a)
  2. operator<=>(b,a) < 0 and b.operator<=>(a) < 0
  3. 0 < operator<=>(a,b) and 0 < a.operator<=>(b)

This allows to provide a single definition of operator<=>. However, if the language finds an expression like b<=>a (even if a<=>b exists), this rule doesn’t apply. This can be seen as a lack of symmetry for operator <=> which has been corrected now.

C++20 library

A <version> header

This is a new header file with implementation-dependent version information. Just to clarify the information that you may find there might be different in each implementation and it will be related to your own vendor. Consequently, you do not need to go there to get any standard information.

In fact, there is no standard symbol defined in that header.

Comparing Unordered Containers

Current comparison of unordered containers is undefined unless Hash and Pred have exactly the same behavior for both containers. This implies that to different hash functions (for example, using different seeds) might lead to containers being different.

Hash has now being removed from the undefined behavior definition.

Extending <chrono> to Calendars and Time Zones

This is (to my view) a very important component of C++20 standard library. I am not going into details here as you may have a look to an implementation at https://github.com/HowardHinnant/date.

string::reserve Should Not Shrink

Until C++17 std::reserve(sz) might reallocate if the new size is smaller than the capacity. This brings a number of problems:

  • It may be a performance penalty.
  • It may cause portability problems.
  • Is inconsistent with behavior of std::vector.
  • Complicates generic code that wants to handle uniformly vector and string.

In C++20 std::reserve(sz) will never perform a shrink_to_fit(sz).

Thou Shalt Not Specialize std Function Templates!

Specializing entities from std has been strongly restricted:

  • Specializing function templates from the std namespace is not allowed.
  • Taking the address of a standard library function is not allowed.

Manipulators for C++ Synchronized Buffered Ostream

Three new manipulators have been added to be used with synchronized ostreams (basic_osyncstream):

  • emit_on_flush: Makes flushes to apply immediately.
  • noemit_on_flush: Make flushes to be postponed until an emit.
  • flush_emit: Flush all remaining information.

span: bounds-safe views for sequences of objects

Class span offers a view over a sequence that may live in an array or vector, but does not own such elements. Consequently, span does not perform any memory allocation or deallocation.

void f(span<int> s) {
  //...
}

void g() {
  int v[100];
  span<int,100> s{v};
  f(s);
}

Constexpr iterator requirements

Defines the concept of a constexpr iterator, which is an iterator whose operations are constexpr. This will allow that those containers providing constexpr iterators (e.g. std::array) may be used in constexpr functions.

Publicado en cpp-posts, misc, Sin categoría, Trip Reports