Episodes

  • Ep #15: Kotlin - A Better Java?

    Clinton and Austin finally talk about Clinton’s favorite company (Jetbrains) and how they have applied themselves to language design. They take an in-depth look at how the company has attempted to make Java irrelevant with Kotlin, not just with the language itself but by fostering a community and integrating the language into their suite of developer tools.

  • Ep #14: The Linux Incident

    Clinton and Austin spend 20 minutes discussing HHS Human Subject Regulation flow charts. They also discuss the much more interesting story behind how a dispute between Linux maintainers and a research group resulted in an entire university being banned from contributing to the largest open source project in the world.

  • Ep #13: M1 Hype!

    Clinton imagines a future Apple release without graphs and Austin worries his future Mac might burst into flames. It’s also a detailed discussion about the architecture of the M1 and how Apple Silicon marks a shift back to Apple’s roots.

  • Ep #12: Design Patterns for Patternless Languages

    On this not so spooky episode, Clinton does his best sports ball announcer voice and Austin reflects on a year’s worth of episodes. They also wade into the debate over the usefullness of design patterns and whether modern languages have made them obsolete.

  • Ep #11: Turing Completeness

    After a breif hiatus, Clinton and Austin are back with a lengthy discussion of old technolgies made new and get in deep on the ways in which Turing Completeness shape the development landscape - from cyber security to language design.

  • Ep #10: Automation

    Clinton and Austin take a listener’s advice and talk about automation and its effects on society and developers. Clinton exstoles the virtues of “putting everything in the cloud.”

  • Ep #9: Shillin' and Chillin'

    Clinton and Austin dicuss recent developments in the .NET and Jetbrains spaces. Clinton shows off his sound design skills.

  • Ep #8: Use Case Goes Remote

    Clinton and Austin discuss how their handling this new all remote world. Clinton shares his dispair with living “in a box”.

  • Ep #7: Cheating at Design

    Clinton and Austin discuss articles written by Adam Wathan and Steve Schoger about how to be design-minded developers. Please stay home, stay healthy, and try to stay sane.

  • Ep #6: Containers!

    Clinton and Austin discuss the rise of Docker and how containers have changed development and infastructure. Clinton reminds us all of the dangers of tandem floats and Austin wishes everyone a safe and happy Mardis Gras.

  • Ep #5: Agile and Scrum

    Clinton and Austin shill some sweet Microsoft products and discuss how and why the tech industry is dropping Waterfall for Agile and Scrum. Lily borks… again.

  • Ep #4: The Failure of PHP

    On a very clickbait episode, Clinton and Austin discuss the internet’s love/hate (but mostly hate) relationship with PHP.

  • Ep #3: Functional Programming

    Clinton and Austin talk about what Functional Programming is, how it compares to OOP and how Functional paradigms have made their way into Object Oriented languages. This month’s Git Trendy also features special guest. Lily, a feisty Mini Schnauzer has something to say about DevOps - we’re just not quite sure what.

  • Ep #2: The State of Quantum Computing

    Clinton and Austin give an overview of the state of Quantum Computing. They discuss what a Quantum Computer is, how it works, and the implications of Quantum Computing for developers.

  • Ep #1: JVM vs CLR

    On the inagural episode of Use Case, Clinton and Austin compare and contrast JVM and CLR. The discussion broadens to include all of the Java and .NET ecosystems as well as the approaches taken by the companies who support them.

subscribe via RSS