In this engaging discussion, Peter Saxton, the creator of the EYG programming language, shares his journey in developing a tool designed to address functional programming challenges. He dives into the revolutionary features of EYG, like a type-safe eval() operation and effect types. The conversation also covers concepts such as error handling, the intricacies of number representation, and the importance of transparency in programming design. Together, they explore how EYG improves interoperability and sets new standards for modularity and performance.

Will Sentance, founder and CEO of CodeSmith and the mind behind the Hard Parts series, discusses the merging of AI and programming education. He delves into how AI tools reshape learning, emphasizing the need for critical thinking. Will highlights the importance of mentorship and experiential learning, including pair programming. They explore foundational knowledge and the various programming paradigms, emphasizing the evolving nature of software careers and the skills needed for future success in this dynamic field.

Kyle Boddy, founder and CTO of Driveline Baseball, dives into the transformative power of data-driven approaches in sports. He shares insights on how high-speed cameras and AI technologies revolutionize player analysis and coaching methods. With a background in PHP and C++, Kyle discusses the early challenges of tech development in a garage setting and the evolution of software tools that enhance athletic performance. Listen as he highlights the importance of reskilling in the face of rapid technological changes.

For the 100th episode of Software Unscripted, Richard talks with Chris Lattner, creator of Swift, the Clang C++ compiler, LLVM, and now the Mojo programming language, about Mojo, Roc, API design, compiler optimizations, and language design!"Swift for C++ Practitioners" by Doug Gregor - https://www.douggregor.net/posts/swift-for-cxx-practitioners-value-types/Mojo - https://www.modular.com/mojoModular Computing - https://www.modular.comRoc - https://roc-lang.orgLLVM - https://llvm.orgClang - https://clang.llvm.orgSwift - https://www.swift.orgCUDA - https://developer.nvidia.com/cuda-zoneSIMD - https://en.wikipedia.org/wiki/Single_instructionmultipledatacmov instruction - https://github.com/marcin-osowski/cmov Hosted on Acast. See acast.com/privacy for more information.

Eli Dowling, a contributor to the Roc programming language, delves into the fascinating world of language design and editor tooling. The discussion highlights innovative error recovery in parsers, the benefits of tree-sitter, and the complexities of macros. Eli shares insights on the balance between functionality and user experience, especially in code editors. They explore the implications of implementing hygienic macros and the challenges of enum types, emphasizing the need for clarity and simplicity in programming languages.

Kelly Shortridge, a security expert and author of a book on security chaos engineering, delves into the CrowdStrike incident that created global tech turmoil. They dissect the implications of flawed software updates, emphasizing the need for robust cybersecurity practices. The conversation explores the divide between software and traditional engineering, advocating for better integration in security measures. Shortridge also highlights the significance of kernel-level access for security tools and the need for collaboration between software engineers and security teams to tackle emerging threats.

Distributed systems scientist Jonathan Magen discusses functional programming in distributed systems using languages like Gleam, Elixir, Ballerina, and Jolie. They cover type inference, big data processing, and the advantages of using purely functional languages in ensuring code reliability.

Tom Ballinger discusses undo and redo in REPLs, stateful systems, hot code loading, and database query planning. Topics include using Redis for undo operations, managing persistent state in a REPL environment, enabling time-rewind mechanisms in games, maintaining determinism in software projects, and cache invalidation in web applications.

Juan Vuletich, creator of Cuis Smalltalk, discusses the dynamic nature of Smalltalk, its origins, and evolution. They touch on personal computing, object-oriented programming, and the influence of Smalltalk on modern languages. The conversation explores image processing, graphics evolution, and the transition to vector graphics in UI design, as well as the evolution of GPUs for parallel processing and dynamic document formats.

Wolfgang Schuster discusses his transition from game to web development, comparing automated testing, dependency management, and release cycles. He explores programming patterns, forking frameworks, manual vs automated testing, and balancing code optimization. The conversation delves into coding mistakes, customizing physics in Unreal Engine, and the importance of user experience in both sectors.