# porcelain question: state of the art for undo-redo?

2 messages from 2005-06-11 to 2005-06-14. Participants: Jon Seymour, Daniel Barkalow.
Thread: https://gitlist.dev/t/906

## Jon Seymour, 2005-06-11 08:51

Subject: porcelain question: state of the art for undo-redo?
Message-ID: <2cfc40320506110151624b3ec1@mail.gmail.com>
URL: https://gitlist.dev/e/2cfc40320506110151624b3ec1%40mail.gmail.com

```
What porcelain layer solutions currently exist for effective undo-edit-redo?

For example, if you are working on a series of patches in a series,
then realise there is a mistake in a patch early in the series, how
does one mod that patch, then reapply all the following patches to
produce a slightly modified patch series with as little stuffing
around as possible?

jon.
-- 
homepage: http://www.zeta.org.au/~jon/
blog: http://orwelliantremors.blogspot.com/

```

## Daniel Barkalow, 2005-06-14 01:25

Subject: Re: porcelain question: state of the art for undo-redo?
Message-ID: <Pine.LNX.4.21.0506132056210.30848-100000@iabervon.org>
URL: https://gitlist.dev/e/Pine.LNX.4.21.0506132056210.30848-100000%40iabervon.org
In-Reply-To: <2cfc40320506110151624b3ec1@mail.gmail.com>

```
On Sat, 11 Jun 2005, Jon Seymour wrote:

> What porcelain layer solutions currently exist for effective undo-edit-redo?
> 
> For example, if you are working on a series of patches in a series,
> then realise there is a mistake in a patch early in the series, how
> does one mod that patch, then reapply all the following patches to
> produce a slightly modified patch series with as little stuffing
> around as possible?

I personally commit changes as I make them (essentially, and time I'm
about to make a change that might not work out, I commit the previous
state). Once I'm completely satisfied with the results, I redo the whole
thing as a series of commits from the base as self-contained changes.

To do this, I get a repository which contains the base (as master) and the
result of my previous work. Then I repeat the following steps:

Diff the work against the head into a temporary file.
Remove all of the hunks I don't want yet from the file.
Apply the file.
Commit.

I stop when the diff is either empty or contains only junk I didn't
actually mean to include.

Then I submit the series thus created.

I generally then diff once more, remove anything I actually don't want to
have (as opposed to wanting to have but not submit), apply and commit to
form a new work head. Then I throw away the old work head.

If I screw this up, I just start over, since I have all the actual content
safe.

	-Daniel
*This .sig left intentionally blank*


```