When you wake up in the morning, you expect all the states and memories in your head to be much the same as where you left them the night before - which means they all had to be stored somewhere in a way that was recoverable. In addition, you expect to be able to learn some new thing without invalidating everything you knew already (unless it truly does).
If you turn off a program and then restart it and expect it to recover from where it left off, it had to have somewhere to store all of the states. As the task the program performs becomes more complex, so the states it needs to store become more dense. Many of the states that the program depends on are states of the algorithm - implicit in procedure variables, in frames on the stack and positions in streams of instructions. You could notionally save an image of all this activity, and restore the image later (which is what the operating system does every time it timeslices), but this doesn't address the problem of how parts of the program can be made visible to other parts, so interactions among its parts can also be saved. Also, if some part of the program needs to change, the program will typically be recompiled, severing any connection to its previous state.
An active structure contains all its states within its structure, so everything is potentially visible to everything else - there is no stack and no program pointer. Change to the structure can be effected locally without damaging states in other parts of the structure - it is long-lived in a way that a program cannot be. This long life affords it the luxury of being able to learn from its existence.