Hi all!

I held a presentation regarding SCM in general a few weeks back as part 
of a course and in that presentation I try to end it with a view ahead 
about what is the Next Step for SCM. So let me go "dreaming" here for a 
minute. :)

As many in this thread has correctly identified the main "issue" with 
SCM is that when several developers work on the *same* codebase in 
parallell it gets hairy, no matter which tool you use. Most open source 
projects actually do *not* do that, we normally work on smallish 
*different* packages or just a few people on the same package - so we 
normally don't get to feel the real *hurt* that a large commercial 
project often does. At least that is my perception.

Yes, MC and git are great. Darcs is in some respects even greater in 
this particular area (merging, cherry picking etc). But these tools do 
not capture what I like to call "developer intent" very good.

git and Darcs etc just manage files, they don't even know what language 
we are using. Darcs has something in the "right direction" and that is 
the token replace change, which is a small step towards "smarter change 
types".

MC knows it is Smalltalk source it is dealing with, but doesn't really 
use that knowledge as much as it could.

Deltas that I started working with (and came quite far with the help of 
Matthew Fulmer and a few others) goes a few steps further. A Delta 
distinguishes developer intent in greater detail than MC and could 
potentially be "smarter" because of that.

And this is where the general future of SCM lies I think, in two areas:

- Making SCM tools aware of developer intent. If I use RB to do a 
refactoring for example, why not *record that* and not just record the 
effects of the recactoring on the source code? If I rename a method in a 
class, and fix all senders of it, why not record it as a *method 
rename*? That way, if it is merged into another environment it can be 
handled much smarter and we could for example fix even more senders.

- Real time collaboration. If we can sit in a shared (in some controlled 
fashion) development environment in some kind of real time model, then 
lots of merging and conflicts would just say PUFF and go up in smoke. We 
are beginning to see this now with the new IDEs running "on the web" 
because suddenly it gets very natural to experiment in that direction.

regards, Göran