Our AI writing assistant, WriteUp, can assist you in easily writing any text. Click here to experience its capabilities.
Resolving the Great Undo-Redo Quandary
Summary
The article discusses the Great Undo-Redo Quandary (GURQ) - a problem that occurs when you undo a change in an editor or word processor, make some additional changes, and then find that your redos have disappeared. The article argues that there is a better way to resolve the GURQ, which involves recording all changes in a linear history, so that any previous state can be recovered. The article also discusses some potential memory usage issues with this approach.
Q&As
What is the Great Undo-Redo Quandary?
The Great Undo-Redo Quandary is a problem that occurs when you're editing something and you undo a certain number of changes, make some new changes, and then your redos disappear because the editor doesn't know what else to do with them.
How have people attempted to solve the Great Undo-Redo Quandary in the past?
In the past, people have attempted to solve the Great Undo-Redo Quandary by using a linear/stack-ish data structure for undo-redo when a tree seems more appropriate. However, this solution is not often used because it requires a navigation system for users to pick their way back through the undo-redo history, which is complicated and time-consuming.
What is the author's proposed solution to the Great Undo-Redo Quandary?
The author's proposed solution to the Great Undo-Redo Quandary is to use a linear data structure for undo-redo, but to preserve all edit states so that they are reachable. This way, if you change your mind about changing your mind, you can still go back and redo the changes.
How would this solution work in practice?
In practice, this solution would work by having an undo stack and a redo stack. When you make a change, it is added to the undo stack. If you then undo that change, it is added to the redo stack. If you change your mind about undoing the change, you can simply redo it and it will be added back to the undo stack.
What are the benefits of this solution?
The benefits of this solution are that it is simple and easy to use, and that it preserves all edit states so that they are reachable.
AI Comments
👍 This is a great article that offers a clever solution to a common problem.
👎 This article is overly complicated and does not offer a practical solution to the problem.
AI Discussion
Me: It's about how undo-redo works in a text editor.
Friend: Oh, that's interesting.
Me: Yeah. It talks about how most text editors use a linear/stack-ish data structure for undo-redo, which can lead to the Great Undo-Redo Quandary.
Friend: What's the Great Undo-Redo Quandary?
Me: It's when you're editing something, undo a ways, make some changes, and your redos go {{{poof!}}} because the editor doesn't know what else to do with them.
Friend: Oh, that's annoying.
Me: Yeah. But the article says there is a better way.
Friend: Really? What is it?
Me: It's called the GURQ-orithm. Basically, it's a way to record everything you do in a linear history, so that you can always go back and undo any change you've made.
Friend: That sounds like it would be really useful.
Me: Yeah. I think it would be a great improvement to text editors.
Action items
- Implement the GURQ-orithm in your own editor.
- Use the Git revert command to back out individual commits.
- Consider making the switch to the GURQ-orithm in your editor.
Technical terms
- GURQ
- Great Undo-Redo Quandary
- Linear/stack-ish data structure
- a data structure that is organized in a linear fashion, like a stack
- Tree
- a data structure that is organized in a hierarchical fashion, like a family tree
- Navigation system
- a system that allows users to move around within a data structure
- Graphical user interface
- a user interface that uses graphical elements like windows and icons