variedthoughts

The Python community is awesome because of the people. Python People is a weekly podcast about getting to know the people who help make the Python community great. It's less about the tech, and more about the people. First 3 episodes are with: - Michael Kennedy - Paul Everitt - Brett Cannon

This episode is a story about packaging, and flit, tox, pytest, and coverage. And an alternate solution to "using the src".

Python makes it easy to build simple tools for all kinds of tasks. And it's great to be able to share small projects with others on your team, in your company, or with the world.

When you want to take a script from "just a script" to maintainable package, there are a few steps, but none of it's hard.

Also, the structure of the code layout changes to help with the growth and support.

Instead of just talking about this from memory, I thought it'd be fun to create a new project and walk through the steps, and report back in a kind of time lapse episode. It should be fun.

Here are the steps we walk through:

0.1 Initial script and tests

0.2 build wheel with flit

0.3 build and test with tox

0.4 move source module into a package directory

0.5 move tests into tests directory

Roadblocks to writing tests, and what to do about it.

Some developers either don't write tests, or don't like writing tests. Why not? I love writing tests. In this episode we examine lots of roadblocks to testing, and start coming up with solutions for these.

Creating maintainable test suites for complex systems. The episode describes some complexities involved with hardware testing, then shares techniques for shifting complexity out of the test cases.

* quick overview of what test instruments are * discussion of API and communication with instruments * techniques for shifting complexity out of test cases

These techniques should apply to all test suites dealing with complex systems:

* Creating test cases that are easy to read and debug and tell a story about what is being tested. * Pushing setup complexity into fixtures. * Pushing lengthy repetitive API call sets into helper functions. * Using stable, documented, interfaces.

Nina Zakharenko gives some great advice about giving tech talks. We talk about a blog series that Nina wrote called "The Ultimate Guide To Memorable Tech Talks". This episode is full of great help and encouragement for your own public speaking adventures.

Some of what we discuss:

- overcoming the fear of public speaking - breathing and pausing during talks - planning your talk as well as planning your time to get ready for the talk - writing proposals and getting feedback on proposals - Nina's talk in PyCascades on programming Adafruit chips - types of talks that are often rejected - pre-recording demos to avoid live demo problems - why you should speak, even if you are an introvert - benefits of public speaking

Andy Hunt and Dave Thomas wrote the seminal software development book, The Pragmatic Programmer. Together they founded The Pragmatic Programmers and are well known as founders of the agile movement and authors of the Agile Manifesto. They founded the Pragmatic Bookshelf publishing business in 2003.

The Pragmatic Bookshelf published it's most important book, in my opinion, in 2017 with the first pytest book available from any publisher.

Topics:

The Pragmatic Programmer, the book The Manifesto for Agile Software Development Agile methodologies and lightweight methods Some issues with "Agile" as it is now. The GROWS Method Pragmatic Bookshelf, the publishing company How Pragmatic Bookshelf is different, and what it's like to be an author with them. Reading and writing sci-fi novels, including Conglommora, Andy's novels. Playing music.

This episode is a look back on 3 years of podcasting, and a bit of a look forward to what to expect in 2019.

I talk about: - statistics for the show, including download counts, etc. - how many episodes are about testing, how many about non-testing topics. - Python vs language agnostic topics - solo vs guest episodes - the top 5 episodes - stuff like that

And then a retrospective like:

- what went well - what was lacking - what's next

I'd like feedback on what you think went well, was lacking, and where to take the podcast.

Brett Cannon discusses the changes afoot in Python packaging as a result of PEP 517, PEP 518, starting with "How did we get here?" and "Where are we going?"

Discussed:

flit Poetry tox Continuous Integration setup.py, MANIFEST.in, etc. pipenv what's with lock files applications (doesn't go on PyPI) vs libraries (goes on PyPI) workflows dependency resolution deployment dependencies vs development dependencies will lock files be standarized multiple lock files requirements.txt

We discuss testing, of course, but we take it further and discuss:

tests for large systems, like kubernetes Testing in real world scenarios with all the configuration and everything Becoming a complete engineer by thinking about the end to end flow from the users perspective Learning from other roles, and the value of roles to allow focus and expertise We even get into Chaos Engineering and testing live systems.

This interview with Trey Hunner discusses his use of automated tests to help teach programming. Automated testing is a huge part of developing great software. But many new developers don't get exposed to testing for quite a while. But this is changing.

New ways to teach programming include automated tests from the beginning.

Trey Hunner is a former PSF director, a Python and Django team trainer, and he has been using automated tests to help people learn Python.

This episode starts down the path of test strategy with the first tests to write in either a legacy system or a project just getting off it's feet.

We cover:

- My approach to testing existing systems. - Put names to strategies so we can refer to them later. - Explain the strategies in general terms and explain why they are useful. - Discuss how these strategies are used in an example project. (The code is available on github).

Strategies covered today:

- Dog Fooding - Exploratory Testing - Tracer Bullet Tests - Act Like A Customer (ALAC) Tests - Manual Procedures - Initial automated tests at 2 levels, API and UI.

A discussion with Katharine Jarmul, kjam, about some of the challenges of data science with respect to testing.

Some of the topics we discuss:

* experimentation vs testing * testing pipelines and pipeline changes * automating data validation * property based testing * schema validation and detecting schema changes * using unit test techniques to test data pipeline stages * testing nodes and transitions in DAGs * testing expected and unexpected data * missing data and non-signals * corrupting a dataset with noise * fuzz testing for both data pipelines and web APIs * datafuzz * hypothesis * testing internal interfaces * documenting and sharing domain expertise to build good reasonableness * intermediary data and stages * neural networks * speaking at conferences

What started as a twitter disagreement carries over into this civil discussion of software testing. Brian and Paul discuss testing practices such as the testing pyramid, TDD, unit testing, system testing, and balancing test effort.

* the Testing Pyramid * the Testing Column * TDD * unit testing * balancing unit with system tests, functional tests * API testing * subcutaneous testing * customer facing tests

Try -q

M. Scott Ford is the founder and chief code whisperer at Corgibytes, a company focused on helping other companies with legacy code.

Topics include:

* How M. Scott Ford got into forming a company that works on legacy code. * Technical debt * Process debt * Software testing * The testing pyramid * iterative development * kanban * readable code and readable test code