The Reference Counting Podcast: Recent Episodes
Taylor Hutchison and Andy Collins
Taylor Hutchison and Andy Collins casual conversations about the technical and not-so-technical aspects of software development.
In this episode Andy and Taylor kick things about talking about the rules of programming or the guiding philosophy of a programming, which often go unspoken. The main topic is the log4j vulnerability (CVE-2021-44228), the role and responsibility of programmers in application security, and where we are as an industry with open source software.
Andy and Taylor are back from a road trip and reminisce about meeting in person for conferences and discus some of the features of C# 10. The main topic is the controversial idea of licensing software developers like other engineering professions. The history of licensing and what a license would require is discussed.
In this episode Andy describes a bug in some code that he wrote dealing with React, Firebase, and authentication. Taylor and Andy then discover how hard it is talk about code in a podcast format. We also talk about authentiation, application security, and how easy it is to make your application insecure by mistake. Taylor talks about his impresions with GitHub Copilot.
The File Transfer Protocol turned 50 years old in 2021. We walk through the history of FTP, how it came to be, how it has evolved, and how it has impacted our development careers.
We spend a lot of time talking about C#, but what is going on in the Java world? Andy has been doing some investigating and is ready to brief us.
How do we learn best? Is there such a thing as a learning style? This episode is all about our philosophy of learning (and teaching) programming. Andy also introduces a new word.
The main topic of this episode is testing. We compare unit, integration, and manual testing and what leads to better code and better applications. The story of Victor Vyssotsky and the Darwin game from Bell Labs is retold and interpreted for meaning.
In this episode we talk about what we want to change about C# language. We walk through our wish list without regard to how difficult or impractical such changes would be.
We take a look back at where the web has been and where it seems to be going and ask does it have a future? We talk PWAs, Angular, React, Blazor, micro-frontends, and other technologies and how they can coexist.
What is a code smell? How does a developer know when something is not right with the code. In this episode we talk about a developer's intuition and how that is related to code smells.
We discuss what we know and what we don’t know about mono-repos. Then we reminisce about a time when Twitter was different.
Taylor and Andy talk about teaching programming to others and how certain techniques are more helpful than others.
Type systems in several languages, including C#, TypeScript, and Haskell are discussed as we try to figure our what the ideal type system might be. Andy outlines the three stages of regular expressions.
Andy and Taylor muse over contrarian programmers and AI-assisted coding. Andy outlines his philosophy of teaching classes and objects to new programmers.
In this inaugural episode we introduce ourselves and attempt to define what kind of podcast we are creating.