

Algorithms + Data Structures = Programs
Conor Hoekstra, Bryce Adelstein Lelbach & Ben Deane
The Algorithms + Data Structures = Programs Podcast (aka ADSP: The Podcast) is a programming podcast hosted by two NVIDIA software engineers that focuses on the C++ and Rust programming languages. Topics discussed include algorithms, data structures, programming languages, latest news in tech and more. The podcast was initially inspired by Magic Read Along. Feel free to follow us on Twitter at @adspthepodcast.
Episodes
Mentioned books

Nov 3, 2023 • 34min
Episode 154: Programming Languages Galore with Jonathan O'Connor
Jonathan O'Connor, a programming language enthusiast, discusses the popularity and evolution of programming languages, including C, Ada, Zig, Nim, Carbon, Eiffel, Weewa, and Closure. The podcast explores topics such as package development, the reasons behind C's popularity, and the future of programming with AI-assisted development.

Oct 27, 2023 • 36min
Episode 153: Pascal vs C vs Ada with Jonathan O'Connor
Jonathon O'Connor, Co-founder of Glockenspiel, discusses Pascal, C, Ada, and why C became more popular than Pascal. They also talk about IBM's clean house approach to code development and the benefits of visualizing algorithms on paper.

Oct 20, 2023 • 33min
Episode 152: Ruby in Rwanda with Jonathan O'Connor
Jonathon O'Connor, a programmer experienced in C++, Java, Ruby, and Rwanda, discusses his career journey. The podcast covers topics such as the benefits of using Ruby over Java, programming builders and netbooks for ATMs in Rwanda, and the development of the M-Pesa mobile app in Kenya.

Oct 13, 2023 • 36min
Episode 151: Is C++ Dying (Response)
Exploring the significance of saving C++, humorous discussion about air tags, addressing social media response, advocating for maintaining the existing C++ codebase, importance of using alternative terms, and discussing completing streets and weighted edges algorithms.

Oct 6, 2023 • 46min
Episode 150: Is C++ Dying?
The podcast discusses the slow progress of C++ and the potential demise of the language. They compare C++ and Rust, reflect on the challenges of learning new languages, and explore the lack of progress in implementing long-awaited features in C++. They also debate the current state of C++, the shift away from C++ by companies like Google, and propose potential solutions for the language's future. The podcast ends with discussions about the challenges of bringing a new direction to the community and future plans for the podcast.

Sep 29, 2023 • 50min
Episode 149: CityStrides.com, Graph Algorithms and More!
The hosts discuss their recent vacations, reflect on the challenges of running in different cities, and share their thoughts on Elon Musk. They also delve into graph algorithms and optimizing path generation in OpenStreetMaps. Additionally, they touch on topics such as LinkedIn followers, R programming, and Rust programming.

Sep 22, 2023 • 34min
Episode 148: 🇸🇮 SRT23 - Robert Leahy on C++ in FinTech
Robert Leahy, specialized in graphics and gaming, discusses C++ in FinTech. Topics include the ISO C++ Committee, proposed data structures like the hive, and prioritizing data access for financial market data. Also, the hosts record while walking in Venice and wrap up their Slovenia road trip.

Sep 15, 2023 • 30min
Episode 147: 🇸🇮 SRT23 - Parallel std::unique Revisited (on a Walk in Venice)
The hosts record live from Venice and revisit the parallel std::unique implementation. They explore the implementation of unique and parallel algorithms in thrust, discuss the design of the thrust library, and ways to optimize the 'copy if' function. They also discuss the implementation of unique count and potential improvements, go on a quest for donuts in Venice, and delve into the naming and functionality of 'unique count' and 'unique copy' algorithms.

Sep 8, 2023 • 24min
Episode 146: 🇸🇮 SRT23 - Algorithms, BQN's Superpowers & More!
The hosts discuss the SI Combinator in Haskell, chunk buying, and group buying. They explain a unique algorithm without temporary storage and explore the technique of down sweep and up sweep for scan operations. They discuss transform reduce, the relationship between algorithms and data structures, and the practicality of different container types in programming. They also talk about tolls in Italy, the value of hash maps, designing parallel algorithms, and the superpowers of array languages.

Sep 1, 2023 • 26min
Episode 145: 🇸🇮 SRT23 - Parallel std::unique
The hosts discuss the parallelization of 'std::unique' and the use of 'copy_if' and 'adjacent_transform' in its implementation. They explore the implementation of adjacent difference in the `thrust` library and its challenges. The speakers talk about strategies for parallel unique operations, including reduction and chunking. They also discuss the key properties of a scan operation and reflect on their road trip and upcoming episodes.