
Gitless: an experimental version control system built on top of Git - rrrrtttt
http://people.csail.mit.edu/sperezde/gitless/
======
farginay
I wish the page described what the goal actually is - and what gitless is.

This is very hard to parse: "We are exploring what conceptual integrity means
with the goal of building a rigorous foundation for concept design."

Huh?

------
quarterto
So... what advantages does this provide over straight Git? Reading the docs,
it doesn't appear to abstract over Git at all.

~~~
saidajigumi
It removes the staging area, which also removes one of the more powerful tools
in git for teasing apart work into distinct ideas, whether for creating a
sensible commit history, or to separate "tangled" work into different
branches. For example:

    
    
        1. Write code
        2. Realize it's more than you want to commit at a go
        3. Stage just the files (or hunks, using `git add -i`) you want
        4. git stash
        5. confirm tests still work
        6. git commit
        7. git stash pop
        8. continue working, committing, etc.
    

I certainly understand the desire for cleaning up Git's CLI[1], but the
staging area is one of those truly new offerings in Git w.r.t. legacy VCS. One
that requires cognitive effort to learn but becomes a very useful tool in
practice.

[1] Cf. Steve Losh's infamous "Git Koans":
[http://stevelosh.com/blog/2013/04/git-
koans/](http://stevelosh.com/blog/2013/04/git-koans/)

~~~
egork8n
Except that in practice people tend not to perform steps 4, 5 and 7. They then
commit non-working code and honestly believe that their commit is OK, because
they saw all tests pass.

~~~
eridius
So, what, if people aren't using the full power of Git, the response is to
remove that power? That seems completely backwards. The response should be to
educate people on proper development practices.

~~~
egork8n
Sometimes it just feels like not removing the nuclear missile launch button
from a cage with monkeys arguing that we should not remove the power of
nuclear weapons just because monkeys are unable to understand the geopolitical
situation.

~~~
X4
Full Ack!

(awesome metaphor btw)

------
justinsb
A nice project: Git is a wonderful version control system, but the git cli
(the porcelain) definitely has some annoyances. I think submodules, for
example, are completely broken at the CLI level.

I don't think this project necessarily goes far enough though; the biggest
change I saw was getting rid of the staging area. Whether or not that's a good
idea, I was hoping for crazier ideas!

For example, how about something that is more aware of github, where my github
branches auto-update, and works nicely with forks, pull-requests and issues.
The git-review integration for gerrit is interesting along those lines:
[https://pypi.python.org/pypi/git-review](https://pypi.python.org/pypi/git-
review)

~~~
ash
I think git-subtree is a better approach than what submodules are doing.
Adding a submodule breaks things. E.g. `git clone` stops working as it should.
In contrast, git-subtree doesn't break anything, because it just merges
another repo history into the main repo:

[https://github.com/apenwarr/git-subtree](https://github.com/apenwarr/git-
subtree)

(also in git contrib/)

------
girvo
Hah. This makes me think of a quote I remember: Git is an excellent library
for building a DVCS. ;)

------
dominotw
I don't understand what it is supposed to do.

> Check out the documentation section to get started.

> Documentation: TODO.

~~~
odonnellryan
I see the documentation.

Seems to be Git without Commits - kind of. It seems to be better described
here:

> Unlike traditional version control systems (such as CVS and Subversion),
> Gitless is distributed. Rather than having a single, centralized repository,
> each user has her own repository that is synchronized with other
> repositories.

~~~
quarterto
That quote can be applied verbatim (but for s/Gitless/Git) to Git itself.

~~~
odonnellryan
That's true.

------
dack
I'm all for reimagining the concepts that go into version control, standing on
Git's shoulders. However, I think this is way too close to normal git for me
to think it's useful. It might be simpler in ways, but it feels more
complicated in others. For example, branches are pretty much the simplest
concept you can think of in Git currently - just pointers to commits
(referenced by name). Trying to think of them as separate lines of development
actually makes me a little nervous that I would clobber some history somehow.

Anyway, that's not to discourage the effort - this is how we move development
forward.

------
couchand
It looks like there's no concept of a stage, which would imply that commits
can only be made at a file level. This nerfs the single greatest feature of
git: git add -p

~~~
michaelmior
git add -p could just be replaced with git commit -p without adding a stage.
Although it doesn't seem like this is what Gitless does at the moment.

~~~
StavrosK
I would think that this is exactly what's expected in an experiment like this.

------
ealdent
Should be renamed Pointless.

We challenge all the basic assumptions of VCS and conclude ... git was right
all along it just needs some syntactic sugar.

------
CodeMage
_" if we were to challenge the very core concepts in version control systems,
what would version control look like?"_

I looked at the documentation and I see nothing that challenges the very core
concepts in version control systems. Did I miss something?

------
Fomite
Looks interesting, but front page doesn't do a great idea with selling me on
why I should spend a couple hours of my day experimenting. What will this _do_
for me?

------
4ad
I wish people compared new DVCS with git and mercurial, not with svn and cvs.
That's incredibly unhelpful now that everyone is familiar with DVCS.

------
js2
See also EasyGit -
[https://people.gnome.org/~newren/eg/](https://people.gnome.org/~newren/eg/)

------
michaelmcmillan
If Linus gets a hold of any of you guys, for just a second..

~~~
alerkay
I thought Linus had mostly worked on the inner workings of Git (the
"plumbing"). These are awesome. But the CLI part is not straightforward at
all. I keep seeing people new to Git having great pain to use it.

So, if some new folks come up and expose clearer CLI concepts than Git does,
then I completely agree with their initiative. On top of that, if it remains
compatible with existing Git repositories, then I will surely give it a try
and maybe use it regularly.

