Emagister Eventos

using std::cpp 2020

  • Fechas:

    Del 16/04/20 al 16/04/20

  • Lugar:

    Universidad Carlos III de Madrid: Campus de Leganés - Salón de grados, edificio Padre Soler, Leganés, España (mapa)

Web del evento

Descripción ↑ subir


  • Due to the current situation with the COVID-19 we have decided to reschedule using std::cpp 2020 until October 2020.
  • When the new date has been set, we will open a new registration where all currently registered attendees will have high priority for the new registration.

using std::cpp 2020 is the largest Conference on C++ in Spain.

using std::cpp 2020 is supported by the Standard C++ Foundation.

It aims to serve as a forum to exchange experiences in the use of the C++ programming language, which pays special attention to last versions of the language, as well as upcoming features.

What is the target audience of using std::cpp 2020?

The event targets professional C++ developers using C++ as an application development language or to build software infrastructure. It also targets undergraduate and graduate students at their final stage who are interested in using C++ as a programming language to build complex and high performance computing systems.

What is the program of using std::cpp 2020?

The program is available here.

Just visit our program section for using std::cpp 2019..

All talks are in English.

Do I have to register to attend using std::cpp 2020?

Yes. Attendance is abosolutely free, thanks to our sponsors.

However, registration is needed as we have limited places.

Registration is already open.




Lugar ↑ subir

Programa ↑ subir

Abr 2020
  • 09:00 - 09:30
  • 09:30 - 10:30
    Combining C++17 Features - Nicolai Josutis (Germany)

    C++17 is a remarkable collection of many features both in the core language and the library. But the real power comes by using them together. And after 3 years of experience, we know enough to give good examples and advice.

    This talk will show some code examples combining various C++17 features. From this, you will get an idea of how powerfull C++17 really is.

  • 10:40 - 10:50
    C++ into a Banking Scene - Jose Luis Pichel (Arena Tech - Spain)

    Where and why is used C++ in the Banking environment. Use cases of the big players and a simple approach to a possible future in the short term.

  • 10:50 - 11:30
    Serverless & C++ in AWS - Javier Ramirez (Amazon Web Services, Spain)

    Serverless is the native architecture of the cloud that enables you to shift more of your operational responsibilities to the cloud, increasing your agility and innovation. Serverless allows you to build and run applications and services without thinking about servers. It eliminates infrastructure management tasks such as server or cluster provisioning, patching, operating system maintenance, and capacity provisioning. You can build them for nearly any type of application or backend service, and everything required to run and scale your application with high availability is handled for you. Does it sound good? In this session we will learn how to deploy serverless C++ applications using the AWS Lambda C++ Runtime API. We will also show how to call AWS Services from your C++ functions.

  • 11:30 - 12:00
  • 12:00 - 12:40
    The state of the /*union*/ variant - Odin Holmes (Germany)

    I'm not convinced that std::variant is done. After a brief summary of key design decisions and other work in the same problem space I will highlight where I have had difficulties with the current std::variant in my code and explore alternative implementations that may work better. I will present a strategy for the positional association of variant alternatives with corresponding functions as opposed to a classic overload set approach to visitation and discuss its pros and cons in different scenarios as well as how it could be added to the standard library.

  • 12:50 - 13:10
    Enterprise C++ toolchain or why is it hard - Seraphime Kirkovski (VMWare, Bulgaria)

    Reproducible builds are an essential topic for any commercial software vendor. The requirements for assuring those make organizations take architectural decisions that impact deeply the future of their products for years. This is an exploration in what it takes to design, create and maintain a complete C++ toolchain without breaking the back of the organization with legacy.

  • 13:30 - 15:00
  • 15:00 - 15:40
    Ranges 102 - Joaquin M. López (Spain)

    C++20 Ranges have arrived in town! Come with us on a walktrough of this new addition to the standard and learn how to use ranges, what their underpinning concepts are, what's so good about them and how you can begin using them now even before C++20-compliant compilers ship in. As a glimpse of what's ahead, we'll finish touching upon some new developments like coroutines, executors and sender/receivers, which interact with ranges in exciting and beautiful ways.

  • 15:50 - 16:10
    Packaging and redistributing binaries built with C++ modules - Diego Rodríguez Losada (Conan/JFrog)
    There are a few misconceptions about C++ modules, how they affect sharing code, specifically sharing and reusing binaries. Though C++ modules is a major and very expected C++20 feature, and they will influence how we write and build C++ code, the reality is that distributing binaries will probably not change much.
    This talk will try to answer some questions about those binaries:
    • What are the artifacts that will be generated by C++ modules? How can be redistributed?
    • Is the ABI improved with C++ modules?
    • Are the ".bmi" files redistributable? Are they multi-platform and multi-compiler?
    • Will be package management in C++ easier or more standard with modules?
    The talk will conclude with an example of binary reuse of a C++ modules library with Conan package manager.
  • 16:20 - 17:00
    Specifiers and qualifiers - Mikhail Matrosov (Align Technology, Russia)
    In C++98 we had const, volatile, static, extern and inline. In C++11 thread_local and constexpr were added. In C++17 — inline variables. In C++20 — consteval and constinit. But have you ever wondered what is a static inline thread_local constexpr const volatile variable?
    In this talk, I will try to sort out all this variety of keywords. We will recall linkage and storage duration, declaration and definition. Examine the connection between extern and inline, static and constexpr. Realize how it took almost 20 years to learn how to declare constants. Our findings will be summarized in a helpful table and a couple of flow-charts.


  • 17:00 - 17:30
  • 17:30 - 17:50
    The Preprocessor Hampers Your Static Analysis Tooling - Will Modules Help? - Thomas Corbat (HSR, Switzerland)

    Modern development environments rely on static analysis of the programming language at hand to provide many useful features ranging from syntax highlighting to automated refactorings. The translation model of C++ consists of multiple phases. In one of them the preprocessor executes all preprocessing directives, which basically is a very primitive transformation of the source code. This translation step incurs a semantic gap between the source code in the files and the resulting C++ source code. Modules, introduced in C++20, reduces this problem, but cannot resolve it completely. I will present a tool developer's perspective on this issue and the challenges it creates for static analysis and automated code transformation tools.

  • 18:00 - 18:40
    Squaring the circle: value oriented design in an object oriented system - JuanPe Bolívar (Germany)

    In this talk, we will present a new open-source library of cursors. Cursors are inspired by functional lenses and reactive streams to provide composable and modular facades to "single atom" value storages. We will see how this can be used to navigate the tension between object-oriented and value-oriented design, and build an example interactive application using Qt and QML against a value-based data-model.

  • 18:45 - 19:00

Ponentes ↑ subir

Patrocinadores ↑ subir

Eventos relacionados