>>> git keeps a history that can tell me what changes rely on other changes
>>> semantically, not just syntactically.
>>
>> How?
>
> Exactly that "linear" order you're complaining about. The DAG of commits
> tells you which changes were written with one version in mind but
> without other changes in mind.

In other words, Git is *guessing* which changes depend on each other 
semantically from which changes were written at the same point in time 
in the same repo.

I could change thing X, and then change thing Y which has nothing to do 
with thing X, and still Git will assume a relationship exists there. 
Darcs, on the other hand, only concerns itself with *real* dependencies. 
It's true Darcs can't guarantee that a particular combination of patches 
will produce runnable code. It's also true that Git can't guarantee that 
the code in any particular commit object is runnable either.

> If I change on April 1 the semantics of function XYZ, then I write code
> on April 3 depending on the new semantics, and you on April 5 write code
> depending on the old semantics, you now have a dependency from your code
> to the April 1 code that isn't recorded anywhere in Darcs. It's recorded
> in git, tho.

For every true dependency, there will be a bazillion spurious ones. So 
it's a case of "Which is worse? Missing some real dependencies, or 
recording millions of fake ones?" Given that the former is much simpler 
conceptually, I'll go with that thanks.

> If I have a repository and I merge in a bunch of your changes and apply
> them, then I merge in a bunch of changes from Jim, I could very well get
> tons of conflicts if Jim didn't apply your changes when he started working.

Is this not the case for every known distributed version control system?

> It seems fragile to me to have a working directory and a repository
> where I can incorporate changes into the repository that I cannot get
> into the working directory to work on.

Why can't you get them into the working directory?

>>> git doesn't have to spend tens of hours applying 240,000 change sets to
>>> the repository in order to give me the latest version of the files.
>>
>> Neither does Darcs.
>
> Sure it does. Delete your working directory.
>
> When you clone git, it pulls down the repository, then creates the
> working directory from that. When you clone darcs, it sounds like it
> pulls down both the repository and the working copy (which would seem
> problematic if the working copy had changes to it that weren't recorded,
> yes?).

Wrong.

It doesn't pull down the working directory at all. Indeed, in the copy I 
put on my webserver, I *deleted* the working directory.

It pulls down the *pristine* copy, which contains only recorded changes. 
[And is compressed.] If you're silly enough to delete that, then you 
just broke your repo. (I'm not sure whether the repair command can fix 
this... I believe so, but I've never tried it. It probably won't be fast 
though.)

>>> git has all kinds of sweet tools to manipulate the repository in ways
>>> Darcs can't very easily.
>>
>> Ways such as what?
>
> Like the bisecting command, just as an example. Or the stash command.

Without looking those up, I don't know what they do.

> Or commiting things in phases.

You mean like if you go to record something and realise you want to 
tweak it first?

> Or efficiently giving me a copy of the files
> as they existed at a specific point in time. (Indeed, since Darcs
> doesn't actually record what order you pulled changes in, it seems Darcs
> can't really even do that inefficiently.)

You could add a tag before you pull anything in. Then if you have 
problems, you can go back to the tag. (Or just query exactly what 
happened after the tag.) But yes, I suppose the fact that you need to 
remember to do this could be considered a weakness. There's no really 
fundamental reason why Darcs couldn't keep a history of what's happened 
to your repo though. (And keep it local to that repo, not part of the 
shared change history.)

> BTW, if you ever want to play, there's a script for git that will import
> the changes from and export to a Darcs repository.

Given the radically different ways in which the two systems work, I 
imagine the history gets pretty mangled in the conversion - no matter 
which system you believe is the "correct" one.

>> 1. I will never wind up "working" on anything that's
>> version-controlled. I
>> am apparently doomed to spend the rest of my /working/ life rebooting
>> people's PCs because Word crashed, rather than doing interesting
>> coding tasks.
>
> <Yoda> And that is why you fail. </Yoda>

Is this the same Yoda who lived in a universe where you can literally 
make inanimate objects physically move just by *believing* that you can?

-- 
http://blog.orphi.me.uk/
http://www.zazzle.com/MathematicalOrchid*

Post a reply to this message