I recommend La Cité de la dentelle, in Calais, North of France (good train stop between Paris and London).

Leavers machine that weight tons. Technology from 19th century that is still in production nowadays.

https://www.cite-dentelle.fr/collections-1/industrie-et-tech...

I don't get the logic of cleaning dishes BEFORE putting them in the dishwasher.

Not actually cleaning, just rinsing.

The logic is to prevent:

  - Chunks of fibrous vegetables (e.g.) from clogging the dishwasher filter
  - Wet sauces (or egg) from drying and hardening over the hours/days before the next dishwasher cycle, and becoming more difficult to remove

A lot of people don't know that dishwashers have filters that need to be cleaned regularly!

And many of us grew up with older dishwashers that didn't work as well as newer ones.

All of that said, modern dishwashers actually monitor the water (clarity, turbidity?) to determine whether the dishes are sufficiently clean. If you rinse your dishes too well, the dishwasher will prematurely think it has accomplished its goal, and reduce time/temperature to end the cycle early. This is why manufacturers recommend against rinsing or pre-cleaning.

In my household, we have a pair of zealous canine precleaners, who do an excellent first-pass job. The dishwasher's only responsibility is to rinse and sterilize. :)

You will after you have to pull the dishwasher out, turn it upside down and partially disassemble it to clean the filter which is blocking the flow of water intended to rinse your dishes.

I think people don't want to clog their dishwasher with pieces of food. If I have a couple pieces of spaghetti, a part of a leaf and half a chickpea stuck on the plate, I would remove them with a paper towel. Not sure why anyone would rinse it afterwards, though.

That reminds me of people who clean before the maid comes. I've never had a maid, but I've read that people do the easiest things themselves so the maid, who is paid by the hour, has to do the harder things only.

I do it and recognize that the logic is flawed, but it's a habit and just looks and feels correct at this point.

I think there is still space for an alternate Go syntax for scripting with the following constraints:

* a single file exposing a "main" package and its "func main()"

* import syntax that merges requires from go.mod (import both packages and modules)

* simplified error handling (just ignore returned errors in code, and they are caught by the transpiler to be handled as fatal)

Those are my ideas to go beyond my own goeval that already allows to run Go oneliners. https://github.com/dolmen-go/goeval

bitfield/script has some nice abstractions for bash builtins and coreutils

https://github.com/bitfield/script

Also, for Go oneliners: https://github.com/dolmen-go/goeval

(Disclaimer: author here)

… so presenting it as a paraphrase is misleading.

As you think Go is a wrong way for computing, tell us about the others routes that we should explore…

I'll take that bet.

Access control to your (customer's) data may also be a concern that rules out managed services like RDS.

I'm not sure what is meaningfully different about RDS that wouldn't rule out the cloud in general if that was a concern.

But first ensure that the input error is properly reported to the client in the response body (ideally in a structured way), so the client could have figured out by himself.

If a fix is needed on your side for this matter, having a conversation with a customer might be useful before breaking more stuff. ("We have no state code in EU. Why is that mandatory?").

If you are trying to sell a product, it is sometimes useful to solve people problems for them, rather than counting on them to figure them out on their own.

Log4J style logging is effectively a hook system. But it is too easy to badly use it with too high level and delegate level fixing to the end user.

TLDR: I agree.

A library might also be used in multiple place, maybe deeply in a dependency stack, so the execution context (high level stack) matters more than which library got a failure.

So handling failures should stay in the hands of the developer calling the library and this should be a major constraint for API design.