Test & Code in Python

Developing Software with Automated Tests

About the show

Topics include automated testing, testing strategy, software engineering practices, packaging, Python, pytest, data science, TDD, continuous integration, and software methodologies.
Also anything I think helps make the daily life of a software developer more fun and rewarding.
Hosted by Brian Okken.

Test & Code in Python on social media


  • 172: Designing Better Software with a Prototype Mindset

    November 30th, 2021  |  6 mins 53 secs
    software design

    A prototype is a a preliminary model of something, from which other forms are developed or copied.
    This episode is about growing better designed software with the help of a prototype mindset.

  • 171: How and why I use pytest's xfail - Paul Ganssle

    November 22nd, 2021  |  38 mins 26 secs
    pytest, xfail

    Paul Ganssle, is a software developer at Google, core Python dev, and open source maintainer for many projects, has some thoughts about pytest's xfail.
    He was an early skeptic of using xfail, and is now an proponent of the feature.
    In this episode, we talk about some open source workflows that are possible because of xfail.

  • 170: pytest for Data Science and Machine Learning - Prayson Daniel

    November 17th, 2021  |  45 mins 12 secs
    data science, machine learning, ml pipelines, pytest, software testing

    Prayson Daniel, a principle data scientist, discusses testing machine learning pipelines with pytest

  • 169: Service and Microservice Performance Monitoring - Omri Sass

    November 11th, 2021  |  30 mins 14 secs
    apm, microservices, performance monitoring, services

    Performance monitoring and error detection is just as important with services and microservices as with any system, but with added complexity. Omri Sass joins the show to explain telemetry and monitoring of services and systems that use them.

  • 168: Understanding Complex Code by Refactoring into Larger Functions

    November 2nd, 2021  |  11 mins 19 secs

    To understand complex code, it can be helpful to remove abstractions, even if it results in larger functions. This episode walks through a process I use to refactor code that I need to debug and fix, but don't completely understand.

  • 167: React, TypeScript, and the Joy of Testing - Paul Everitt

    October 21st, 2021  |  36 mins 52 secs
    javascript, react, tdd, typescript

    Paul has a tutorial on testing and TDD with React and TypeScript.
    We discuss workflow and the differences, similarities between testing with React/TypeScript and Python.

  • 166: unittest expectedFailure and xfail

    October 14th, 2021  |  6 mins 23 secs
    expectedfailure, pytest, python, unittest, xfail

    xfail isn't just for pytest tests. Python's unittest has @unittest.expectedFailure.

  • 165: pytest xfail policy and workflow

    October 7th, 2021  |  9 mins 44 secs
    pytest, software testing, xfail

    A discussion of how to use the xfail feature of pytest to help with communication on software projects.

  • 164: Debugging Python Test Failures with pytest

    September 14th, 2021  |  13 mins 17 secs
    debugging, pytest, python, software testing

    An overview of the pytest flags that help with debugging.

  • 163: pip install ./local_directory - Stéphane Bidoul

    August 20th, 2021  |  29 mins 39 secs
    packaging, pip, python

    pip : "pip installs packages" or maybe "Package Installer for Python"
    pip is an invaluable tool when developing with Python.
    You can use pip to install Python packages from pypi.org, or a different index, or a local directory.
    The way pip installs from a local directory is about to change, and the story is fascinating.

  • 162: Flavors of TDD

    August 3rd, 2021  |  22 mins 44 secs

    What flavor of TDD do you practice?
    In this episode we talk about Classical vs Mockist TDD, Detroit vs London, Static vs Behavior, Inside Out, Outside In, Double Loop TDD, BDD, FDD, Tracer Bullets, Rules of TDD, Team Structure, Lean TDD and so much more.

  • 161: Waste in Software Development

    July 20th, 2021  |  18 mins 49 secs
    agile, lean, value, waste

    Software development processes create value, and have waste, in the Lean sense of the word waste.
    Lean manufacturing and lean software development changed the way we look at value and waste.
    This episode looks at lean definitions of waste, so we can see it clearly when we encounter it.

  • 160: DRY, WET, DAMP, AHA, and removing duplication from production code and test code

    July 8th, 2021  |  14 mins 40 secs

    Should your code be DRY or DAMP or something completely different?
    How about your test code? Do different rules apply?
    Wait, what do all of these acronyms mean?
    We'll get to all of these definitions, and then talk about how it applies to both production code and test code in this episode.

  • 159: Python, pandas, and Twitter Analytics - Matt Harrison

    July 2nd, 2021  |  47 mins 51 secs
    data analytics, jupyter, pandas, python, twitter analytics

    When learning data science and machine learning techniques, you need to work on a data set.
    Matt Harrison had a great idea: Why not use your own Twitter analytics data?
    So, he did that with his own data, and shares what he learned in this episode, including some of his secrets to gaining followers.

  • 158: TDD in Swift - Gio

    June 18th, 2021  |  43 mins 20 secs
    software testing, swift, tdd

    Iterative processes that include writing test code and production code together, such as TDD, help make coding fun. Gio Lodi, author of TDD in Swift, joins the show to discuss Test Driven Development, software workflows, bottom up vs top down, rapid feedback, developer vs customer facing tests, and more.

  • 157: pre-commit - Anthony Sottile

    June 11th, 2021  |  41 mins 40 secs
    ci, code formatters, linters

    pre-commit started as a framework for running linters and code formatters during git actions via git hooks. It's grown and expanded and now supports an extensive list of languages and actions and manual running of actions. But even at it's core, it's great for letting computers nitpick about whitespace and formatting, so that code reviews can focus on architecture and design.

    Anthony Sottile discusses pre-commit, for using locally by developers, and pre-commit.ci, which can run actions during merge requests.