We’re Not Going to Allow You to Throw ? Anymore

The Curse of Backwards Compatibility: This week we chat with Harald Achitz about a new ISO mirror in Sweden, the C++ community - in Sweden, and worldwide - and other topics (which may or may not include Cobol) We explore the underbelly of getting involved with standards work - not just the C++ one, as well as community building, language evolution and static analysis. by cpp.chat

61 min listen

Did You Really Learn from All the C++ Mistakes?: We're back! Again! And so is Dave Abrahams, after a long period outside the C++ community. So we thought we should hear about what he's been up to and what he's doing now. We end up getting some fascinating insights into the design and evolution of the Swift programming language, which Dave joined the team behind quite early on. While Swift draws inspiration from many languages, the core of the team behind it - including Dave - were C++ experts - but experts who wanted to take from the best, yet learn from the mistakes, of the past. Listen to this episode to find out if they pulled it off! by cpp.chat

66 min listen

I Can't Believe I'm Here: This week, err... month, no, episode, we're joined by Anastasia Kazakova for a cross-over show with No Diagnostic Required - the other show that Phil co-hosts with Anastasia. We cover articles on static analysis, move semantics and expressive interfaces, three new std proposals, then chat about conferences, especially CppCon, which just finished for this year. by cpp.chat

73 min listen

The Future of C++ (KDAB interview): This episode is slightly different to the normal. Rather than being a pure cpp.chat session, it's a recording of an interview, conducted by KDAB, of a panel of C++ experts, including our own Jon Kalb - but also past cpp.chat guests Ivan Čukić and Jens Weller, as well as Matthias Kalle Dalheimer. The interview is around the future of C++, but also takes a look at its past and present. by cpp.chat

39 min listen

The Answer Is, It Depends: In this episode we welcome back Tony and Klaus to talk about the [SOLID](https://en.wikipedia.org/wiki/SOLID) Principles, and how they relate (or not), to C++. Tony is about to give a keynote at C++ Now about his take on the SOLID Principles. Klaus has been giving a talk on applying SOLID to C++ and even Phil has recently given a talk on a similar topic. Perhaps somebody should have mentioned this to Tony before! Along the way we get plenty of SOLID advice, discover what the single responsibility is that Tony's objects have, what COLID is, who is going to argue against Liskov, and who is just there for the jokes. The answer, of course, is: it depends. by cpp.chat

72 min listen

Required to Warn You, Unless It’s Hard: This week we get back on track and chat with Christopher Di Bella from Google about working on the Chrome OS toolchain - including his newly finished concepts implementation. We talk a bit about the practicalities of bringing C++ 20 features to compilers, interoperating GCC and Clang and how to deal, portably, with std libraries that can’t be implemented without compiler support. by cpp.chat

64 min listen

I'm a Bit Rusty: This week we have a special panel made up of members of the C++ community, joined by members of the Rust community. We have a round table discussion of how the two languages relate, differ - and how entwined their fates may be. We also learn why Rust doesn't have random numbers, but why it's lucky to have Burnt Sushi. by cpp.chat

70 min listen

Izzy's 'Fine' With Modules: This week we chat with Isabella (Izzy) Muerte about modules, build systems and more. We talk about xyr new job (which, at the time of recording, was with Netlify), and how that still involves working on build systems - but particularly CMake, where xe has found an intriguing special use for emoji! We segue into a discussion about modules, which Izzy was definitely down on a couple of years ago, and what xe thinks of them now. To avoid spoilers don’t read the title! by cpp.chat

70 min listen

Chairs Around a Tony Table: This week we chat with Tony Van Eerd about what comes after Post Modern C++, what the single most important principle for good code is, and what Dr. Seuss and Shakespeare have to do with all this. The off-by-one jokes are regular, or at least semi-regular, but what proposals has Tony killed? And how can opening your mind to unexpected ways of thinking lead you to better code? by cpp.chat

70 min listen

I Really like Sugar: This week we chat with a Conor Hoekstra, about dreaming in algorithms, being a programming language addict and writing beautiful code. We look at what Conor is jealous of in other languages, why his competitive coding entry came dead last, and why he really likes sugar and dopamine. And is it really true that no-one is listening to Sean Parent? Note that this episode was recorded over four months before editing, so the news items are a bit stale. by cpp.chat

66 min listen

My Friends Call Me Bool: This week we chat with a vector-of-bool (a.k.a. Colby Pike). We talk about pseudonyms, modules, build systems and his standard layout proposal, Pitchfork. At the last minute we branch into TDD and what makes good design. But what prompts Michael Caisse, in the chat, to respond, 'because we are not monsters', and why does that cat say 'test first'? by cpp.chat

64 min listen

It Doesn’t Get Bored and It Doesn’t Get Tired: This week we chat with a Yuri Minaev, of PVS Studio, about static analysis - and why you shouldn't be skipping on this essential part of software development. Why is using a static analysis tool better than peer review (the clue is in the title)? Should you do both? What is the most common bug? And what does happen if you write to address zero? We also discuss the billion dollar mistake and the perils of copy & paste (and how you can mitigate them). All in all, a step towards safer coding. by cpp.chat

67 min listen

The Problem Is, They Expect Answers: This week we chat with a panel of C++ trainers from around the world (but mostly from Germany, for some reason) - Nicolai Josuttis, Jason Turner, Rainer Grimm, Klaus Iglberger and Mateusz Pusz. We talk about how bringing in a good trainer will keep your costs down, whether online training works or not, and why C++ is different to most other languages when it comes to training. One of our guests reveals that he has had, and has recovered from, COVID-19 - but who? by cpp.chat

67 min listen

Willing to Steal Good Ideas: This week we chat with Bryce Adelstein Lelbach about how the ISO C++ WG21 committee is evolving - and his roles within it (and beyond) are evolving, too. We also look at the cross-over and interaction with the C standard, and even other languages. Is C really the Latin of programming languages? What is the relationship between the languages and the committees at this point? And why did so many committee members agree to a plan that contains items they may not be interested in? And what happened to the Varna meeting, anyway? by cpp.chat

68 min listen

Colour Is Not Black and White: This week we chat with James Berrow about colo(u)r, and how we're doing it all wrong (and not just the spelling). We look at why colour management is complicated, how RGB doesn't exist, and how everybody (well, almost everybody) gets it all wrong. We also look at the graphics proposal, and James' critique of it, as well as how he is working with the authors on some improvements. by cpp.chat

61 min listen

Ranting Is Optional: This week we chat with JeanHeyd Meneide (A.K.A. ThePhD) about coming full circle on std::embed, as well as whether optional references should rebind or assign-through. Packed with edge-of-the-seat stories of interesting proposals adventures through the standardisation process, as well as a decent amount of ranting. by cpp.chat

59 min listen

Copperspice Is Your Middle Name?: This week we chat with Ansel Sermersheim and Barbara Geller about Copperspice, Doxypress, csLibGuarded and kitchen utensils. We find out that Barbara and Ansel are not just library people but are actually programmers - and programmers that know how to build abstractions. We chat about why they started CopperSpice, how it got it's name, and what else they've been working on. by cpp.chat

64 min listen

Set a Breakpoint in the Past: This week we chat with Greg Law about debugging and going back in time! How do things change when we can wait for something to go wrong, then go back to any point in time and examine the program state, like The Matrix's 'Bullet Time'? How is this even possible, and what challenges need to be overcome? We also answer that age old question: what's the first thing people ask for when you say you can give them a time machine? by cpp.chat

61 min listen

We Almost Always Get the Default Wrong: This week we chat with Vittorio Romeo about the pros and cons of backwards compatibility in C++, and his proposal to get the best of both worlds: Epochs. As well as language compatibility, we also discuss _ABI_ compatibility - why breaking these things is such a problem, but how _not_ breaking them is increasingly becoming a problem. We also, finally, get an answer to the age of question of, 'how many programmers does it take to change a lightbulb?' by cpp.chat

58 min listen

If You Change It and You Break It, You’ll Know: This week we chat with Clare Macrae about Approval Testing, testing in general, the challenges (and some solutions to) testing legacy code - as well as highly visual environments like Qt GUIs or image processing apps. Working with an existing codebase that doesn't have tests can be scary and time consuming. But getting it under test is challenging, too. Clare explains how Approval Testing helps here, and how it all works. We also talk about how she has quickly become a sought after speaker, with some tips for first time speakers, and some more general ideas from Agile and Continuous Delivery circles. by cpp.chat

59 min listen

All the C++30 Features - but Right Now: This week, in a cpp.chat exclusive, we chat with Sean Baxter about Circle - the C++ compiler that he wrote. That’s a C++ compiler. That he wrote. Oh, and it does meta-programming in a way that we’re only dreaming of part of for C++23 or 26! So what can it do, and what is it useful for? Why is Jon struggling to wrap his head around what Sean has achieved and can it really turn Twitter into code? If you want to follow along screen shared segment, I've tried to embed screenshots in the podcast mp3 - or you can go to [this point in the YouTube recording](https://youtu.be/Tcaoz56uSKs?t=1044). And finally, contrary to what Phil says during the show, there were not 130 lightning talks at CppCon. It was more like 70 - and we're not including a link to the ACCU CfP as it has now closed). by cpp.chat

60 min listen

I’m Surprised You Brought up Rotate: In our second live CppCon 2019 episode we chat with Sean Parent about relationships, working with Alexander Stepanov, over-object-orientizing things and, yes, even rotate. Sean tells us stories from his years at Adobe, including how he first came to work with Stepanov (the father of the STL) - a well as some spectacularly bad responses to interview problems. by cpp.chat

46 min listen

You Get to Fix It the next Time: The first of our two, live, CppCon 2019 episodes - this time we sit with Andrei Alexandrescu and Herb Sutter to introspect about introspection and take exception to exceptions. We also talk about the 'Engage, Entertain, Educate: Technical Speaking that Works' class that Andrei was involved with, again, at CppCon 2019. But Andrei describes himself as a 'free radical' and 'too much plutonium' and claims he needs Herb as 'a bit of graphite' to keep him in check. Listen to find out what the debate is about! by cpp.chat

41 min listen

The Shape of the Value: This week we chat with David Sankel and Michael Park about their Pattern Matching proposal, as well as a language level variant. We look at how some judicious use of syntactic sugar can improve even the ugliest part of the sausage. Pattern Matching (as well as the language version of Variant) are progressing well through the committee - potentially on track for C++23. We discuss how, when these land, they are going to impact every single developer - allowing us to inspect and handle values in a far more declarative way, We also talk a bit about CppCon, which was upcoming as we recorded, but already in the past as we release this episode. by cpp.chat

53 min listen

There's No Secret to Security. The Secret Is ...: This week we chat with Patricia Aas about secure coding practices, using computers to count votes in elections and the two hardest problems in software development. Patricia and Phil have both been at NDC TechTown all week where Patricia gave a keynote, a two-day class, a talk and hosted a meet-up - but still found time to chat with us. We discuss the relationship between secure code and just plain good code (spoiler: they're essentially the same), and how much rigour went into computerising the Norwegian election vote counting system (spoiler: none). We also discuss whether it is possible to fully computerise national voting systems reliably (spoiler: you'll just have to listen). by cpp.chat

64 min listen

Aggressively Stealing from Other Languages: This week we're joined by Victor Zverovich as we chat about his string formatting library - which has just been adopted into C++20 - as well as the possibility of a corresponding input library, various smaller C++17 features, and whether it's possible to travel continuously from C++ event to C++ event. We also announce the dates for C++ on Sea 2020, Phil's vision for CppCon's Lightning Talks, as he takes them over, whether we should be removing more from the standard, and look forward to seeing The Last Macro. by cpp.chat

57 min listen

Can Everyone Stop Saying "Tupple": This week we chat with Guy Davidson about linear algebra coming to C++, other mathsy stuff, audio, games dev and C++ training evenings. We barely even mention 2D graphics once! Did you know that Guy has written four linear algebra libraries in C++ since 1990? He's in a good position to be involved with the standardisation effort. But how do you bring something that Fortran excels at to modern standard C++ without it just being the C++ification of Fortran? Listen to find out. by cpp.chat

64 min listen

Hell's Corner: Shared Mutable State: This week we chat with Juan Pedro Bolívar Puente (a.k.a. JuanPe) about immutable data structures, value types and more - and definitely not functional programming! How can data types be valuable if you can't change them? How can copying huge amounts of data be cheap? How can we go beyond Object-Oriented Programming - and get concurrency almost for free - all without making moral judgements about our code? The answers to all this and more drop out of our chat with Juan Pedro. by cpp.chat

62 min listen

How Often Do People Move Functions?: This week we chat with Pablo Santos, founder and chief engineer of Plastic SCM, and SemanticMerge. Pablo talks to us about how the 'full stack' version control system he created at Plastic SCM differentiates itself in the age of GitHub, how times have moved on for VCS systems (largely driven by GitHub), and how it might even be being used outside of software projects now. We also chat about SemanticMerge, which can automatically - and accurately - merge far more cases than the traditional text-only merge tools, and what this means for coders. by cpp.chat

55 min listen

You Do Not Understand Anything as Well as You Think You Do: This week we chat with Ivan Čukić about Functional Programming, despite him not wanting to be known as 'The Functional Programming Guy', TMP and OO, and how he was taught C++ in high school. How does Ivan balance writing books (in fact will he write another book?) and speaking at conferences internationally, while teaching full time at university? by cpp.chat

59 min listen

Discover this podcast and so much more

We’re Not Going to Allow You to Throw ? Anymore

We’re Not Going to Allow You to Throw ? Anymore

Description

Titles in the series (59)

More Episodes from cpp.chat

Related podcast episodes