• Modules - The Beginner's Guide

    MVTec Software GmbH

    This month we have the pleasure to welcome Daniela Engert to our user group. Daniela has worked for 30 years now as a developer in a wide variety of software and hardware projects, mostly in the domain of digital signal processing and its application in areas like signal and communications intelligence, medical imaging, and now industrial non-destructive testing systems for steel goods. ---------------------------------------- Abstract: Modules are one of the big new language additions which will be part of C++20. Seemingly new, modules were actually available for quite a few years in Microsoft's Visual Studio compiler, serving as some form of a reference implementation of the so-called 'Modules TS'. The other root of C++20 modules is the clang compiler, incorporating ideas from engineers (mostly) at Google with their idea of how a implementation of modules should look like. Eventually the developers of gcc also arrived at the party with a fresh look at modules. After joining forces of all three major players, a common vision of a matured specification of modules was agreed on and voted for inclusion into the next C++ standard. With this piece of history in mind, I invite you to follow my exploration of the modules ecosystem as it exists today: - in a nutshell, what are modules after all? - what does a module look like? What are it's basic concepts? - are there pitfalls using modules? - how do modules benefit me or my team? Or my users? - what is the current implementation status in compilers? Are they mature and robust enough for everyday use of modules? - what do people need to know if they want to start with creating their first module? - is it worth it to leave the trodden path and introduce modules into codebases? My efforts and experiences of modularizing the {fmt} library are the basis of the exploration. ---------------------------------------- Agenda: 19:00 -- Welcome with Snacks and Drinks 19:30 -- Welcome at MVTec 19:40 -- Lightning Talk 19:50 -- Main talk by Daniela Engert ~21:00 -- Open Discussions 22:00 -- Official End ---------------------------------------- Sponsor: MVTec (https://www.mvtec.com)

  • Principles of Software Engineering

    Google

    This week we have the special honor to welcome Titus Winters to our user group. Titus has spent the past 6 years working on Google's core C++ libraries and helps maintain the Google C++ Style Guide. He's particularly interested in issues of large scale software engineering and codebase maintenance: how do we keep a codebase of over 100M lines of code consistent and flexible for the next decade? ------------------------------ Abstract: What is the secret to software engineering at Google? Over the years, we’ve come to recognize three key principles that guide our practices and decisions: Time, Scale, and Tradeoffs. Software engineering and programming are related but different problems. If programming is about producing code, software engineering is about maintaining that code for the duration of its usefulness. It is about the practices, policies, and decisions that support robust and reliable code. It is about building for growth and for the ability to manage change. It is this need for sustainability that differentiates software engineering from programming. At Google, we have learned many lessons related to the sustainability of software. Google arguably maintains one of the largest codebases ever. The expected lifespan of the codebase is at least another couple of decades. We’ve needed to figure out how to operate at a scale previously unattempted for a timespan longer than most others have considered. Learning from the difficulties that we have encountered along the way while wrangling with this unprecedented problem, we have tailored our engineering practices to factor in time, scaling, and evidence-based decision making. This is what has enabled us to operate as we do. This talk will explore the themes of time, scale, and tradeoffs in the context of sustainable software engineering. We will discuss the impact that each of these factors has on the process of software development and maintenance and how Google has shaped its engineering practices to take these principles into account. ------------------------------ Schedule: 19:00 -- Welcome with snacks and drinks 19:30 -- Welcome at Google 19:35 -- Lightning talk 19:45 -- Main talk ~21:00 -- Open discussions 22:00 -- Official end ------------------------------ Sponsor: Google (https://about.google)

  • Modern Template Techniques

    NavVis

    On November, 19th, for the second time we have the great please to welcome Jon Kalb to our user group. Jon has been programming in C++ for almost three decades and does onsite training for teams that want to up their C++ game. He chairs C++Now, CppCon, the C++ Track of the Silicon Valley Code Camp, and the Boost Steering Committee. He also serves on the board of directors for the C++ Alliance. ------------------------ Abstract: So if you’ve covered the basics of template syntax for types and functions, but you're not quite ready to dive into template metaprogramming yet. Then this session's for you. In this session, we’ll assume you know most of the basic templating syntax (advanced syntax not required) and we’ll cover the next step in your templating journey. We’ll briefly review function templates and then cover topics like the Curiously Recurring Template Pattern and static polymorphism. We’ll also cover modern design tools like policy classes and perfect forwarding. We’ll not dive into template meta programming, but we’ll dip our toes in by covering type traits, compile-time conditional overloading, and C++17’s new compile-time if, which are the building blocks for template metaprogramming. We’ll finish by looking at how we can learn the types of objects whose types are deduced by the compiler. A practical survival skills on your templating journey. ------------------------ Agenda: 18:30: Open doors und get-together with catering 19:00: Official welcome by NavVis 19:10: Lightning talk ~19:30: "Modern Template Techniques" (Jon Kalb) ~20:45: Open discussions 22:00: Official end ------------------------ Sponsor: NavVis (www.navvis.com)

  • "Type punning in modern C++" and "The Dawn of a New Error"

    JetBrains Event Space

    This month we have the great pleasure of a double feature. We continue our tradition and welcome both Timur Doumler and Phil Nash for the last meetup of this year. ---------------------- Title: Type punning in modern C++ Presenter: Timur Doumler. Timur is a C++ developer specialising in audio and music technology, active member of the ISO C++ committee, and part of the includecpp.org team. He is passionate about building communities, clean code, good tools, and the evolution of C++. Abstract: Type punning is often used in C++ for fast floating-point math, deserialising C++ objects from a sequence of bytes, and other purposes. Popular techniques involve unions, reinterpret_cast, and memcpy. C++20 provides new useful tools, such as bit_cast. And there are proposals to provide even better control over C++ object creation in the future. This talk is a comprehensive overview of all of these techniques. We will discuss when and how they can be used safely without causing undefined behaviour, what C++ does and does not allow you to do (and why), existing holes in the C++ language, and how to fix them. In the process, we will cover important C++ concepts such as object lifetime, value representations, and aliasing rules. ---------------------- Title: The Dawn of a New Error Presenter: Phil Nash. Developer Advocate at JetBrains, author of Catch/Catch2, co-host of cpp.chat, host of C++ London, chair and organiser of C++ on Sea. Abstract: As a community we've tried many different ways to express, propagate and handle error conditions in our code over the years. Each seem to have different trade-offs, with none being perfect in all cases. This presentation is the follow-up to my earlier talk, "Option(al) Is Not a Failure", where I surveyed existing error-handling approaches and score them against each other, leading up to the new proposal, p0709, "Zero-overhead deterministic exceptions". We'll summarise some of that background so we're all on the same page, but in this talk we're going to dig into the proposal in more depth - and look at the supporting proposals, p1028 (std::error) and p1029 ([[move relocates]]) and others. We'll also comment similar mechanisms in other languages, notably Swift, to get an idea of how it might work out in practice. ---------------------- Schedule: 19:00 -- Welcome by JetBrains 19:30 -- Talk by Timur Doumler 20:30 -- Break 20:45 -- Talk by Phil Nash ~21:45 -- Open Discussions 22:00 -- Official End ---------------------- Host: JetBrains (https://www.jetbrains.com)

  • Combining C++17 Features in Practice

    Rohde & Schwarz GmbH & Co. KG

    On March, 11th, for the fourth time, we have the great pleasure to welcome Nicolai Josuttis to our user group. Nico (http://www.josuttis.com) is an independent system architect, technical manager, author, and consultant. He designs mid-sized and large software systems for the telecommunications, traffic, finance, and manufacturing industries. He is well known in the programming community because he not only speaks and writes with authority (being the (co-)author of the world-wide best sellers The C++ Standard Library (www.cppstdlib.com), C++ Templates (www.tmplbook.com), and C++17 - The Complete Guide (www.cppstd17.com)), but is also an innovative presenter, having talked at various conferences and events. Abstract: 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 2 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 powerful C++17 really is. Agenda: 18:30: Open doors und get-together with catering 19:00: Official welcome by Rohde & Schwarz 19:10: Lightning talk ~19:30: "Combining C++17 Features in Practice" (Nicolai Josuttis) ~20:45: Open discussions 22:00: Official end Sponsor: Rohde & Schwarz (www.rohde-schwarz.com)