Re: [Gnu-arch-users] Re: tla import versus tla commit

[John Meinel]

Stefan Monnier wrote:
> > > I think we'll be better off following an approach similar to NNTP (where the
> > > problem is also that once data is sent, you can't in general trace back all
> > > the copies): create a new kind of changeset which modifies a previous one.
>
>
> > Ick.  Sorting out such a collection of changesets by hand seems
> > horridly tedious and, operating globally (rather than in the
> > special-case local form I advocate for above) in the arch namespace
> > but extended with some kind of undo semantics sounds hopelessly
> > intractible (what is to become of mirrors, for example?  When can they
> > safely be used in your Brave New World other than when an
> > authoritative master server can be contacted?).
>
>
> Huh?  Mirrors would work just as they do now: if you've updated them since
> the `undo', they'll have the undo applied, otherwise they won't.
> The undo is a change propagated just like the others.
>
> Of course this change will not be a 100% undo in that it will leave a trace.
> E.g. the undo-change itself will have to be kept around so it can be
> propagated to further mirrors.
>
> And obviously, we can't allow just arbitrary archive changes via such
> special changesets.  Only some specific ones like `undo' or `updatelog'.
>
>
>         Stefan

Why not just commit a new changeset with the changes undone? That's 
already possible. It leaves a trace that at one point in time it was 
this way, but then it changed back to the old way.

If it's as simple as fixing the log message for the last commit, just 
commit an empty changeset and state that it refers to the old revision.

I'm pretty sure that Tom will always feel (and I agree with him) that 
changing the past is bad.

If you just have a bad commit/log message, I think the tack-something-on 
works fine.

I'm not sure how to handle accidental branching, that sort of thing. As 
if I say tag -S ..., it will create a project, and then that name is 
used. However, I can always tag into it again, from a completely 
different project and override the earlier branch.

I think the only problem here is that we as humans look at it and say 
"That's not very pretty, what are all these extra changes, etc". But 
those were really there, and life in general isn't all that clean.

Arch lets you fix the present to overcome the past, but it doesn't let 
you change the past. It seems a fine way to go about it to me.

John
=:->

signature.asc
Description: OpenPGP digital signature