Is self-modifying code alive?

Question

Programming

Hello, I recently stumbled across this thread. This is supposedly called as polymorphic code, but it is extremely difficult to find it under this name due to the OOP technique with the same name ...
Well, all the articles about this technique are dated 2005 or even later, nothing more recent can be found failed, but still interesting to know what happened to such an interesting direction.

I'm wondering if this direction is still alive, is it dead or has it evolved into something more interesting? (In theory, the articles write that this technique, as it were, died due to the appearance of windows, in which they slightly covered the ability to execute code on the stack and poorly documented information about functions that help execute code on the stack)

I was interested in this topic because. I am interested in the topic of reversing and anti-reversing, and in theory, this is one of the areas of anti-reversing.

Since I know python, I can say that if you close your eyes to the fact that python is interpreted and many other things, then we can say that there is a dead descendant of polymorphism in it, which is implemented by the exec function, which executes the code.

Well, that's basically it, it's interesting to hear information on this topic.

Link to two articles about what I mean:
https://habr.com/ru/post/272619/
https://www.securitylab.ru/blog/personal/vxlab/291...

Answer 1

self-modifying code is much more complicated than code of the same functionality, but not self-modifying code :) both in understanding and in debugging.
taking into account modern development and the terrible cheapness of hardware resources against the background of the high cost of human resources, it has died out as an excess.
at the dawn of computers, I remember reading a description of a game in which some game functions were formed right during the operation of the game.
As far as I remember, there was a large set of executable pieces in the file, from which chains of execution were formed by copying into memory, control was transferred to the beginning of which CALL'om, and at the end there was necessarily RET.
periodically the chains were reformed.

Answer 2

learn Lisp topic

Answer 3

It looks like this has now been replaced by machine learning and the processing of data received from the client's work with the software back into the system.
That is, games that adapt to your playing style or opportunities. Or, for example, DLSS 2.0 from NVidia, which allows you to increase the image without visible loss of quality, if the developers train the algorithm, etc.
That is, the behavior changes due to some external factors. The machine instructions themselves do not change. I think everything has evolved in this direction.