Algorithms + Data Structures = Programs

Conor Hoekstra, Bryce Adelstein Lelbach & Ben Deane
undefined
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.
undefined
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.
undefined
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.
undefined
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.
undefined
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.
undefined
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.
undefined
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.
undefined
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.
undefined
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.
undefined
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.

The AI-powered Podcast Player

Save insights by tapping your headphones, chat with episodes, discover the best highlights - and more!
App store bannerPlay store banner
Get the app