News for hackers. Stuff that matters.
Re:Gitless: a version control system by k__ on Sunday October 02, 2016 @11:20AM (#12622746)
Git is, like many professional tools, something you simply got to learn.

But like with many professinal tools, you don't need to know everything to get to work.

I don't know all Photoshop or Ableton Live features, but I can improve my photos or create songs non the less.

With these commands you can already start your own repo and work on it locally:

    git init // crate new repo

    git status // show which files are changed and which of them are staged

    git add -p // add "chunks" of changed files to the stage

    git commit -m "<commit_msg>" // commit everything added to the stage with a commit message

    git log // show a list of commits

    git checkout <file> // throw away all changes since the last commit (one file)

    git reset --hard // throw away all changes since the last commit (all files)
If you want to work with a repo from somewhere else like Github etc., you need a few extra commands:

    git clone <repo_url> <target_dir> // clone a remote repository locally

    git pull // download and merge new commits in the remote repo that happened since the last clone/pull

    git push // uploading your own changes after a commit to the remote repo
I think these 10 commands are all that is needed to get your own project into Git.

Yes, the more people are working on a project, the more commands you need, like creating a new branch and getting commits from one branch to another, or amending commits because you forgot something etc.

For a professional tool this isn't too much, I think. The 10 commands I mentioned will be remembered in less than a week. Most of the rest isn't needed often (maybe merge/rebase and branch depending on how you intend to use Git), but they shouldn't take too long either.

Re:Gitless: a version control system by lisper on Sunday October 02, 2016 @02:50PM (#12623653)

    git checkout <file> // throw away all changes since the last commit (one file)

    git reset --hard    // throw away all changes since the last commit (all files)
This is a perfect illustration of why git needs a better UI. Two different commands to do exactly the same thing, with the only difference being that one is for one file and the other is for many files? If you tried to design a hard-to-use UI you could hardly do better than that.

[NOTE: these two commands actually don't do quite the same thing, which is part of the problem.]

Re:Gitless: a version control system by djur on Sunday October 02, 2016 @03:44PM (#12623881)
They do different things, anyway. `git checkout <file>` will restore files from the _index_, which means it actually discards changes since the last `git add`. It can also be used on the entire tree as `git checkout .`. (As an aside, I think that the different branch vs. tree behaviors for `git checkout` are the biggest UX wart in git.)

`git reset --hard` discards the index _and_ any unindexed changes. You can think of it as essentially `git reset` (which discards the index) followed by a `git checkout .`

I think a lot of the murkiness of git's usability comes from the fact that many commands have collected convenience flags that replicate the behavior of other commands. The rest comes from the fact that `git checkout` and `git reset` can affect any or all of 1) the contents of the working directory 2) the contents of the index 3) the contents of repository metadata like branch tips and HEAD, and you pretty much just have to learn what does what.

Re:Gitless: a version control system by lisper on Sunday October 02, 2016 @04:05PM (#12623969)
Yes, all this is exactly my point. It is nearly impossible to explain the current git UI in a way that isn't embarrassing at best and wrong at worst. And then it's nearly impossible to remember. The number of things you actually want to do 90% of the time is small, so I think there is value in designing a veneer that makes that 90% easy to explain and remember.
Re:Gitless: a version control system by Drdrdrq on Sunday October 02, 2016 @04:18PM (#12624025)
Hg did that - unfortunately GitHub won over BitBucket, thus deciding the fate of Mercurial too.
Re:Gitless: a version control system by shinymark on Sunday October 02, 2016 @09:18PM (#12625108)
I find Mercurial so much easier to use than Git. Many of the concepts are similar but the hg interface feels much easier to learn and use.
Re:Gitless: a version control system by david-given on Monday October 03, 2016 @05:01AM (#12626114)
I use Mercurial as a client for git, using the hg-git extension. It works absolutely fine for my use case (small numbers of developers on github, mostly). There are a few rough edges when you want to do things that git doesn't like, like moving tags, and the bidirectional branch<->bookmark syncing isn't quite as robust as it should be, but it saves me having to touch git at all.
Re:Gitless: a version control system by friendzis on Monday October 03, 2016 @02:01AM (#12625698)
At $dayjob we have a mixed bag of hg and git. I found that while git makes great distinction between local and remote (and working directory), hg is more similar to centralized VCSes. Any other remote action than "sync local with remote" requires Blak Magick Mumbojumbo™. Some "common" (as seen by original authors. Local throwaway branch is not such) tasks are sure easier than git, but stepping out of the beaten path becomes cryptic. Git, on the other hand, is of average difficulty for most of the tasks. Your mileage may vary.
Re:Gitless: a version control system by Drdrdrq on Monday October 03, 2016 @02:10PM (#12629851)
I'm curious, what other remote action do you miss with hg? Push and pull (to different remote repos if needed) are sufficient for me. What am I missing?
Re:Gitless: a version control system by jjoonathan on Sunday October 02, 2016 @03:35PM (#12623855)
But they don't do "exactly the same thing, with the only difference being..." unless you ignore the index, which is one of the extremely powerful abstractions that sets git apart. Sure, git could expose a simplified lowest-common-denominator interface that plasters over its differences, but the same interface would (and gitless does) plaster over its strengths and encourage people not to learn them.

I agree with TFA: this isn't a UI issue, it's an abstraction issue. Several of git's abstractions only make cost/benefit sense in a distributed environment. Unbundling the cost of learning dVCS abstractions would make git a better fit for the Cathedral and a worse fit for the Bazaar. This might be what you want, but you should at least be able to understand why other people do not want it.

Re:Gitless: a version control system by arielb1 on Monday October 03, 2016 @05:17AM (#12626151)
`git checkout` is indeed a stupid command, because it has 3 modes:

> git checkout [--detach|-b] <commit-ish>

Set HEAD to a new place and sync the working-directory/index to it.

> git checkout <paths>

Copy paths from the index to the working directory.

> git checkout <tree-ish> <paths>

Copy paths from a given commit to the working directory.

This means that "git checkout HEAD file" is different from "git checkout file".

Similarly, `git reset` has 2 modes:

> git reset <tree-ish> <paths>

Copy paths from a given commits to the index, leaving the cwd unchanged.

> git reset [--soft | --mixed | --hard] <commit>

Set *HEAD to a new place, and optionally sync the working directory/index to it.

This is obviously terrible, but changing the names now might be worse.

Re:Gitless: a version control system by strictfp on Sunday October 02, 2016 @03:42PM (#12623874)
They don't do the same thing implementation wise, but they do the same thing ux wise. This difference causes all discussions like the above: it seems as if some people like ux "plaster", while others like bare-metal tools.
Re:Gitless: a version control system by jjoonathan on Sunday October 02, 2016 @04:07PM (#12623973)
They do the same thing ux wise if and only if your mental model has no notion of a staging area.
Re:Gitless: a version control system by k__ on Sunday October 02, 2016 @04:32PM (#12624089)
I just stage parts of my changed code before commit. So things I work on are un-staged mkst of the time. Which eliminates the problem, I guess.
Re:Gitless: a version control system by djur on Sunday October 02, 2016 @03:45PM (#12623883)
They only do the same thing if you haven't previously used `git add`. If you have, `git checkout` will use the contents of the index, not the contents of the last commit.
Re:Gitless: a version control system by chungy on Sunday October 02, 2016 @02:55PM (#12623680)
Then use `git checkout -f` if it so pleases you. There's more than one way to skin a cat.
Re:Gitless: a version control system by ender7 on Sunday October 02, 2016 @03:04PM (#12623721)
To be honest, this comment is more evidence of a problem than anything else.
Re:Gitless: a version control system by popmystack on Sunday October 02, 2016 @05:55PM (#12624466)
They are not doing the same thing. It's two completely different operations.
Re:Gitless: a version control system by lisper on Sunday October 02, 2016 @07:24PM (#12624790)
You'll have to take that up with /u/k__.
Re:Gitless: a version control system by stevenhuang on Monday October 03, 2016 @12:52AM (#12625575)
How so? You're the one proposing they do the same thing when they fundamentally do not. To posit so is less of git's "ux problem" and more of just needing to grok git.

I share your concerns for consistent tooling, but the idea of becoming proficient in something without putting in the effort is not reality.

Re:Gitless: a version control system by lisper on Monday October 03, 2016 @01:33AM (#12625647)
> How so?

Because he's the one who said that they do the same thing.

Re:Gitless: a version control system by stevenhuang on Monday October 03, 2016 @02:57AM (#12625817)
I don't follow--where does he say that?
Re:Gitless: a version control system by lisper on Monday October 03, 2016 @11:45AM (#12628354)
Re:Gitless: a version control system by matt4077 on Sunday October 02, 2016 @11:57AM (#12622892)
This is very close to the result of the study that was I believe he reason to write gitless:

- Most people use git by learning a set of a few commands

- A minority actually understands git on a deeper level

But both groups form a mental model of how git works, and that model is apparently usually wrong, which results in those cases were you get stuck and just start with a fresh checkout and manually reapplying the changes you wanted to commit.

Re:Gitless: a version control system by copperx on Sunday October 02, 2016 @09:11PM (#12625083)
If both groups get the mental model wrong, how can we ever hope to get it right? read the Git source code?
Re:Gitless: a version control system by globuous on Monday October 03, 2016 @07:18AM (#12626523)
No, but there's a book called "Pro Git" by Scott Chacon and Ben Straub that popped up on HN not too long ago. It does explain git on the lower level without going into the git source code.

This book is over 500 pages, but chapters 1 to 3 will get you up and efficient within 2 hours. Especially chapter 3 (I skipped to it, I kinda knew the basic git commands from "experience"), which goes over branching and how it works. It explains how snapshots are handled and what points to what, which make working with multiple branches locally and remotely a pleasure actually.

It's honestly not to hard to get decent at git. Although I never realized how much of a tool git was until I heard about people writing 500 page long books about it.

Re:Gitless: a version control system by matt4077 on Monday October 03, 2016 @08:00AM (#12626723)
I never realized how much of a tool git users were before I knew there are 500 page books about it....

This whole thread is evidence of two opposing viewpoints: "git is too hard" and "git is powerful, professional tool and that requires some effort".

I believe those making the latter point misunderstand the first group (to which I belong): I'm not opposed to putting in some time to learn a tool that's central to my craft.

But git seems to often be complicated not because of the complexity of the underlying problems, but because of choices made in its implementation.

Consider: If you have a decent understand of information theory, you'll be able to use any database system within a short time, even if you never had heard of SQL before. Indeed, with a few years of SQL, you'll quickly understand NoSQL systems as well – coming from Postgres, I was productive in Redis within half an hour.

But no amount of experience with VCSs will allow you dive into git without hitting a brick wall.

Re:Gitless: a version control system by slowmovintarget on Monday October 03, 2016 @09:45AM (#12627369)
Git is a powerful, professional tool that requires some effort, primarily because the UI was accumulated, not designed.
Re:Gitless: a version control system by influx on Monday October 03, 2016 @10:52AM (#12627795)
It also was designed for a use case that almost no one actually does which is distributed version control.

Most people use it like a svn with better branching and merging.

Re:Gitless: a version control system by eridius on Monday October 03, 2016 @07:54PM (#12632340)
Everybody who's ever forked a project on GitHub is using it as distributed version control, and that's a lot of people, so I don't know why you say almost no one actually does distributed version control.
Re:Gitless: a version control system by develop7 on Tuesday October 11, 2016 @08:16AM (#12683619)
I'm quite certain most of these are sure they are using github and see no difference between it and Git; and "version control" term gives them headaches in same way as "currying" or "first-class function".
Re:Gitless: a version control system by collinmanderson on Monday October 03, 2016 @09:29AM (#12627275)
Merge Conflicts.

I think a lot of tutorials spend a lot of time teaching you the index/staging (a non-trivial concept that beginners don't need) but don't teach you how to survive merge conflicts and other common tricky situations which beginners are likely to run into if they're collaborating.

Your list is all you need...until you try to `git pull` and it says

> Cannot pull with rebase: You have unstaged changes.

You're only option with your list is commit your changes, but I think it's better to `git stash` then `git pull` then `git stash pop`

Though when you `git pull` you can get a merge conflict and there's two different ways to resolve it depending on if you used the `--rebase` flag or not.

Once you're done resolving those conflicts, you run `git stash pop` and could possibly get yet-another merge conflict that needs to get resolved.

Basically, I'd add `git stash` to your collaborative list. You can't `git pull` without it.

Re:Gitless: a version control system by dahart on Monday October 03, 2016 @12:43PM (#12628999)
> Basically, I'd add `git stash` to your collaborative list. You can't `git pull` without it.

Of course you can! Git stash is not necessary for any workflow, it's pure convenience.

Best practice is not to pull with unstaged changes. If you want to, then:

  $ git commit -am "WIP"
  $ git pull --rebase
Easier than stashing! But this does mean you're going to need to rebase -i later before you push.

Stash is dangerous for beginners, I don't recommend learning it first. From the stash man page:

"If you mistakenly drop or clear stashes, they cannot be recovered through the normal safety mechanisms." https://git-scm.com/docs/git-stash

Re:Gitless: a version control system by collinmanderson on Monday October 03, 2016 @01:00PM (#12629173)
Sure, but my guess is it's just as easy to shoot yourself in the foot with rebase -i. Beginners are still going to have a hard time recovering mistakes with rebase -i, even if it's theoretically possible to recover.

Plus, now you need to use `git diff origin` rather than `git diff` to see your changes.

Re:Gitless: a version control system by dahart on Monday October 03, 2016 @01:14PM (#12629313)
> Sure, but my guess is it's just as easy to shoot yourself in the foot with rebase -i.

No. rebase -i goes in the reflog. stashes don't. The rebase man page does not have the same safety warning that the stash man page does. I have personally witnessed a lot of stash accidents, and not many rebase accidents.

With a rebase, if you have a bad merge conflict, you can abort. With a stash you can't. If you've committed your changes and have problems either forgetting what you're doing, or with merge conflicts, or with being in the wrong branch. All of these cases have more undo options with commits. In the worst case, you still have the safety net of the reflog with commit. With stashes, your only safety net is hunting for dangling blobs using fsck.

Previous threads: https://news.ycombinator.com/item?id=12613062 https://news.ycombinator.com/item?id=12622414

Re:Gitless: a version control system by collinmanderson on Tuesday October 04, 2016 @09:05AM (#12635187)
I mean it's just as easy to make a mistake in the first place with rebase -i. Even though one is theoretically possible to recover with rebase -i, it's going to be very hard to recover for a beginner. (You need to know the reflog command, etc.)
Re:Gitless: a version control system by weberc2 on Sunday October 02, 2016 @12:27PM (#12623045)
I don't think those commands are remotely sufficient to work with git. You're forgetting about merging, traversing history, branch creation, remotes, grokking the staging area, etc. I'm sure I'm missing a lot as well, because those of us who have worked with git for a long time take these things for granted. And it does frustrate me that it's so complex, because Mercurial shows us it doesn't have to be this way. Unfortunately, Mercurial never took off (presumably because it never had a good GitHub analog).
Re:Gitless: a version control system by k__ on Sunday October 02, 2016 @02:26PM (#12623573)
The commands are enough to get through the first month of using git for your own project.

They are certainly not enough to work with Git for your whole career :)

Re:Gitless: a version control system by weberc2 on Sunday October 02, 2016 @02:32PM (#12623599)
The examples I mentioned were taken from notes I made myself when I was learning git (whenever I had an "aha" moment, I would make a note so I wouldn't forget how to work around it later, since I didn't know the git jargon and thus couldn't Google effectively). Maybe my experience is atypical, but at the time I didn't think I was doing anything novel.
Re:Gitless: a version control system by wst_ on Sunday October 02, 2016 @11:11PM (#12625368)
Then they introduce more mess than it's worth. Sooner or later you will have to go back to the original ones and learn anyway.
Re:Gitless: a version control system by StavrosK on Sunday October 02, 2016 @01:04PM (#12623248)
How are they forgetting merging, remotes, etc? The commands are literally on the front page. The only thing it doesn't have is a staging area, which is a conscious decision that I happen to agree with.
Re:Gitless: a version control system by detaro on Sunday October 02, 2016 @01:46PM (#12623424)
I think you missed that weberc2 replied to a comment listing 10 git commands "that are all you need to get started", not to the top level article.
Re:Gitless: a version control system by StavrosK on Sunday October 02, 2016 @03:35PM (#12623852)
Ah, thanks. The mobile app view wasn't clear on that.
Re:Gitless: a version control system by skybrian on Sunday October 02, 2016 @12:20PM (#12623013)
I'm quite comfortable with git now but I also remember what a pain it was to learn. This included making mistakes and diving deep into git's internals to recover. The question is whether we should make things easier for new versus experienced developers?

If switching to gitless became a thing I'd have to learn something new, but if it made things significantly easier for beginners, maybe my personal inconvenience isn't that important.

Re:Gitless: a version control system by lbotos on Sunday October 02, 2016 @12:47PM (#12623163)
Version control is arguably confusing for beginners, but building a shim instead of learning the tool isn't the answer in my head.

I always struggle with "lowering the barrier of entry" and it's not a "I did it they need too do it" it's more of a "Usually high barriers mean it's complex, and learning how to understand complex things is important."

If this was some new novel way to version that wasn't just pretty git, I'd be a lil more excited.

Re:Gitless: a version control system by masklinn on Sunday October 02, 2016 @02:22PM (#12623559)
In my previous job, I taught darcs to a designer/graphics artist. It took about half an hour to go through the CLI, and after that he used it successfully and asked me maybe a pair of questions ever.

Now the guy was pretty technical (part of his job was AS development), but he was not a developer.

Darcs's and Git's fundamentals are not that different[0], but Darcs's CLI actually makes sense in and of itself independent from the implementation details, and when it diverges from the older standard (e.g. SVN) it's so that commands make more sense, not less. Meanwhile Git has taken pretty much the opposite tack.

Git's porcelain is a giant steaming roasted turd sandwich, no other DVCS has such a complex, hostile and nonsensical CLI that people tell you you're supposed to learn it from the storage model up and then it'll make sense.

Don't try to shift the buck to VCS/DVCS concepts, while they are complex Git's CLI goes a great way towards making them nonsensical to beginners and non-beginners alike. I routinely used three different DVCS before I had to take the plunge into Git, and it was still a fucking pain in the ass. And that's a problem at every level of resolutions, just compare the hot mess that is gitrevisions(7) to mercurial's (more powerful, more flexible, more readable and more regular) revsets. It's not like revsets are a genius's flash of inspiration either, "hey I'm trying to manipulate sets of revisions, how about I manipulate them as sets?" We're not talking turing award worthy discovery here.

[0] well they kinda are, but by and large the fundamental differences are irrelevant to basic day-to-day use.

Re:Gitless: a version control system by petre on Monday October 03, 2016 @02:47AM (#12625795)
That's why we picked fossil over git. The interface is really sane and you can also do stuff from the browser. It gets out of your way. You do not need Python, it can be statically linked easily. It also works on Windows. The usability experience is akin to Mercurial, but even easier to use. Unfortunately it doesn't quie work for bigger projoects (think the Linux kernel or the FreeBSD ports tree) and it can also get slower once you have a lot of history. The repo is esentially a SQLite db.
Re:Gitless: a version control system by bsder on Sunday October 02, 2016 @06:14PM (#12624547)
> Version control is arguably confusing for beginners

NO IT IS NOT. <smack to back of head> That kind of thinking is broken.

Most people who have been around computers on Windows long enough eventually adopt it. They start creating zip files of directories and they put date codes on them. You laugh, but it works.

As such, it's really easy for me to explain Mercurial to them. I simply explain it that Mercurial holds those zip files with some extra information and a pretty GUI. It takes me 30 minutes, max, and they get it.

They have one branch. They occasionally share things with other people. And, very occasionally, they have to merge something--which generally gets resolved by taking this file or that file--but rarely actually merging content.

Things only start to go bad when you start adding concepts that require the user to keep state of the repository in their head. If the end user has to think about the DAG, yeah, THAT'S complicated. And that's broken.

I've now been using git and hg for so long that I know both. I now know enough about git that I have been able to unwedge my teams without just copying the repo (cue xkcd link: https://xkcd.com/1597/). I don't need to spend hours of Googling anymore, I just need quick reminders of "Oh, yeah, that stupid flag."

And, you know what, I have never, ever been in a situation where I thought "Gee, I really wish I was in git rather than Mercurial." The converse, however, happens at least once a week.

Perhaps one day my teams or my repos will be complicated enough that the light dawns. The fact that the *BSD guys still operate using CVS and Subversion makes me skeptical.

Re:Gitless: a version control system by skoczymroczny on Monday October 03, 2016 @10:20AM (#12627586)
For me the problems are always merge conflicts. Don't know why, in SVN I wasn't afraid of merge conflicts, I just opened a GUI, clicked on some arrows, picked the parts I want and parts I don't want, save and done. In Git, even with gui tools, I often end up with a mess of .BASE, .LOCAL, .REMOTE files, then I can't merge it all properly, and even if I do it asks me to commit the changes again and it's a mess, so I just clone the repo again and copy the files (xkcd #1597).
Re:Gitless: a version control system by dasil003 on Monday October 03, 2016 @12:14PM (#12628689)
If you think merging in svn is easier than git then you haven't seen the pathological cases of svn merges. The problem is svn has no concept of a repo root or branches, it only has directories, so sooner or later things get very very broken.
Re:Gitless: a version control system by StavrosK on Sunday October 02, 2016 @01:02PM (#12623237)
I don't understand this rationale. Are you saying that Git's UI is perfect, and there's no improving it? It's not, and gitless does, indeed, improve on it.

We should be celebrating better UIs over important tools, not saying "I made great effort to learn it, therefore learning it with less effort is inferior". No. If it does everything Git does, but more easily, it is strictly superior.

Re:Gitless: a version control system by nickpsecurity on Sunday October 02, 2016 @01:25PM (#12623329)
Well-said. We also know that git was originally hacked together in two weeks after Torvalds had to ditch the better-designed product they were using, Bitkeeper. It's almost as if a bunch of Linux developers kept hacking stuff into it with no concern for UX and telling people they were idiots if they didn't like mastering unnecessary complexity.

Meanwhile, unlike Git, I understood most of Gitless's commands before the tutorial started explaining them. Opposite experience I got with Git tutorials where I kept questioning why it would be done a certain, unintuitive way. This is definitely an improvement.

Re:Gitless: a version control system by flusteredbygirl on Sunday October 02, 2016 @01:40PM (#12623401)
Git's UI will never beat Git's command line. Not even close. It may be easy, but the command line is far more powerful, and way faster. Basic git usage is around 10 simple commands or less, and it's not like it's not well documented.
Re:Gitless: a version control system by detaro on Sunday October 02, 2016 @01:43PM (#12623408)
git UI == git command line in this context. I don't think anyone in this subthread is talking about GUIs.
Re:Gitless: a version control system by flusteredbygirl on Sunday October 02, 2016 @01:47PM (#12623432)
My apologies - I saw UI and immediately thought of Git's GUI clients.

I don't think git's command line needs to be changed, though.

Re:Gitless: a version control system by andybak on Sunday October 02, 2016 @05:55PM (#12624468)
Because it's perfect? Because it's familiar? I'd be curious to know why.
Re:Gitless: a version control system by Houshalter on Sunday October 02, 2016 @01:56PM (#12623466)
Command lines have no discoverability though.
Re:Gitless: a version control system by Drdrdrq on Sunday October 02, 2016 @04:31PM (#12624079)
Not true - you have Tab, --help and man pages.
Re:Gitless: a version control system by lbotos on Sunday October 02, 2016 @03:04PM (#12623722)
What I'm saying is, Gitless is cool, BUT beginners are always looking for ways to cheat the effort. My point is, this is a great tool if you understand git, and want to use a shim, but for beginners, going straight to the shim is not good.

>If it does everything Git does, but more easily, it is strictly superior.

In the abstract I agree, but if an junior dev goes "oh, I just use gitless because it's easier" and DOESN'T understand git, it's a problem. That's my point.

Re:Gitless: a version control system by pjc50 on Sunday October 02, 2016 @03:11PM (#12623747)
cheat the effort

I'm always suspicious of arguments like this, because they have a Luddite quality to them. Isn't sending email versus handwritten postal mail "cheating the effort" of communication?

git is a lot of effort to learn because its command line is inconsistent and it is frequently unclear what it has done, why and how to recover from it. It is worth asking if this is really necessary.

If a system has a high percentage of beginners pressing the wrong button and losing time and effort as a result, maybe someone should move the buttons?

Re:Gitless: a version control system by StavrosK on Sunday October 02, 2016 @03:37PM (#12623862)
This is spot on, thank you. The git porcelain is very inconsistent between commands, and that really muddies the view of the underlying model. I would argue that a cleaner porcelain would lead to more easily building a mental model of the data structures.
Re:Gitless: a version control system by crawfordcomeaux on Sunday October 02, 2016 @01:01PM (#12623231)
I think there's a difference between learning something that's necessarily complex and learning something with an overly complex design. According to their analysis, the design changes they've made do away with unnecessary complexity.
Re:Gitless: a version control system by k__ on Sunday October 02, 2016 @01:00PM (#12623222)
It's like with IDEs.

Eclipse has stuff like workspaces with multiple projects and others have simply projects. What to do with these workspaces?

Same goes with Git. Simple VCS have central repositories and a working copy. Git has multiple repositories and every one of them can have a working copy. Other VCS don't have a stage, you simply commit your changes directly into your repository.

It's not only that these tools have different commands and stuff like Mercurial or Subversion has easier commands etc. but they really have different concepts that need to be considered while working with these tools on a daily basis.

But you don't have to internalize them on your first week or month working with them. When you got your project in the System it's mostly save and if you don't have complex workflows you can still reap the benefits of VCS with Git without knowing everything.

Re:Gitless: a version control system by ern on Sunday October 02, 2016 @08:32PM (#12624979)
I may have misunderstood you, but you do realize that Mercurial is also a DVCS like git, right?
Re:Gitless: a version control system by astrobe_ on Sunday October 02, 2016 @02:50PM (#12623655)
The problem is better solved with good tutorials. Cutting corners is a bad idea here so encouraging newbies to do that is more hurting than helping them.
Re:Gitless: a version control system by bsder on Sunday October 02, 2016 @05:53PM (#12624460)
> Git is, like many professional tools, something you simply got to learn.

Or, you can use a tool that is built for purpose aka doesn't suck). I don't use a Stanley #55 Plane to trim an edge even though it can.

Mercurial, the author notes, doesn't have most of the pitfalls. Yes, everybody persists in using git because "Linus used it".

Re:Gitless: a version control system by mitchty on Sunday October 02, 2016 @09:32PM (#12625144)
I persist in using git mostly because it doesn't also mean I need to have python installed everywhere.

I recognize this may be a minority reason, but that is a significant one. The rest amount to being able to rebase/reorder my commits.

At no point does "linus used it" factor in. What genuine technical points about git besides "doesn't suck" are you espousing as reasons I should switch?

Note, my workplace:

a: uses git

b: is about as likely to switch to hg as a pig would be to fly

c: follows linux upstream closely (we do kernel stuff)

I know of the following things that would be reasons to move to hg, however they're more in the "nice to have" rather than "need" category.

a: evolve extension

b: more consistent ui

If I were to list out all the cons for hg from my current perspective, here would be my top 5:

a: have to unlearn fetch/pull as they are not the same between tools, which is right is academic at this point

b: have to unlearn a lot of git use over the past 8 years, not against it but I need a good carrot to bother

c: now I have to install python on some low power systems, honestly this is dumb needing to install a scripting language just to use a VCS, and I use python daily, but its extra bloat that really shouldn't be needed.

d: last I looked (~6 months ago), i'd need to install extensions to recreate most of my workflow, again, this boils down to more effort than sticking with the status quo which by and large works out of the box.

e: would be nice if hg proponents would stop with the "git users are brain damaged by bad ui" posts, it honestly just makes me roll my eyes and move on, not rethink my position, SHOW ME WHY IT IS BETTER, stop berating as that isn't helping and at best is making me think people are treating VCS choice as a religion or political affiliation, which is easily dismissed and not at all worth my time to reply.

Re:Gitless: a version control system by bsder on Monday October 03, 2016 @12:05AM (#12625474)
> I persist in using git mostly because it doesn't also mean I need to have python installed everywhere.

That is a perfectly valid objective reason. It surprises me, given that I do embedded development and have yet to be in a position where Python in my toolchain is an issue, but I'm happy to concede it.

> c: follows linux upstream closely (we do kernel stuff)

Then git is your horse, full stop. Even as a Mercurial person, if I was following kernel stuff I'd use git, that's just common sense.

> e: would be nice if hg proponents would stop with the "git users are brain damaged by bad ui" posts, it honestly just makes me roll my eyes and move on, not rethink my position, SHOW ME WHY IT IS BETTER

You do realize that the UI is more than the majority of the tool, right?

People have done what you ask for. Repeatedly. Including the parent post. Git power users have written extensively of the various UI brain damage and the problems it causes for non-power users.

Git people concede the UI sucks and still persist in starting new projects with git. How should that be classified?

> If I were to list out all the cons

Do be cognizant that with the exception of objecting to python, most of your list of cons is: "I've used git and optimized for it so changing is difficult". If Microsoft/Oracle were attempting via network effects to foist such a broken tool on the open source community instead of Linus/github, people would be screaming.

Personally, I can use either now. Also, personally, I now consider Mercurial to be a not-so-secret productivity advantage (well integrated with Windows, no wedged repositories, no wasted time recovering, can explain how to use it to neophytes so executive level people and non-programmers can use it, etc.). I know that my Mercurial teams won't waste 5% of their time fighting their source code system every single week--they won't even think about their source code system.

My beef is that beginners think "Oh, everybody uses git so git is fine so let's use git". And then, once they've made that mistake, now they feel they have to defend it. And that's not cool.

Re:Gitless: a version control system by mitchty on Monday October 03, 2016 @01:14PM (#12629319)
> It surprises me, given that I do embedded development and have yet to be in a position where Python in my toolchain is an issue, but I'm happy to concede it.

Admittedly its weak but I've used it to run things like git on some really small systems. I'd rather not have to try to get python running on something like an AVR. But to each their own. Not sure what embedded development is meaning here exactly but no matter.

> You do realize that the UI is more than the majority of the tool, right? > People have done what you ask for. Repeatedly. Including the parent post. Git power users have written extensively of the various UI brain damage and the problems it causes for non-power users.

I'm looking more for what advantage hg itself gives me, less about how much git sucks which is at this point beating a dead horse.

> Do be cognizant that with the exception of objecting to python, most of your list of cons is: "I've used git and optimized for it so changing is difficult". If Microsoft/Oracle were attempting via network effects to foist such a broken tool on the open source community instead of Linus/github, people would be screaming.

Indeed, but that just points to after 8-9 years of using git, minor gains in using hg just don't seem as warranted. To date most of what I have seen with hg hasn't shown me what I will gain from switching will be greater than moving. Perhaps thats due to not having to use hg constantly but with things like magit I really don't notice the git ui a lot unless I choose to drop into the command line.

> Also, personally, I now consider Mercurial to be a not-so-secret productivity advantage (well integrated with Windows, no wedged repositories, no wasted time recovering, can explain how to use it to neophytes so executive level people and non-programmers can use it, etc.). I know that my Mercurial teams won't waste 5% of their time fighting their source code system every single week--they won't even think about their source code system.

For my work I've no real need to integrate with windows, not sure what wedged repositories is referring to. Recovering is vague but as a worst case the reflog has always been an emergency fixer. I've not really experienced this to be honest and I'm basically the go to guy for git with my team.

> My beef is that beginners think "Oh, everybody uses git so git is fine so let's use git". And then, once they've made that mistake, now they feel they have to defend it. And that's not cool.

Thats fine, but a bit different than the original statement of Linus uses it therefore we must. It is more git is widely used, ignoring it or not knowing how to at least basically use it isn't a tenable position imo. But to each their own.

Re:Gitless: a version control system by tadfisher on Sunday October 02, 2016 @04:39PM (#12624118)
git wasn't designed to be used by humans. I can't find the quote, but Torvalds said at one point that intention of Git was to provide a content-addressable graph that more human-friendly tools could build upon for different use cases.

Those 10 commands are the beginning of the iceberg when you actually start using git with teams. Where are `rebase`, `merge`, `branch`, etc? These are all commands I use daily, they are complicated, and it's trivial to shoot yourself in the foot.

The problem is that you can learn those 10 commands and things will work, until they don't, and you as a beginner are now spending hours trawling StackOverflow to figure out how to, say, pull a commit from one branch to another (you might not know that such a process is called "cherry-picking").

It's telling that Torvalds said this more recently about git:

> The first Git For Dummies and Git Visual Quickstart books are going to be out in a couple of months, and that is the beginning of the end as far as I’m concerned. Those books mean the end of git expertise and github reputation as reliable indicators of geek status. Once a technology is adopted by the masses the extreme geeks find something more esoteric. Look at what happened to Ruby on Rails. The people stumbling their way through Rails to-do list tutorials have never even heard of DHH.

Re:Gitless: a version control system by nickhuh on Sunday October 02, 2016 @06:47PM (#12624679)
I could be wrong, but I think the article that the Torvalds quote came from was purely satirical [1]. If you look at the tags it says it was posted under satire. Got me at first too!

[1]: http://typicalprogrammer.com/linus-torvalds-goes-off-on-linu...

Re:Gitless: a version control system by eridius on Monday October 03, 2016 @07:58PM (#12632361)
Git wasn't originally designed to be used by humans. There was a separate "porcelain" built on top of git, but I no longer remember what it was called. But enough people wanted to just use git proper without the porcelain that the git core commands evolved into a porcelain themselves, and the separate porcelain layer was deprecated.
Re:Gitless: a version control system by aidenn0 on Monday October 03, 2016 @12:20AM (#12625500)
Here's one quote from Torvalds to that effect:

http://www.gelato.unsw.edu.au/archives/git/0504/0873.html

Re:Gitless: a version control system by eriknstr on Monday October 03, 2016 @08:40AM (#12626973)
After having used git for a few years, I identified what commands I use most frequently and have created two-letter aliases for these;

    alias st='git status'        # STatus
    alias dp='git diff'          # Diff Pending
    alias aa='git add .'         # Add All
    alias di='git diff --cached' # DIff
    alias cm='git commit -m'     # CoMmit
    alias pu='git push'          # PUsh
I've added comments above to show you what I think in my head when I type the two-letter alias in question.

I have a few other two-letter aliases for git as well but the ones above cover about 80% of my use I think.

For the remaining 20% I usually type the command out fully even if I have an alias for it, because those less-frequently used commands are harder to remember the aliases for, whereas the aliases that cover the 80%, I have those in my fingers now without having to think about it.

Re:Gitless: a version control system by marcandre on Monday October 03, 2016 @09:20AM (#12627217)
It's way superior to use git aliases instead of shell aliases. In this way autocompletion and autocorrection will work.
Re:Gitless: a version control system by eriknstr on Monday October 03, 2016 @09:57AM (#12627441)
For the specific aliases I have, the only one that needs an argument is commit and you can't auto-complete a commit message anyway ;) For the aliases that I sometimes specify a file path for, bash is still able to tab-complete that. So for me, shell aliases are actually the best.
Re:Gitless: a version control system by norswap on Sunday October 02, 2016 @12:16PM (#12622989)
I think git's concepts are simple and worth learning (unlike what the gitless people said).

That being said, the command line interface is "meh" at best and full of byzantine options.

Re:Gitless: a version control system by yawaramin on Sunday October 02, 2016 @09:15PM (#12625098)
> I think git's concepts are simple and worth learning

For what purpose? The reason for using a VCS is to get your job done. If gitless does that, why should I need to learn the concepts of a content-addressable graph storage and traversal format?

Re:Gitless: a version control system by norswap on Monday October 03, 2016 @04:41AM (#12626053)
For instance, git has a notion of staging area (the index) where you collect the changes that go into a commit. In gitless, all changes to tracked files are committed. The index goes a long way towards making nice commits that can be understood by other team members, pass tests, etc.

Similarly, the stash that allows you to save your uncommitted changes before switching branches is also quite worthwhile.

Re:Gitless: a version control system by yawaramin on Thursday October 06, 2016 @03:33PM (#12655366)
For all intents and purposes, gitless has an index too. It lets you specify upto hunk-level granularity what you want to include in (and exclude from) each commit.
Re:Gitless: a version control system by pjmlp on Sunday October 02, 2016 @03:13PM (#12623755)
Actually I miss using Mercurial and most customers that I work with, refuse to move beyond Subversion into Git.

Those that do move, just use Git workflows as if it was Subversion.

Re:Gitless: a version control system by fragmede on Sunday October 02, 2016 @11:21PM (#12625386)
Example usage from the article:

    $ gl checkout foo.py
    You have uncommitted changes in foo.py that would be
    overwritten by checkout. Do you wish to continue? (y/N)
    > y
A cheat sheet with those 10 commands are enough to get started, but Git takes a bit to grok properly ( https://xkcd.com/1597/ ). More importantly, it doesn't have to be user hostile. Professional tools in manufacturing are very expensive and last decades. Software lifecycles are shorter and easier and far cheaper to replace.
Re:Gitless: a version control system by chiefalchemist on Monday October 03, 2016 @06:47PM (#12631991)
True. But the argument breaks down (for me) when you consider all the computing power we have, what we're building (i.e., lack of dog fooding), etc. and this must learn tool is the best we got.

NO ONE would use Photoshop or Ableton if they're were as messy as Git. Nuff said.

Re:Gitless: a version control system by oh_sigh on Monday October 03, 2016 @02:18AM (#12625736)
The problem is the world isn't just git. There are thousands of other things to master at any given moment. Putting a veneer over something you aren't interested in mastering and using that seems like a valid strategy.
Re:Gitless: a version control system by vatotemking on Sunday October 02, 2016 @11:21PM (#12625388)
I just use Git GUI. Click click and I'm done. For more complex tasks I open up Git Bash eg. git merge --no-ff <branch> which is the equivalent of "gl merge" command in gitless
Re:Gitless: a version control system by foxylad on Sunday October 02, 2016 @09:36PM (#12625153)
Yep, that's pretty much my git repertoire! I would add branch and merge to this list - conceptually simple, but they add another dimension to version control.
Re:Gitless: a version control system by vbtemp on Sunday October 02, 2016 @11:31AM (#12622792)
> Git is, like many professional tools, something you simply got to learn.

Nailed it.

Re:Gitless: a version control system by rplst8 on Sunday October 02, 2016 @11:52AM (#12622876)
Agreed. I'm seeing terms like "elitist" being thrown around below for "git apologists" when it's simply a matter of learning a tool. Not everyone needs all the power of the git CLI and the complications it brings - but when you do need it, it's there to fix the dumb things we all do sometimes.

I think if you look deep in the guts of Clearcase for example you will see nastiness that makes git look like the ls command.

Re:Gitless: a version control system by nickpsecurity on Sunday October 02, 2016 @01:30PM (#12623358)
" I'm seeing terms like "elitist" being thrown around below for "git apologists" when it's simply a matter of learning a tool."

Some tools people encounter seem unintuitive and have a steep learning curve. Others that do the same thing are super easy to understand and learn. Git vs Gitless is a good example where Gitless instantly clicked with hardly a thought. That means it was a superior interface. That also means anyone telling people they need to suck it up and just accept bad interfaces that smart people were able to learn with enough wasted energy is a bad idea.

Reminds me of those guys when I first started dealing with Linux who told me I was just being slow or lazy for expecting an installer that just required a little bit of input like I had with Windows. Anyone should know everything about handling partitions, configuration of low-level graphics, init systems, whatever. These days, the installers are point-and-click for average case while including options for others. So, why did the Linux people tell me that early on? They were elitist snobs peddling bad UI's and seeing no value in good ones. That simple.

Re:Gitless: a version control system by andybak on Sunday October 02, 2016 @06:00PM (#12624490)
No-one is disputing the power of git. People are merely pointing out that it's textual user interface is clunky and inconsistent. Just because it won the DVCS wars doesn't mean the conversation needs to end and we have to accept this is as good as it gets. It won despite it's CLI not because of it.
Re:Gitless: a version control system by tree_of_item on Sunday October 02, 2016 @01:58PM (#12623473)
> Git is, like many professional tools, something you simply got to learn.

No. Why do people think "professional" has to mean "poorly designed"?

But then, the rest of your post seems to miss the point of this thing entirely. You go on to say that you basically only need 10 commands...which is pretty much the insight that lead to Gitless in the first place.

Re:Gitless: a version control system by chowells on Sunday October 02, 2016 @03:29PM (#12623823)
"Professional" doesn't mean "Poorly designed". It means "designed so that people with lots of domain knowledge and experience with the tool find that it never gets in their way."

In that sense, git is a professional tool. If you know everything about it, it doesn't get in your way. The problem is when you don't know everything about it..

Re:Gitless: a version control system by ubernostrum on Sunday October 02, 2016 @08:44PM (#12625004)
In this sense, trivially, every tool is a "professional" tool, since if you just rote-memorize every aspect of it you know how to do everything it can do.

The problem with git is the lack of coherence in its default UI. Multiple ways to accomplish the same task, git commands which perform incredibly different functions depending on (invisible) context, inability to decide whether commands or flags should act as the highest-level switches...

It is simply the case that, no matter how beautifully and cleanly designed git's internals might be, the interface it presents to them has zero conceptual integrity.

Re:Gitless: a version control system by Nursie on Monday October 03, 2016 @06:26AM (#12626330)
No, trivially, there can be tools that you know inside out which still present roadblocks to perfectly ordinary tasks and be a bad fit for the domain they operate in.

Visual SourceSafe springs to mind here...

Git, by comparison, is very flexible and allows you to do an awful lot, when you've learned it. You can learn SourceSafe inside out and still have it be a total pain in the arse.

Re:Gitless: a version control system by ubernostrum on Monday October 03, 2016 @09:10AM (#12627159)
Again: git as some sort of Platonic ideal of an implementation of a DAG I don't care to argue about. But git's default user interface I will argue about until I'm out of breath, then keep arguing about.

Nothing in that interface is designed to aid in learning. Nothing in it is designed so that mastering one task provides discoverability or intuitability of how to perform another task. It is a complex mess of inconsistencies, discontinuities and obscurities which point more to a lack of design or even of someone with authority to perform design than to anything else. It can only be "mastered" through rote memorization, and bears no necessary or useful relationship to the underlying data models and structures whatsoever.

Re:Gitless: a version control system by Nursie on Monday October 03, 2016 @09:40AM (#12627348)
Eh. Fair enough, my pedant mode just kicked in when you said any tool could be a 'professional' tool in the sense the parent poster said.

I have no particular view on how good or bad git's command line is - I have greatly enjoyed using SourceTree though, and the underlying DVCS seemed not to get in the way.

Re:Gitless: a version control system by slavik81 on Sunday October 02, 2016 @06:44PM (#12624667)
I think this is because the commands are poorly named and badly organised. Professionals will use it frequently enough that they remember everything they need and find it easy from that point forward, but for beginners the unintuitive commands are a double-whammy. It's hard to find the command you want, and the poor naming is a hinderence to building a good mental model of the system.
Re:Gitless: a version control system by snoman on Sunday October 02, 2016 @06:00PM (#12624492)
The burden of having to know everything about it, is precisely what gets in your way. Granted, I use an actual tool (sourcetree) that abstracts away the BS that is the git commandline.

This idea that 'if you don't like the tool, it's because you're not good enough to use it, because you don't know everything about it' is elitist hokum.

Re:Gitless: a version control system by nine_k on Sunday October 02, 2016 @06:38PM (#12624643)
Is an aircraft cockpit a poorly designed ux? It does require a fair bit of learning.
Re:Gitless: a version control system by rficcaglia on Monday October 03, 2016 @12:38AM (#12625535)
yes. and that's why as new planes are being produced, both commercial and small planes, they are replacing the older cockpits with fully electronic modern cockpit controls (with non-electronic secondary controls for power failure use)

many NTSB studies show that even master pilots with thousands of hours of training and flight time make (often fatal) mistakes due to confusion in understanding the cockpit readings

Re:Gitless: a version control system by massysett on Monday October 03, 2016 @11:38AM (#12628273)
Fully electronic "modern" solves nothing without training. Part of the reason Air France 447 crashed was because the crew did not react correctly to the instruments, even though it was an Airbus with all its gee-whiz electronic stuff. Boeing has been more conservative.
Re:Gitless: a version control system by paulmd on Monday October 03, 2016 @12:37PM (#12628948)
There's a standard tech-nerd bias that assumes that technology will always save us, but just throwing electronics at the problem doesn't necessarily solve anything.

For example, the Army found that using glass cockpits doubled or quadrupled the accident rates in UH-60 and OH-58 aircraft respectively, increased it by ~30% in the AH-64, and reduced it by ~40% in the CH-47.

http://oai.dtic.mil/oai/oai?verb=getRecord&metadataPrefix=ht...

http://www.usaarl.army.mil/TechReports/2001-12.PDF

A five-year NTSB study found that although glass cockpits had twice the incidence rate of fatal accidents. The study concluded that glass cockpits do not show a safety benefit. This remains the position of the NTSB.

http://www.ntsb.gov/safety/safety-studies/Documents/SS1001.p...

http://www.ntsb.gov/news/events/Documents/2010_Glass_Cockpit...

http://www.ntsb.gov/safety/safety-recs/recletters/A-10-036-0...

The reality is that simpler is sometimes better. Mechanical instruments each do one thing and they do it well. Vacuum-driven systems are simple and extremely reliable. You cannot fly a 100% glass cockpit, period.

What glass cockpits really do well is information integration. That makes it easier to surface relevant information for the pilot but it also means that pilots have to handle more complex systems that are throwing more information at them, and yet also may not be throwing the right information at them.

This is an inherently one-way street, the reason we have the instruments we do is because they're relevant, you can't go hiding relevant information from the pilot. As such, NASA recgonizes that glass cockpits and cockpit automation impose a higher cognitive load on pilots. It's very simple and straightforward to interact with a traditional cockpit, but with a more advanced cockpit you also need to have a correct mental model of what's happening in the background, otherwise "cognitive mismatch" will result.

Just like any other abstraction - it's nice when they work but all abstractions are "leaky" to some degree or other and you need to know how it works and be able to route around the problem to fix the cases where it fails.

The long and short here is that experience and frequent training are the key factors in aviation safety and glass cockpits actually increase the requirements in this area. They're nice when they work but they certainly are no panacea.

http://human-factors.arc.nasa.gov/flightcognition/research/s...

https://www.thinkmind.org/download.php?articleid=achi_2012_1...

Re:Gitless: a version control system by redwall_hp on Sunday October 02, 2016 @08:40PM (#12624996)
Professional means it doesn't sacrifice functionality in favour of making things easy for newbies. This is a philosophy I approve of for all software. Vim is great because it offers power at the expense of having a little bit of a learning curve. A shell gives you unlimited power compare to a stripped down and locked down GUI.

GUIs and "UX" are generally antithetical to making a computer do what it does best (automate things instead of creating more busywork).

Re:Gitless: a version control system by copperx on Sunday October 02, 2016 @09:17PM (#12625105)
> GUIs and "UX" are generally antithetical to making a computer do what it does best

I agree with you, but although CLIs are explicitly automatable, they are almost never are because most operations are one time deals. If you have evet set up a Linux server I think you'll understand what I mean. The CLI is also a usability nightmare with no discoverability.

Re:Gitless: a version control system by cestith on Tuesday October 04, 2016 @05:03PM (#12639461)
I use configuration management tools to set up multiple nearly identical Linux servers with nearly identical configurations. It's totally repeatable. Look into Ansible, Chef, Puppet, or SaltStack.
Re:Gitless: a version control system by jomamaxx on Monday October 03, 2016 @12:21AM (#12625503)
"GUIs and "UX" are generally antithetical to making a computer do what it does best (automate things instead of creating more busywork)."

Except for helping the 6 or so billion people in their daily lives, but hey, the iPhone would be 'better' if it just had 'bash'?

Read your email lately from bash?

Didn't think so!

Re:Gitless: a version control system by terminalcommand on Monday October 03, 2016 @04:19AM (#12626001)
Bash is what I miss in iOS, I used to jailbreak just for getting a shell.

Now, I use pythonista as a python-shell. Being able to chain a couple of commands and fix a good-enough solution saves a lot of time in many cases such as web scraping on-the-go.

I know this may be an extreme use case, but if iPad is going to be a laptop replacement we need to be able to get a way to speak with it without immidiate access to a laptop.

Re:Gitless: a version control system by croon on Monday October 03, 2016 @07:42AM (#12626628)
False equivalence. We wouldn't have billions of users if there were no other agents than users. You can't create an iphone using an iphone.
Re:Gitless: a version control system by jomamaxx on Monday October 03, 2016 @04:57PM (#12631245)
"False equivalence. We wouldn't have billions of users if there were no other agents than users. You can't create an iphone using an iphone."

It's not a false equivalence at all.

The necessity of lower-level technology in the creation of higher-level technology does not imply that the lower-level technology is somehow 'better' or 'superior'.

You are using a UX right now to read and respond to this.

It's crazy to posit that 'UXs are inferior'. Positively wrong.

In the vast majority of cases, UX's are superior to shells. Maps, news, social media, browsing/buying things, listening to music, making music, photo editing - there are actually very few use-cases wherein the shell is advantageous. Even emacs is a UX of sorts.

Re:Gitless: a version control system by croon on Tuesday October 04, 2016 @06:26AM (#12634480)
Well, first off: I didn't claim that "UXs are inferior", whatever that means. Every interface is a UX. I assume from context you're talking about polished GUI:s.

GUI:s are superior for the specific (limited) use cases they are designed for, inherently since they were designed to excel at those use cases. They are however less optimal when you want to diverge from those use cases and create something new. This is where malleability/modability comes in, and where CLI:s, bash, scripting, programming comes in, and you can't use limited-scope apps for that.

All tools are best at what they were designed for, I agree with you there. I'm however not sure how I in your mind was wrong before. The two are intrinsically bound, but it's undeniable that apps can't exist without tools, but tools sure can exist without apps.

Re:Gitless: a version control system by king_phil on Tuesday October 04, 2016 @06:10PM (#12639969)
Not with bash but with less :-P
Re:Gitless: a version control system by croon on Monday October 03, 2016 @07:38AM (#12626606)
Hell yes. Why does [established practice] have to mean [best practice]?

With all the security concerns and regulation regarding flight, it's easy to imagine how hard it is to move forward and innovate in usability.

I'm not saying upending git for something better would be trivial, but I don't want to constrain my imagination by thinking it's not possible.

If you can coherently explain what you need [git replacement] to do, and explain it simpler than you would explain git itself, then you have an outline of a superior tool.

Re:Gitless: a version control system by perilunar on Monday October 03, 2016 @09:58PM (#12632820)
A rather ironic question, given the history of ergonomics and human factors research in aviation.
Re:Gitless: a version control system by k__ on Sunday October 02, 2016 @03:12PM (#12623753)
Why would someone write a tool for 10 commands?!
Re:Gitless: a version control system by tree_of_item on Sunday October 02, 2016 @05:33PM (#12624368)
No one here did that. What are you talking about?
Re:Gitless: a version control system by gjolund on Sunday October 02, 2016 @07:05PM (#12624740)
Git bisect should be on this list.