Lo que hacemos

You're already in love with C++ or just started some tutorial. You want to talk to other C++ developers about template metaprogramming, concepts, or the next C++ standard. You have some awesome library ideas in mind you'd like to see in the next Boost release but don't really know how. You're looking for a new job or your company has exciting job offers for C++ developers. Or you simply don't mind an opportunity to attend interesting talks about C++ topics.

C++ User Group Munich is for professionals and beginners interested in modern C++, exchange of experience and networking.

We organize a meetup once a month with a talk about C++ topics. Sponsors welcome!

Recordings of previous talks in our YouTube channel: https://www.youtube.com/channel/UCf3tX0nf8EFIwmgQBH6PIGw (https://www.youtube.com/channel/UCf3tX0nf8EFIwmgQBH6PIGw/videos)

Our Code of Conduct: http://berlincodeofconduct.org

Próximos eventos (4)

Dependency Management in C++

UnternehmerTUM / DesignOffices

This week we have the chance to get a sneak preview of Xavier Bonaventura's talk at code::dive. About the speaker: After getting his Ph.D. at the University of Girona (Catalonia) Xavier moved to Munich to apply his knowledge to industry. Currently, he is a software engineer working in the automotive industry and his goal is to bring autonomous driving on the streets using modern software development techniques. He has been working with codebases of different sizes, with contributions from 5 to 1000 software developers. He loves learning and teaching and he believes that success in large scale projects can only be achieved with quality, using modern techniques, and applying software engineering principles. Abstract: Proper handling of dependencies in a software development project can make the difference between success and failure. A lot of actors need to be aware of these dependencies: the developer, the compiler, the linker, the build system, the runtime system and so on (even the legal department). This takes special importance in projects that need to scale, not only in the runtime phase but also in the development phase. In this presentation, we will go through the different types of dependencies and how they can affect each phase of the project. We will go from the generic point of view with everyday life examples to the singularities of C++ including concepts that are generic for all software development projects. In the last part of the presentation, we will see how Modules introduced in C++20 could change the current scenario regarding dependencies. After this presentation, the audience will have the tools to have a better understanding of the dependencies in their projects. Some of the concepts that we will go through are: direct vs transitive dependency, full dependency vs dependency by name, dependency graph, compilation vs runtime dependency. Agenda: 19:00 -- Welcome with Snacks and Drinks 19:30 -- Welcome at UnternehmerTUM 19:40 -- Lightning Talk 19:50 -- Main talk by Xavier Bonaventura ~21:00 -- Open Discussions 22:00 -- Official End

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


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)

"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)

Eventos anteriores (76)

Aspects of C++ in autonomous driving development

Bremer Str. 6