UpStare is a dynamic software updating system for multi-threaded applications. It discovered a new updating model called whole-program updating — and a new programming abstraction — that can apply live updates no other model can.
Live updates are the only way to keep some software continually running. The browser you are using to read this page and the server that prepared it will always need a live update. The alternative of waiting for software to restart happens often enough to cost tens of thousands of dollars per hour of downtime.
What makes UpStare different is that it updates live all the code and data of a program, not just parts of it. In particular, UpStare updates functions on the stack. You need this ability to update common multi-threaded server applications that can't be updated otherwise. If you were to update only parts of a program, without updating the stack, the update may take forever to finish safely and that practically means downtime. 
Although the approach is general for use in other programming languages, UpStare updates applications written in C. The updates are applied in three steps. First UpStare changes an application's source code automatically to make it updateable. Then it compiles the changed source code with an existing compiler like gcc to produce the executable file the user runs. Finally, when a new version of the source code becomes available, UpStare automatically generates an update patch to the next version. This update patch can be complemented by the user where necessary, and is applied easily on the running application at any time.
Whole-program updating in UpStare is implemented with a new mechanism called stack reconstruction.  This mechanism tears apart and restitches an application into a new version piece by piece. During this process the application does not exit, and network connections remain open. All functions on the stack are updated at the same time, which guarantees all active functions are of the same version after an update.
It wasn't as obvious in the beginning but stack reconstruction isn't just a mechanism. It's a programming abstraction. It is a means of doing easily something useful and hard in a programming language, similar to recursion or garbage collection.
Specifically, stack reconstruction is a means of modifying continuations: representations of the runtime state of a program. Modifying continuations is useful because you need to update the stack to apply some kinds of updates and the stack is part of the continuation. The stack also proved to be the hardest part to update without stopping a program that's running. It's more obvious now continuation updates help programs continue to run. 
Stack reconstruction is missing from programming languages. Existing languages don't modify continuations before they restore them. They don't make continuation internals accessible to be modified at such a fine grain. More generally, today's programming languages don't update whole programs live.
Though powerful, it's hard to tell how important stack reconstruction will turn out to be. Powerful programming abstractions like macros and continuations are rare. Most of them were discovered more than forty years ago. They also tend to stretch the way average programmers think to such a degree that the most powerful abstractions are used scarcely. It takes good programmers to use them. If an abstraction surfaced now that was used by good programmers it wouldn't just be powerful; it'd be a big deal.
Dynamic updates UpStare applied successfully include:
The software is available here and there is a user manual [HTML single] [HTML multiple] [PDF]. There are also papers: