p.s. thanks to all those working this week :)

A tiny bit more context here:

https://github.com/nats-io/nats-server/discussions/3312#disc...

(I opened this discussion 2.5 years ago and get an email from github every once in a while ever since. I had given up hope TBH)

I hate to admit it, but flaky tests almost always highlight weaknesses in my software architecture.

And fixing a flaky test usually involves making the actual code more robust.

> Who tests the tests?

To me it's a bit like double entry bookkeeping. Two layers is valuable, but there's rapidly diminishing returns beyond two.

I think it's relative, right? That's how abstractions and interfaces work.

I can write a module with integration tests at the module level and unit tests on its functions.

I can now write an application that uses my module. From the perspective of my application, my module's integration tests look like unit tests.

My module might, for example, implicitly depend on the test suite of CPython, the C compiler, the QA at the chip fab. But I don't need to run those tests any more.

In your case you hope the in-memory database matches the production one enough that you can write fast isolated unit tests on your application logic. You can trust this works because something else unit-tested the in-memory database, and integration tested the db client against the various db backends.

My guess is the tunnel will become the preferred roosting spot for the bats.

> We once saw a comment in the generated code that said "I need some coffee".

B1M covered this. The video has a fun animation of the political history too:

https://www.theb1m.com/video/italys-12bn-bridge-mystery

Loved that one. We need something like this for NZ's south and north islands and so far ships are by far the best option.

Maybe some semi submersible, low-safety tube for cargo could make sense tho, but I'm not holding my breath.

New government cancelled $1.45b ferry replacement project for cost blowout and everyone expects it to cost even more.

I usually just use asyncpg.

You can use asyncpg in SQLAlchemy

Lol same, writing SQL and directly wrangling Async connection pools always seemed way easier for me than trying to jam sqlalchemy into whatever hole I'm working with.

Why is the first one needed?

I think the idea here is that your first approach is what you think is correct. However, there's a chance the model is just outputting text that confirms your incorrect approach.

The second one is a different perspective that is supposed to be obviously wrong, but what if it isn't actually obviously wrong and it turns out that the model is outputting text that confirms what is actually the correct answer for something you thought was wrong?

The third one is then a prompt that pushes for contradiction between the two approaches you propose to the model to identify the correct answer or at least send you in the correct direction.