• Recording Errors in Test and Cool Compiler Tidbits

    Online event

    Welcome to another month of C++ London. After a little break we're back with a couple of great talks from Matt Godbolt and Chris Croft-White (of Undo).

    Because it's a packed agenda we'll be kicking off a little earlier than usual.

    Please go to: https://live.cppldn.uk for the event, itself.

    Approximate schedule:

    18:30 Intro and News (Phil Nash)

    18:40 Improve Test Automation Efficiency by Recording Test Failures (Chris Croft-White)

    Continuous delivery at speed is essential but equally important is delivering high-quality software. Despite all of this, some critical testing and debugging steps still fall outside the automation process and are often handled manually. This introduces risk and unpredictability into the process.
    Join us as we demonstrate workflows and techniques to debug faster and ensure software quality by automating the recording of the errors that cause failing tests

    19:30 Cool Compiler Tidbits (Matt Godbolt)

    We use compilers every day, but how often do we stop to think about the kinds of amazing things they do for us? Modern compilers are a feat of engineering and in this talk Matt will demonstrate just a few of the very clever things they do for you.

    Matt will use Compiler Explorer to show how simple, easy to read code can be turned into amazing optimized, efficient assembly code. Writing clear, readable code that's also efficient hinges on being able to trust your compiler's code generator. By the end of this talk, you'll be able to read assembly well enough to be able to appreciate your compiler, and have an understanding of what it can - and can't - optimize for you.

    20:30 on ...

    Socialising online (details to follow).


    About the speakers:

    Chris is a Pre-Sales Consultant Engineer. Armed with a Computer Science degree from the University of Cambridge, UK, he acquired experience as a Field Application Engineer, a Security Engineer, and a Sales Engineer at a range of technology firms. He is particularly adept at problem-solving and resolving customer issues by getting to the root cause of pesky bugs quickly.

    Matt is a C++ programmer and occasional verb. He loves writing efficient code and sharing his passion about how computers work under the hood. An engineer at Aquatic, he has previously worked in cryptocurrencies, at other trading firms, on mobile apps at Google, run a C++ tools company and spent more than a decade making console games. When not tinkering on Compiler Explorer, Matt enjoys working on emulators for old 8-bit computer hardware.

  • Costs (of dynamic memory) and debt (of the technical kind)

    Online event

    This month we welcome Ivica Bogosavljevic to discuss the cost of dynamic memory, and Alex Omeyer with a shorter talk about technical debt.


    19:00 Phil Nash - "Intro and news"

    19:10 Alex Omeyer - "How to deal with tech debt - Lessons learned from 200+ engineering teams"

    I have interviewed 200 top engineering teams to learn the perfect process to manage technical debt. In this talk, I will share my learnings: tactics, processes, and tools to use when dealing with small, medium, and large pieces of tech debt, and the approach you can take depending on your company’s stage, size, business priorities, and culture.

    19:30 Ivica Bogosavljevic - "The price of dynamic memory in C/C++"

    For most C/C++ developers, working with dynamic memory comes down to using new/malloc and delete/free functions. However, when your program's speed is important, you will need to rethink the way you are using these functions and how you are organizing your data in memory. We will investigate how memory allocation and memory access patterns influence the speed of your programs and what you can do to speed them up.

    21:00 End of talks - socialising in Remo


    About the speakers:

    Ivica is an Application Performance Specialist working in the industry for 10 years. His professional focus is application performance improvement - techniques used to make your C/C++ program run faster by using better algorithms, better exploiting the underlying hardware, and better usage of the standard library, programming language, and the operating system.
    He is also founder of the Johny's Software Lab LLC (https://johnysswlab.com) performance consulting company that helps software development companies deliver fast software.

    Alex Omeyer is a Co-founder & CEO at Stepsize, a tool for engineering teams to manage technical debt. Alex spends most of his time speaking to the best software development teams in the world about how they handle technical debt and sharing this knowledge with the community.

  • Conan Package Manager for C++ in Practice

    Online event

    This month we welcome Jerry Wiltse from the Conan development team, who's going to give us a tour of the Conan package manager for C++. We also have a shorter talk from Frank Haferkorn.

    As usual we'll meet virtually. Venue details will be updated soon.
    Please note that times are UK times (slightly confusing as meetup just says GMT+1. The UK changes from GMT to BST just before the event, so if you're looking at it before that you might think it means CET!).



    19:00 Phil Nash - 'Intro and News'

    19:10 Frank Haferkorn - 'The Compound Block "LOOP" - and some implications'

    The compound group "LOOP" is a C / C ++ language extension..
    The introduced compound statements loop() {}, typed_loop() {}, named_loop_up() {} and named_loop_down() {} are reductions of the regular for(;;){} compound. They will allow writing different algorithms and will increase teachability of C/C++.

    19:30 short break

    19:45 Jerry Wiltse - 'Conan Package Manager for C++ in Practice'

    The Conan package manager for C++ is useful in both simple and advanced development environments. Join the Conan team to see it in action, with a simple demo using OSS libraries and tools from ConanCenter, and a more complete demo showing how to create and upload a package including different binaries for different platforms to a private repository. Also, learn about many other unique and innovative advanced Conan features along the way.

    20:45 Finish and socialising in Remo

    Do stay on for the informal chat in Remo, after the talks.


    About the speakers:

    Jerry Wiltse is a member of the Conan development team, and has been dedicated to build engineering for C and C++ since 2016. He is an avid open-source enthusiast but also deeply focused on enterprise development environments. He is also the narrator and creator of the Conan learning track on the JFrog Academy.

    Frank.Haferkorn is a German Physiker, senior software developer and founder or Head-Of-Science of the inventor bureau [OGIS] OatGrain-InnovationS. He belongs to the generation that has seen the whole development of desktop computers (from the CBM-PET) and has worked as a professional software developer in the industry since graduating from the Technical University of Munich in 1995 until today.
    His areas of expertise are Modern C ++ (>=2020), algorithms, parallel computing technology, physics (electrodynamics / QM / QED / SRT / ART and the psychoacoustics of Spatial Hearing). He has also worked in the field of semantic web / linked data. Currently he digs into the Raspberry-PI technology.
    In addition to smaller publications, he also “draws” his own thoughts on the further development of C ++. The use of elaborate tools of all kinds is his hobby and covers the whole spectrum from Visual Studio to Qt and Linux. To compensate, Frank can be found as an artist drawing, composing and as a sound designer for spatial audio.

  • Supercharging HPC for Object Oriented Languages

    Online event

    This month we welcome Dmitri Goloubentsev to talk to us about a technique for hugely boosting performance of repetitive calculations.

    As usual we'll be meeting virtually. Once the venue is set up, registered attendees will get the details.

    We're also pleased to say that this event will be sponsored by G-Research, who will be giving away a £100 Amazon voucher - so look out for that (and they might have a job for you, too!)

    We can still fit in a short/ lightning talk (5-15 minutes) if anyone is interested? - http://cppldn.uk/speak



    19:00 Phil Nash - "Intro and News"

    19:10 Chris O’Brien (Talent Acquisition, G-Research) - "G-Research Intro"

    An introduction to what they do at G-Research, Europe’s leading Quantitative Research Firm.

    19:15 Dmitri Goloubentsev - "Supercharging HPC for Object Oriented Languages with a touch of differentiable programming"

    A new practical programming paradigm for parallel
    computing with optional Automatic Adjoint Differentiation that brings leaps in performance
    for repetitive calculations.

    20:15(ish) "G-Research giveaway"

    One lucky attendee will be randomly selected to receive a £100 Amazon gift voucher, courtesy of G-research, so be sure to stick around to the end of the talk!

    Then: socialising in Remo. Stick around to chat with the speakers and other attendees. Drinks are optional (but you'll have to bring your own).


    About the speaker(s):

    Dmitri is head of Automatic Adjoint Differentiation in MatLogica.
    Prior to establishing the company, he had 15 years of combined experience in model development working on C++ quant libraries. He worked as a Senior Quant Analyst in interest rate derivatives and played a leading role in delivering XVA solution at a major Canadian bank. Prior to focusing on AAD, he was responsible for construction of SIMM/MVA model. Dmitri earned his degree in Maths and Applied Maths from the Moscow State University.

  • Understanding Coroutines by Example

    Online event

    This month we welcome back Pavel Novikov who's going to talk to us about Coroutines. This is particularly timely, with C++20 now published, and GCC and MSVC already shipping with Coroutines support.

    As before we'll be hosted in Remo, which will allow us opportunity to socialise between and after the talks.


    19:00 Phil Nash - "Intro and News"

    19:10 Pavel Novikov - "Understanding Coroutines by Example"

    Coroutines are a powerful tool added to C++20. Though currently there are basically no means to conveniently work with coroutines out of the box. That’s why we need to learn to properly use this tool to get benefits and to do it efficiently. We’ll be doing just that.

    We’ll figure out how to use coroutines from the ground up by example of how to work with asynchronous tasks.

    20:30 socialising in Remo


    About our speaker:

    Pavel has an engineering degree in missilery from BMSTU. He loves C++ and knows how to cook it.
    He likes meta-programming, multithreading and asynchronous programming and is a coroutine adoption enthusiast.

  • Type-Erasure, Argument passing, concepts and pain

    Online event

    This month we're back to pure C++ and welcome two more "visiting" speakers: Eduardo Madrid and Roi Barkan.

    As before we'll be hosted in Remo, which will allow us opportunity to socialise between and after the talks.

    Agenda (subject to change):

    19:00 Phil Nash - "Intro and News"

    19:10 Roi Barkan - "Argument passing, core guidelines and concepts"

    Core guidelines recommend passing objects to functions differently based on whether they are 'cheaply copyable'. Earlier this year, Herb Sutter put a spotlight on the importance of simple and correct methodology for such argument passing.
    In this talk I'll remind people about subtleties of this topic and endeavor to use c++20 concepts to let the compiler assist us with the guideline.

    19:40 break & socialising

    20:00 Eduardo Madrid - "Type-Erasing the Pains of Runtime Polymorphism: The Practical Part"

    Object Oriented interfaces are one of the most powerful tools in all of software engineering, we design an interface capturing the behaviors our subtypes should have and then make concrete implementations; but interface inheritance has modeling limitations and the core language feature of inheritance and virtual overrides inflicts on us several pains that fortunately we can avoid, because C++ is such a powerful language we can use some of its features to synthesize the equivalent of others, only better in some key aspects. We have implemented an open source framework that does exactly that, and this framework is “production-strength”, including being used in Snapchat, an application with hundreds of millions of daily active users; hence this is ready for the attendees to start benefiting from, especially if we explain with lots of examples, Catch2 tests and benchmarks, compiler explorer links how to use it.

    Type-erasure is the technique at the root of the magical powers of std::function, however, its other implementations are very inefficient as shown in our CPPCon presentation. In this presentation we will generalize quite a lot what we can do with things like std::function.

    In particular inheritance and overrides:

    1. Have important performance/efficiency drawbacks that can be avoided

    2. Are “intrusive” of otherwise perfectly good types already implemented, force us to make “wrappers”, but type-erasure allows us to just use existing types.

    3. Are very limited in their modeling powers, however, zoo lets us go beyond.

    This presentation also works as the introduction to the deeper and more technical aspects of the theory and implementation of type erasure in the zoo libraries I have been communicating publicly.

    21:00 Socialising


    About the speakers:

    Eduardo is a tech lead at Snap, the maker of Snapchat, works in the team that does the Augmented Reality "Lenses". He used to work in the field of Automated Trading and shared with us results of his work in the field at CPPCon 2016, as well as other high-performance computing interests of his at CPPCon 2019 and others. Today he will continue discussing subjects he introduced at his presentation "Not Leaving Performance at the Jump Table" from CPPCon 2020, but today's presentation is independent and they can be watched in either order.

    Eduardo is a returning presenter at our meetup, earlier in the year he shared, in the company of his colleague Sumant Hanumante, the details about how to throw exceptions more efficiently.

    Roi is a professional software developer and architect since 2000. His main focus throughout his career was on high performance and distributed systems, implementing complex and innovative algorithms. Roi has been the VP technologies of Istra Research since 2014, where he helps creating low latency financial systems. Prior to working for Istra Research, Roi spent 12 years in software development, architecture and management in the IT Security field. Roi received his B.A in Computer Science with high honors from the Technion in Israel, and his executive MBA from Tel Aviv University.

  • The C++ LDN && Rust talks (part 2)

    Online event

    Following on from last month's extraordinarily successful joint meet-up with the Rust London group, we're back with another cross-over event.

    This time it will, technically, be C++ London hosting Rust London (last month it was the other way around) - but you'll probably not notice much difference (proving that ownership is hard!).

    We have another great pair of talks, this time from members of the Rust community. If you're wondering where all the pure C++ content has gone, don't worry, we'll be resuming our usual pattern from next month (although there will be more opportunities to follow up on the intersection of ideas - stay tuned for more on that).

    We're also going to start a little earlier this time as we found that we ended up finishing quite late last time, and some had to drop off before the end.


    18:30: Phil & Ernest - "Intro and news"

    18:50: James Munns - "Rust: Access All Arenas"

    Over the past five and a half years since its 1.0 release, Rust has started to become the language of choice for developers across a wide variety of applications and industries. This talk will explore where the language came from, the challenges it was designed to overcome, and how people have started to apply Rust to areas above and beyond the original intent. In particular, James will focus on areas like web assembly, embedded systems, and even moving into the safety-critical domain with efforts like Sealed Rust - that have been rapidly picking up steam in the Rust developer communities

    19:40 break

    20:00 Mikhail Voronov - "FCE: using interface types for server-side WebAssembly modules"

    This talk is dedicated to the Fluence Compute Engine – FCE (github.com/fluencelabs/fce). FCE is an engine intended to run multi-module WebAssembly applications with the shared-nothing linking scheme and with interface-types support.
    In particular, the following topics will be highlighted in this talk:
    - Why the state of the interface-types proposal is essential for all ecosystems using Wasm,
    - Why Rust is one of the most suitable languages for any projects using Wasm,
    - FCE architecture,
    - Support of interface-types in Fluence Rust SDK (github.com/fluencelabs/rust-sdk).

    20:30ish - chatting and socialising at Remo tables

    About the speakers:

    James is an embedded systems engineer, with a history of working on software for a wide range of systems, including safety-critical avionics, and rapidly prototyped IoT systems. James is a founding member of the Rust [Embedded Working Group](https://github.com/rust-embedded/wg), as well as a founder of [Ferrous Systems](https://ferrous-systems.com), a consultancy focused on systems development in Rust, with a speciality in embedded systems development.

    James is working hard to bring Rust to new places in the embedded domain, including efforts to qualify the Rust language for use in safety-critical systems through the [Sealed Rust](https://ferrous-systems.com/blog/sealed-rust-the-plan/) initiative, and building easy to use open source tooling in the [Knurling-rs](https://github.com/knurling-rs) project.

    Mikhail is a system programmer with a strong knowledge of OS internals and process virtual machines architecture.

  • The Rust && C++ LDN *Virtual* Talks

    Online event

    C++ and Rust London are proud to announce our first joint meetup The Rust && C++ LDN Talks. This is the first in a series of collaborative events between our two communities which have been compared and contrasted for several years.

    The purpose of these events is to begin an exchange of ideas and experiences between our user groups.
    The Rust London User Group will open up the LDN Talks platform to the C++ London community. We will have speakers from C++ London who will share their perspectives, opinions and learning experiences with the Rust Programming language.

    There will also be a special giveaway of various prizes from our community partners; Ferrous Systems, The ODSC and RustLab.




    **This event will be Live-Streamed due to the Corona-Virus Pandemic**


    • Welcome

    • News, Announcements & Special Giveaways

    • Speaker: Hendrik Niemeyer

    • Speaker: Payas Rajan

    A Friendly Introduction to Rust for C++ Developers

    Rust's design philosophy aims for a language which helps the developer as much as possible with memory safety, freedom from data races, great error messages and package management. But also no sacrifices shall be made in terms of performance and low-level control over memory.

    In this talk, I will introduce Rust and its core principles from the perspective of a C++ developer. Similarities and differences between C++ and Rust will be discussed by comparing the example code in both languages.

    Are Graphs Hard in Rust?

    "Graphs are hard in Rust due to the strict borrow checking rules." In this talk, I argue otherwise. I use examples from popular libraries including Boost Graph, OSRM and petgraph to show that implementing graphs and graph libraries in C++ and Rust, in fact, have very similar levels of difficulty. Moreover, the Rust's traits-based type system makes certain operations simpler and can save programmers a lot of time and cryptic error messages.

    About the speakers:

    Payas is a PhD Candidate at the University of California - Riverside where he studies route planning algorithms in transportation networks and other geospatial problems.

    Hendrik is a Technical Lead for Data Sciece and works on machine learning and big data solutions in Python but is also interested in C++ and Rust. He described himself as a "learning enthusiast" who always gets absorbed in learning new things.

    We'll be hosted, again, on Remo, courtesy of the Standard C++ Foundation.

  • tag_invoke :: niebloids evolved

    Online event

    This month we welcome back Gašper Ažman, who's going to talk to us about the upcoming tag_invoke feature and how to use it.

    We'll, once again, be meeting online, this time using a service called Remo. Big thanks to G-Research who are hosting us, this month, on their instance of Remo. Please see the joining instructions towards the end of this post for details.

    We're also interested in lightning talks ---> http://cppldn.uk/speak

    19:00 Phil Nash - Intro and News

    19:10 Lightning talks:

    Pavel Novikov - "Coroutines + type erasure = state machine"

    Eduardo Madrid & Sumant Hanumante- "How to improve exception throwing: better than perfect forwarding, the best types, and the best of both worlds of inlining/non-inlined"

    20:00 Gašper Ažman - 'tag_invoke :: niebloids evolved (or "finally, a good way to do customization points")'

    tag_invoke is the new (and awesome) way to do customization points in C++ that does not take up global names, is extensible, fast, and precise. This talk will teach you how to employ this soon-to-be-standard mechanism in your own code.

    About the main speaker:

    Gašper has been trying to have the compiler prove his code since 2008, and it's been going better of late. He has written code for the web, backends, and research tools, for UC Berkeley, A9.com (http://a9.com/), and currently Citadel. He has corrected proofs in "From Mathematics to Generic Programming", and frequently attends C++ conferences.

    Instructions (with thanks to G-Research):

    The link to join the event is: https://live.remo.co/e/c-london-meetup-june-2020 If you have not already, please sign up for the event on Remo (you will need to make an account).

    We will be officially starting at 7:00pm (BST) but please aim to join just before then. You should use this time to watch the demonstration video available in the top left-hand corner.

    Before the event begins, you will be seated at a table with other attendees of the meetup so feel free to use this time to network if you would like to. Please also ensure you have headphones connected to avoid echoes and background noise.

    If you have a question during the presentation, please put this in the Q & A chat. If you wish to take part in networking after the event, this will take place on the tables. Please therefore turn on your microphone and camera using the icons at the bottom of your screen so that the other people on your table can see and hear you.

    During your discussions, you can select the whiteboard function to share notes/ideas with individuals on your team. The icons on the left hand side should be used to write or draw on the whiteboard. You can also share documents here. To navigate away from the whiteboard, simply click the 'return to map' button on the bottom of your screen.

    If you have an idea for a talk or other type of session - any length - please let me know via: http://cppldn.uk/speak.

  • Corobatch - Batch operations, simply, with coroutines

    Online event


    We're once again going to be live streaming the meet-up, and running parallel video chat rooms. This month we welcome Francesco Zoffoli to talk about using coroutines for batch operations (the talk he was originally going to give in March).

    We'd also like to run some lightning talks - so if you have any ideas for one - from 5-10 minutes - please let me know on cpplondon.org/speak. If you want to hash out an idea you're not sure about, or want help, advice, or some practice doing a remote presentation let me know, too.

    19:00 Phil Nash - "Intro and news"

    19:10 Lightning talks

    * Kevlin Henney - "λιστ"
    * Kilian Henneberger - "Polymorphism Decision Table"
    * Arthur O'Dwyer - "A C++20 Magic Trick"

    20:00 Francesco Zoffoli - "corobatch: how coroutines can transform your code to do batch operations"

    Batch operations tend to be more efficient than multiple single operations (network calls, IPC, memory allocation, I/O in general), but they can make the code harder to read.
    corobatch uses coroutines to allow you to write code as if you were processing one element at a time, and perform batch operations underneath, to get the best of both worlds.


    About the speakers:

    Francesco is a professional Software Engineer currently working at Facebook after several years at Bloomberg LP in London. Passionate about programming languages and maintainable software, he learned C++ when joining the industry. He is passionate about C++ and its expressiveness, especially its meta-programming capabilities. He's coauthor of "C++ Fundamentals". He uses C++ to build distributed systems in his day to day job as well as in his personal projects.

    Kevlin Henney is an independent consultant, speaker, writer and trainer. His development interests include programming languages, software architecture and programming practices, with a particular emphasis on unit testing and reasoning about practices at the team level.

    Kilian is 26 years old and lives in Germany. He holds a B.Sc. in Applied Mathematics and Informatics and is highly interested in every part of C++ except localization and streams.

    Arthur O’Dwyer is a speaker and trainer on modern C++; the chair of CppCon’s "Back to Basics" track; and the author of Mastering the C++17 STL (2017). He also blogs on a wide range of C++ topics. Arthur lives and works in New York.


    If you have an idea for a talk or other type of session - any length - please let me know via: cpplondon.org/speak.

  • No-Paradigm Programming