Especially in a CRUD situation, every custom procedure will probably have a few basic steps that stay the same. All you usually need is a pre and a post hook.

It's tempting to think that for e.g. a CRUD situation, pre- and post-hooks are all you need.

And it may be that way at the beginning, although hardly so, except for the simplest applications. But very soon, you start to run into things like (not an exhaustive list, but all are things I actually encountered while trying to do precisely what you're saying, many years ago):

* Transactions, when multiple things have to happen atomically. Your pre-hook must start a transaction, and your post-hook must commit it. But what if there's an error somewhere? Python and JS don't have RAII, so you need some kind of catch block to abort the transaction. Where does that happen?

* Tricky validation, e.g. needing to do queries against the data store to check the request is well-formed. So if you're using an event-based language, your pre-hook also needs to be asynchronous.

* Data transformations (what the user sends will hardly be what needs to end up in your data store), so your pre-hook needs to be able to return a new object.

* Tracing across service calls, so you need to pass some kind of request ID as well to your hooks.

* An "update" request needs to return something (e.g. an ID) to avoid another round trip. But sometimes it needs to return more stuff, so your post hook must be able to return data. Oh, but your ORM or DB usually returns the created object, so you'd like to use that instead of re-fetching in your post-hook, so now your post-hook must accept that as well.

These just keep coming up. The first three in particular are usually guaranteed to happen before the first release of the product, since requirements always change. Soon you have an unmaintainable monstrosity. A little copy-paste is tame in comparison.

And the proposed solutions of hooks, AOP etc all start down the road of scattering actual logic across files and methods making the code harder to reason about which seems to be the worst part of overeager abstraction.

The library Automapper from C# is another place I run into this a lot. At its core it simply maps from domain to dto properties but you soon end up needing awful unwieldy configs and magic. I'd rather have a few hundred lines of obvious mapping than ever work with automapper again.

[1] https://www.gnu.org/software/emacs/manual/html_node/elisp/Ad...

A further elaboration on that idea. I like it, but have used it in a disciplined way. There's some valid criticism of its ability to obfuscate a program. Particularly with the ability to add and remove advice dynamically, making static analysis (to determine why something happens) practically impossible.

This difference is something important to stress.

“Imagine writing an A”

Then they look at what fires and record it.

Instead you’d ask “imagine typing an A” and then do the same thing.

Eventually when brought training happens to capture variation you start to get visual feedback and can train faster.

Why do you say this? anything I can read about ? From what I see in the news the government makes a plan for the future and executes it, it does not care about some billionaires or some company.

China does not need to create a convoluted scheme to pump money into some company, so it makes no sense. They could just give the population the miracle medicine/plant stuff and then write a contract for the big pharma for some vitamins that will be mandatory.

That being said, Windows 11 is a free upgrade. So aside from just not liking the changes (I personally like most of them) there's not much room to complain about Windows 10 not actually being the last version of Windows.

If your computer is new-ish.

That being said, the cutoff line for Windows 11 CPU support does seem to be a bit higher than necessary. But I don't know all of the reasoning behind why they chose the point that they did.