The Eric Normand Podcast

Eric Normand
undefined
May 3, 2021 • 13min

Could we build Newtonian mechanics on purpose?

The discussion highlights the evolution of Newtonian mechanics and its significance in physics. It poses thought-provoking questions about why it took so long to develop this foundational model. Drawing parallels to software design, the speaker offers insights on creating effective domain models. Additionally, the challenges of translating domain-specific knowledge into clear programming models are explored, encouraging listeners to engage with the research and build better solutions.
undefined
Apr 26, 2021 • 15min

How is domain modeling related to Starbucks?

We discuss two phases of domain modeling, one easy and one difficult.https://lispcast.com/how-is-domain-modeling-related-to-starbucks/
undefined
Mar 29, 2021 • 18min

Is design a noun or a verb?

Dive into the intriguing debate of whether design is a noun or a verb. Discover the importance of focusing on the design process rather than just labels. Learn from the iterative journeys of renowned designers like the Eames and the creators of the iMac. Challenge the static view of design by embracing it as a dynamic cycle of problem-solving and adaptation. This discussion promises to reshape your understanding of what design truly means.
undefined
Mar 22, 2021 • 19min

Has software design taken a wrong turn?

For audio, video, and text transcripts: https://lispcast.com/has-software-design-taken-a-wrong-turn/
undefined
6 snips
Feb 8, 2021 • 1h 27min

Form and Content in Computer Science

Delve into the legacy of a pivotal 1969 lecture that shaped AI. Discover the tension between form and content in computer science, drawing from Marvin Minsky's insights. Explore how technology should enhance, not dictate, educational experiences. Uncover the innovative collaboration between Seymour Papert and Marvin Minsky, focusing on computational models in learning. Reflect on how programming can transform cognition and problem-solving skills. Finally, appreciate the historical context of award-winning papers that have influenced the field.
undefined
Jan 25, 2021 • 1h 38min

One Man's View of Computer Science

For audio, video, and text transcripts: https://lispcast.com/one-mans-view-of-computer-science/
undefined
Jan 18, 2021 • 1h 32min

Computing Then and Now

Explore the groundbreaking contributions of Maurice Wilkes that revolutionized software libraries and microprogramming. Reflect on the historical challenges of early computer development and how our perspective on progress has evolved over time. Discover the shift from batch processing to time-sharing systems and the ongoing debates over programming languages. Delve into the importance of programming languages and data structures, and examine the role of the Association for Computing Machinery in fostering community in the tech world.
undefined
Jan 11, 2021 • 1h 9min

The Synthesis of Algorithmic Systems

Explore the historical significance of Algol and its role in shaping programming languages. The discussion highlights Alan Perlis's influence on language design, tackling the balance between efficiency and generality. Additionally, the evolution of programming flexibility is examined, celebrating languages like Lisp for their dynamic coding capabilities. The conversation navigates through past advancements and future possibilities, showcasing how these elements contribute to modern software development.
undefined
Dec 14, 2020 • 12min

Is Clojure a language for hipsters?

Dive into the world of Clojure, where stereotypes of 'language hipsters' are unpacked. Discover the real reasons developers choose it over mainstream choices like Python. The historical context sheds light on Clojure's evolution and its surprisingly stable nature. The conversation contrasts its perception with that of Common Lisp and Java, revealing a deeper understanding of tech adoption and community biases.
undefined
Dec 7, 2020 • 1h 42min

Lambda: The Ultimate GOTO

The podcast delves into the historical misconceptions surrounding go-to statements versus procedure calls. It critiques programming style and highlights a pivotal 1977 paper to clarify language design. The discussion expands to the complexity of structured programming and the importance of documentation. Furthermore, the debate on code clarity emphasizes alternatives to go-to statements, while exploring the impact of Lambda Calculus. The contrasting development philosophies of Fortran and Lisp are also examined, revealing insights into programming constructs and modularity.

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