Two different approaches to debugging a software problem:

The Sudoku approach: stare at the limited set of clues you have, and think harder and harder about them until you find a way to deduce something useful.

The Minesweeper approach: don't even try to figure out the solution from only the clues you have right now. Instead, focus on finding a way to acquire another clue, and then using that to get another, and so on. Eventually you've collected so many clues that the answer is obvious.

Sometimes the Sudoku approach is necessary, because you've got all the clues you're ever going to get. But I think my new motto is "Never Sudoku a problem when you can Minesweeper it."

@Patricia This is good knowledge because that book has been sitting on my shelves staring at me waiting for me to read it for a while.

@norootcause Yours, or quoting someone?

Liked this line: an ounce of practice beats a pound of theory, but a pound of practice needs an ounce of theory

@fanf @chrisamaphone Honestly I don't remember why I hated it quite as much as I did. I found it smug and condescending and generally full of facile advice. There must have been more to it than that, but I've forgotten all the details.

@chrisamaphone Thinking further back I also read all of Atlas Shrugged (I skipped the speech though), because I was bored and there wasn't much internet back then.

@chrisamaphone Oh I also hate read all of "Finite and Infinite Games" because I wanted to find out if it got better after the number of people I'd heard praise it.

It didn't.

@chrisamaphone it was partly because I thought it would be funny, partly because I didn't want to pass it on in case someone else read it

@chrisamaphone I read the Tao of Pooh and then burned my copy

@cfbolz Custom dunder methods is sortof how it works in Scala. There's a special `unapply` method that returns an Option of a tuple, and `match(x) { case Foo(a, b, c) }` matches when Foo.unapply(x) gives you a three-tuple matching a, b, c.

(I think. Some details might be wrong, and syntax probably is. I haven't written Scala in > a decade)

@ltratt @cfbolz I find it mildly useful even in fairly basic cases, but I think the only case where it really shines is when you want to nest patterns.

But e.g. here's some code I wrote recently that uses it and I'm not going to claim you couldn't express this without pattern matching (you could, easily) but I do think the pattern matching version is a bit cleaner.

@Edent I really hate how hard it is to find out who is linking to my stuff these days.

Wrote this up in slightly more detail: https://notebook.drmaciver.com/posts/2025-04-07-18:38.html

@tintvrtkovic yeah for sure. Misleading notation on my part given that sorry!

@tintvrtkovic No, it works with arbitrary matchers. e.g. `object(some_field=1)` matches if the field is present and its value is 1.

I think my notation is confusing you. `some_matcher` is just meant as a standin for an arbitrary match expression, and you're interpreting it as a variable literally named `some_matcher`

@tintvrtkovic Yup. It works like any other Python pattern match. Crucially though, it won't match if the object being matched doesn't have some_field.

Hey did you know that Python has arbitrary structural pattern matching?

```
match x:
case object(some_field=some_matcher):
...
```

This will match a value iff it is an instance of object and has the field some_field, whose value matches some_matcher.

@jcoglan I think password resets have always meant that your email is de facto a credential, so this isn't actually much worse for security reasons, but I still hate it. Adds a tonne of friction for no good reason.