- The Rust && C++ LDN *Virtual* Talks
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. https://ferrous-systems.com/training/ https://odsc.com/ https://www.rustlab.it/ **This event will be Live-Streamed due to the Corona-Virus Pandemic** Agenda: ========= • Welcome • News, Announcements & Special Giveaways • Speaker: Hendrik Niemeyer • Speaker: Payas Rajan ----- A Friendly Introduction to Rust for C++ Developers https://github.com/hniemeyer 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? https://github.com/PayasR "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
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
live.cpplondon.org 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
We're excited to announce that we will be running C++ London this month after all - but now as an online event. That means our originally scheduled visiting speaker, Klaus Iglberger, will be joining us as we broadcast on YouTube. We'll also experiment with a video conferenced side channel, using Jitsi, for general socialising. Find us at the following location (please use Chrome if you'll be participating in the Jitsi rooms): https://live.cpplondon.org For more information about the way we're doing this see: https://www.reddit.com/r/cpp/comments/ga8yhs/c_london_goes_online/ ---- Agenda: 19:00 Phil Nash - "Intro and News" 19:10: Klaus Iglberger - "Embrace No-Paradigm Programming!" What kind of language is C++? Is it a procedural programming language? An object-oriented programming language? A functional programming language? A generic programming language? All of those? None of those? In this talk I’ll analyse why it is increasingly hard to answer these questions, especially since the advent of “Modern C++”. I’ll demonstrate by example that the good solutions, i.e. the solutions that promote loose coupling, ease of use, ease of maintenance, and performance, are not firmly rooted in either one of the traditional paradigms. The examples will raise doubt whether it is reasonable to try to assign C++ to any one of the paradigms. Instead, they may be an indication that we should embrace no-paradigm programming. --- About the speaker: Klaus is a freelancing C++ trainer and consultant. He shares his experience in popular advanced C++ courses around the world (mainly in Germany, but also the EU and US). Additionally, he is the initiator and lead designer of the Blaze C++ math library (https://bitbucket.org/blaze-lib/blaze) and one of the organizers of the Munich C++ user group (https://www.meetup.com/MUCplusplus/) --- If you have an idea for a talk or other type of session - any length - please let me know via: cpplondon.org/speak.
- Epochs, Best-Practices and Cross Platform Security
This month we're excited to be hosted by another new venue, Garrison, who will be providing pizza and drink as well as the event space. And we have a packed schedule, with three speakers: David Bailey, Jarl Ostensen and Vittorio Romeo! Agenda: 19:00 Phil Nash, "Intro and news" 19:10 Jarl Ostensen, "Finding the balance; lessons learned for best C and C++ practices in a live production code base" Polystream's IP is its technology and this has evolved over the last few years from relatively straight C owned by a very limited number of people, through to something much more C++'ified developed by a larger team. The code is heavily optimised for performance and the complexity of the IP adds strict requirements on maintainability and scalability under different conditions. As we have grown the team and the scope of the technology challenges, we have gone through a number of iterations of refactoring building on lessons learned at each step, and have converged on a pragmatic mix of C and C++ practices. This talk is about our journey so far, developing and refining our code base and approaches, wrong turns and good decisions alike 20:00 break 20:15 David Bailey, "C++ in a custom hardware, cross-platform security product" Developing a complex enterprise cyber security product, involving custom hardware, FPGAs and a deep software tech stack involves many different trade-offs and decisions when it comes to language and platform support. At Garrison, we are users of C++ in multiple places in our stack - from embedded development, Android Open Source Project, browser development using Chromium, through to desktop and mobile applications. We don't live at the bleeding edge of the language, and indeed we have to live with constraints resulting from the hardware and vendors we use, and the range of platforms we have to support. We have to think long term - code we write now may be running in a data centre for the next 5-10 years. The aim of this short talk is to share how we use C++ in a multi-discipline, multi-platform environment and highlight some of the challenges and some of the solutions we've adopted in our engineering practice. 20:25 Vittorio Romeo, "Fixing C++ with Epochs" 21:00-ish - finish --- About the speakers Jarl is the Director of Engineering for Streamer Technology at Polystream, leading the research and delivery behind Polystream’s unique streaming technology. Prior to joining Polystream in 2016, Jarl lead the Service and Technology organisation at Microsoft’s Lionhead Studios, lead Mobile Technology at Supermassive, and has helped deliver many great and successful games at Electronic Arts, all the way back to working at the fabled Bullfrog Studios, creators of Theme Park World and the Dungeon Keeper series. - Dave Bailey is the Chief Engineer at Garrison Technology, and formerly the lead engineer in BAE Systems Cyber Security business, known for an extensive track record of delivering complex technical projects. Much of Dave’s experience has been in hands-on development and project management of operational (24/7) systems that require tight integration between hardware and software systems. These projects have ranged from accelerating exotic financial trades by many factors, supporting submarine missions and developing one of the world’s first behavioural cyber security monitoring solutions. - Vittorio Romeo (B.Sc. Computer Science) has been a Software Engineer at Bloomberg for > 3 years, working on mission-critical company C++ infrastructure and providing Modern C++ training to hundreds of fellow employees. Vittorio has created several open-source C++ libraries and games, published many video courses and tutorials, and actively participates in the ISO C++ standardization process. He has presented more than 20 times at international C++ conferences. When he’s not writing code, Vittorio enjoys weightlifting and fitness-related activities, competitive/challenging computer gaming and sci-fi movies/TV-series.
- Compile Time Regular Expressions with Deterministic Finite Automaton
This month we're excited to welcome Hana Dusíková, visiting from Prague, to talk to us about Regular Expressions ... at compile time! We're back at CloudFlare, so drinks and some light snacks, will be provided. To submit a talk idea for future events please visit http://cpplondon.org/speak. Agenda: 19:00 Intro and News - Phil Nash 19:10: TBA --- 19:45 "Compile Time Regular Expressions with Deterministic Finite Automaton" - Hana Dusíková. In this talk I will present an advancement on the Compile Time Regular Expression (CTRE) Library. The library was designed with new C++20 features, and it uses novel techniques. This presentation independently sums up the work since my previous CppCon talk about the library. The primary topic of this talk will be an explanation of the new Deterministic Finite Automaton (DFA) engine in the library and how it's built and optimised during compilation. I will explain the differences and limitations of the new engine in comparison to the previous Back Tracking engine. I will address these differences with a benchmark and I will discuss the generated assembly. Even if you are not interested in regular expressions, you will learn new techniques in compile-time meta-programming and see new C++20 features in action. ---- About the speakers: Hana is working as a senior researcher in Avast Software. She is the author of CTRE (Compile Time Regular Expressions) library, Chair of SG7 (Study Group for Compile Time Programming) and Czech National Body representative in WG21 (ISO C++ Committee).
- Testing and UB
This month we welcome visiting speaker, Clare Macrae, as well as our own Tom Waldron ******** A big thanks to Cloudflare, who are hosting us at short notice after Skills Matter went into administration). They're based near Waterloo Station, so very central. It's a great venue - and they have free snacks and drinks! If we behave well enough that they let us, we'll probably meet there often from now. ******** To submit a talk idea for future events please visit http://cpplondon.org/speak Agenda: 19:00 Intro and News - Phil Nash 19:05 "Undefined Behaviour by default" - Tom Waldron A quick splash around in the sub-genre of embedded C++ for microcontrollers, which relies heavily on implementation defined and undefined magic as standard. 19:45 Break 20:00 "C++ Testing Techniques, Tips and Tricks" An assortment of practical techniques to make it easier to write effective automated tests of C++ code, both old and new. Clare will share some approaches for easier handling of commonly troublesome testing scenarios. This is a brand new talk, that is independent of test frameworks, and even covers a little for those creating Qt desktop applications. ---- About the speakers Clare is an independent consultant, helping teams streamline their work with legacy and hard-to-test C++ and Qt code. She has worked in software development for over 30 years, and in C++ for 20 years. Since 2017, she has used her spare time to work remotely with Llewellyn Falco on ApprovalTests.cpp, to radically simplify testing of legacy code. She has enjoyed this so much that she recently went independent, to focus even more on helping others to work more easily with legacy code. Clare was until recently a Principal Scientific Software Engineer at Cambridge Crystallographic Data Centre, which releases structural data and powerful software for scientific education, research, and streamlining the design and manufacture of new medicines. From 2016 to 2018, she lead the team that replaced their 30 year old database format and Fortran code. She then returned to C++ and Qt, working on the popular 3D crystal structure visualisation program Mercury, which she was the original author of. When not thinking about supporting teams to streamline development, testing and releases, she spends time with family and friends, and enjoys the Raspberry Pi, folk music and cinema. -- Tom is a Senior Embedded Design Engineer for ROLI, bass guitar player for Nova Neon, cycling enthusiast and occasional capoeirista. He uses C++ with efficiency in mind, running on constrained systems, making use of compile-time trickery and abuse of compiler settings. His favourite tools are Visual Studio Code and a soldering iron.
- Lightning at Dawn
This week Phil Nash talks more about error handling - and specific proposals - and we have a selection of Lightning Talks. To submit a talk idea please visit http://cpplondon.org/speak ---- IMPORTANT: Please also register at Skills Matter (so you can get into the venue): https://skillsmatter.com/meetups/12965-lightning-at-dawn ---- Agenda: 19:00 Intro and News 19:10 Lightning talks 19:40 Break 19:55 "Dawn of a New Error" - Phil Nash 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 --- About the speaker(s): Phil is one of the hosts of C++ London. He's also the author of the C++ test framework, Catch2, and the composable command line parser, Clara. As Developer Advocate at JetBrains he's involved with CLion, AppCode and ReSharper C++. More generally he's an advocate for good testing practices, TDD and using the type system and functional techniques to reduce complexity and increase correctness. He's previously worked in Finance and Mobile as well as an independent consultant and coach specialising in TDD on iOS.