Python on Hillel Wayne

Breaking the limits of TLA+ model checking

Mon, 17 Apr 2023 00:00:00 +0000

I haven’t written much about TLA+ on the blog since the new learntla went up. Any examples or special topics I think of go there instead. But I recently thought of a cool demo that doesn’t quite fit the theme of that book: there are some things you can’t easily check with the model checker but can check if you work with the state space as a directed graph.

Context Managers for Debugging

Thu, 01 Sep 2022 00:00:00 +0000

A small helper I use to debug some python programs:

from contextlib import contextmanager

@contextmanager
def debug_error():
    try:
        yield
    except Exception as e:
        breakpoint()
        quit()

### usage

with debug_error():
  x = 1
  y = 0
  x/y # x and y will be avail in pdb

You can also put things before the yield (which will run before the with block), and after it (to run at the end of the block.) Anything put after it will run at the end of the block. See @contextmanager for more info.

Notes

Path Objects

Tue, 23 Aug 2022 00:00:00 +0000

Python 3.4 added path objects, but most people still don’t know about them. They simplify a lot of file operations:

### Without pathlib

path = "path/to/file"

# parent dir
os.path.dirname(path)

# file suffix
os.path.splitext(path)[1]

# read file
with open(path) as f:
  x = f.read()


### With pathlib

path = pathlib.Path("path/to/file")

# parent dir
path.parent

# file suffix
path.suffix

# read file
x = path.read_text()

Paths are also OS-independent, so the same code will generally work on both Windows and Unix.

Crimes with Python's Pattern Matching

Sun, 31 Jul 2022 00:00:00 +0000

One of my favorite little bits of python is __subclasshook__. Abstract Base Classes with __subclasshook__ can define what counts as a subclass of the ABC, even if the target doesn’t know about the ABC. For example: class PalindromicName(ABC): @classmethod def __subclasshook__(cls, C): name = C.__name__.lower() return name[::-1] == name class Abba: ... class Baba: ... >>> isinstance(Abba(), PalindromicName) True >>> isinstance(Baba(), PalindromicName) False You can do some weird stuff with this.

Two workers are quadratically better than one

Mon, 02 Nov 2020 00:00:00 +0000

For latency, anyway. A common architecture pattern is the “task queue”: tasks enter an ordered queue, workers pop tasks and process them. This pattern is used everywhere from distributed systems to thread pools. It applies just as well to human systems, like waiting in line at a supermarket or a bank. Task queues are popular because they are simple, easy to understand, and scale well. There are two primary performance metrics for a task queue.

Property Testing with Complex Inputs

Fri, 19 Jun 2020 00:00:00 +0000

This was originally written as a tutorial for Hypothesis and will eventually be reproduced there, but it might still be useful for people using other property-testing libraries. This essay assumes some familiarity with Hypothesis. If you haven’t used it, a better introduction is here. Once you learn the basics, there are two hard parts to writing property-based tests: What are good properties to test? How do I generate complex inputs?

The Hard Part of Learning a Language

Mon, 27 Apr 2020 00:00:00 +0000

I want to do $THING. Normally I do my hacking in Python, which is okay but has lots of frustrations. My friends tell me $LANGUAGE is better for doing $THING. After going through the online tutorial, I can see why. Maybe I’ll try $LANGUAGE for this project! Just a few things I need to figure out first: How do I install it? The docs say brew install, but I’m on Windows.

How fast do I talk?

Mon, 28 Oct 2019 00:00:00 +0000

I speak very fast. It’s like the words are piled up in my mouth and I can’t say one without the rest tumbling out. Through my whole life people have told me to slow down, speak more clearly, and enunciate. I can do it if I concentrate but I quickly relapse into gushing out words. As I now give lots of conference talks, this has become a professional issue:

Python Negatypes

Thu, 26 Sep 2019 00:00:00 +0000

Back in 2007 Python added Abstract Base Classes, which were intended to be used as interfaces: from abc import ABC class AbstractIterable(ABC): @abstractmethod def __iter__(self): while False: yield None def get_iterator(self): return self.__iter__() ABCs were added to strengthen the duck typing a little. If you inherited AbstractIterable, then everybody knew you had an implemented __iter__ method, and could handle that appropriately. Unsurprisingly, this idea never caught on. People instead prefered “better ask forgiveness than permission” and wrapped calls to __iter__ in a try block.

Finding Property Tests

Mon, 08 Apr 2019 00:00:00 +0000

A while back I was ranting about APLs and included this python code to get the mode of a list: def mode(l): max = None count = {} for x in l: if x not in count: count[x] = 0 count[x] += 1 if not max or count[x] > count[max]: max = x return max There’s a bug in it. Do you see it? If not, try running it on the list [0, 0, 1]:

Property Tests + Contracts = Integration Tests

Sun, 17 Dec 2017 00:00:00 +0000

I’m a pretty big fan of contracts and property-based testing. While they’re both powerful, they do have tradeoffs: Contracts are simple and allow for complex conditionals, but you need to test them over a wide space to confirm them. Property-Based Testing can test your code over a very wide search space, but you have to come up with good generators and invariants. Maybe they complement each other: “your code doesn’t violate any contracts” counts as a PBT invariant.

Introduction to Contract Programming

Mon, 27 Nov 2017 00:00:00 +0000

I’ve namedropped contracts enough here that I think it’s finally time to go talk about them. A lot of people conflate them with class interfaces / dynamic typing / “your unit tests are your contract”, which muddies the discussion and makes it hard to show their benefits. So I’d like to build up the idea of contracts from first principles. We’re going to work in Python, up until the point where things get crazy.

Instructive and Persuasive Examples

Tue, 29 Aug 2017 00:00:00 +0000

I recently read No excuses, write unit tests, which argues Unit Tests are Good and You Should Write Them. For the most part I strongly agree with their message, which is why I feel kinda bad criticizing the essay. They provide this as “an example of simple testing”: constadd=(...numbers) => { returnnumbers.reduce((acc, val) => { returnacc+val; }, 0); }; it('should add numbers', () => { constexpected=15; constactual=add(1, 2, 3, 4, 5); expect(actual).

Hypothesis Testing with Oracle Functions

Fri, 21 Jul 2017 09:00:00 -0500

This post is about the Hypothesis testing library. If you’re unfamiliar with it, check it out! Property tests are a fantastic addition to your testing suite. All examples use pytest. Imagine we’ve written a bubblesort: def bubblesort(l: List[int]) -> List[int]: # blah blah blah What are some of the properties we could test? We could check that the input has the same length as the output: from hypothesis import given from hypothesis.

Doctests in Python

Thu, 16 Feb 2017 00:00:00 +0000

Doctests are one of the most fascinating things in Python. Not necessarily because it’s particularly elegant or useful, but because it’s unique: I haven’t found another language that has a similar kind of feature. Here’s how it works. Imagine I was writing an adder: def add(a,b): return a + b There’s two kinds of ways we can test it. The first is with unit tests, which everybody’s already used to.

Hate Your Tools

Tue, 27 Dec 2016 19:48:18 -0600