Live data from Hacker News

Gitless: a version control system

gitless.com

71–80 of 390 posts

Re: Gitless: a version control system

#71
post #68
post #57

Earlier quoted context omitted.

I tend to agree with you that most people don't need that power but I think the problem is just that it IS a CLI interface, not that it's a particularly bad one. A GUI is the perfect tool to deal with discoverability and providing an easier interface for non-technical users. A CLI wrapper is just making things more confusing. I don't really understand what problem gitless seems to be solving...

I disagree; `hg` is a CLI as well, but it's far simpler and safer than `git`. That said, I have far more experience with git than hg. Further, gitless itself is a cli, and it's also simpler than git.

If simplicity was the goal of command line interfaces they wouldn't exist. This is not ls or cat, nor is it trying to be. hg might have a better CLI than git, but it still doesn't justify something like gitless.

You need a really compelling reason to layer another level of abstraction on top of git and from what I can tell, having branches be full sets of working files isn't really a good enough reason to make that switch.

Where are the improvements in Gitless exactly? Pretty telling they don't even list them in anywhere.

Re: Gitless: a version control system

#72
How is this any different from hub (https://github.com/github/hub). It provide useful command like aliases. Along with ghi(https://github.com/stephencelis/ghi), I can do everything like creating new repo, sending PR, looking/creating/updating/commenting on issues with my command line.

Re: Gitless: a version control system

#73
I think there will be a very small subset of developers who are confused by the Command Line Interface of Git, but not confused by the Command Line Interface of this thing.

Sure, there are tons of developers who find Git confusing. But the solution they're looking for is something like Git Extensions that removes the silliness of memorizing and typing a bunch of commands in to a terminal. In terms of Global Confusion Index, this only drops us from 98 to 97.

A simple GUI version of this same concept would seem a much better plan.

Re: Gitless: a version control system

#74
post #28

When people say they don't like git, I lose a little faith in them as a programmer and/or engineer. This is probably due to my own biases of having worked with folks that just don't want to invest the time in learning it. That or they are afraid of branching/merging. To me this indicates intellectual laziness which isn't the kind of laziness that makes a good programmer (as is with the quote from Larry Wall and the k…

When people suggest that git is great I lose a little faith in them as a programmer cause it indicates to me they don't have much breadth if experience with source control systems & they are too intellectually lazy to investigate alternatives. Could just be my biases I guess.

I still think that git is great, only git - the cli is bad.

Re: Gitless: a version control system

#75

Earlier quoted context omitted.

I disagree. It's one of the best command line tools I've seen. It detects errors, gives you suggestions and you can get along with a few basic commands. Yes, there are multiple steps, but that's okay because it can't figure out your intentions. Look: http://imgur.com/xY8dKWD no verbosity here and this is 99% of my git workflow. Working in a team is more tricky, but you should use and IDE with built in git support. If…

This is not objective. Git CMD has terrible flaws that are easily spotted as soon as you start teaching git, because you can see people struggling on difficulties purely created by a bad design. As a professional trainer, here are the most commong problems: - git checkout does so many different things. Git check file, git checkout branch, git checkout commit all do different stuff, and don't get me started on the opt…

Let me just start by saying that while gitless seems fine, it tries to hide the index and thus encourages bad habits in git users.

The index is by far one of the best features git has in comparison to other VCS, and trying to hide it because it can be confusing to users is doing them a disservice.

EDIT: editing this to expand on why I think the index is essential:

Being able to use the VCS tool to fashion a commit separately from what is in the worktree allows you to create changesets that make sense, instead of them being "this is what happened". Exact history is not interesting, it is the logical progression of the codebase (via changes applied to it) which really matters.

Furthermore, when resolving conflicts, the index is extremely useful because you can work through a conflict (which often can span multiple files) piece-by-piece and easily tell whether you've already fixed everything, run diffs on what's resolved and what isn't, etc. I find myself missing the index whenever I need to do anything nontrivial with other VCS (which is most often Subversion)

I've seen some people argue that they don't want to commit something that has not been tested, but I don't understand this argument. Why would you test something that isn't committed? Committing (or even pushing) something does not mean the code is instantly in production, but it means you have an unambiguous way to refer to what is being tested, instead of whatever state your worktree and system happened to be in. How could you be sure you're really testing what you will be committing?

Certainly, creating separate commits after-the-fact can cause commits where the tests don't pass, but it's up to you to decide whether the merge points are what should be tested, or each individual changeset.

Let's go through that list

- git checkout does one thing: it updates your worktree to match whatever you want to check out, be that a commit, a branch (which actually is just a named commit) or a file in a branch. Why is this difficult for beginners, and how would you refactor/name the operations so that they make sense?

- I'm not sure what you mean with context-dependency. Obviously it's context-dependent in that your worktree and repository may be in a state where certain commands do different things eg. because they have the current checked out branch as an implicit parameter. I don't think it's at all different from most other VCS

- I'm not sure I'm convinced by the article's argument that branch switching is hard, but I guess I'll grant that.

- Huh. I don't use stash that often, so this is a maybe. Teach people to use stash apply instead?

- git rm --cached is weird, but mostly because git can't choose just one thing to call the index.

- You can never accidentally destroy history with a rebase. Nothing short of manually wiping files destroys history in git once something has been committed. I don't really see why detached heads would be a problem (just create a branch?) and if you force push, you're basically telling git "I know what I'm doing, shut up" in which case the tool doesn't assume you're an idiot and will do what you want. You can't call it bad UI when you explicitly have to use a --force flag to do potentially destructive things. Not being able to do it at all is worse.

Really though, other than minor gripes with terminology and maybe sometimes confusing command line switches, what is a good (hypothetical) UI for git that doesn't just ignore all the good things?

Re: Gitless: a version control system

#76
post #7

To me the really bad thing about git is its command-line interface. It has extremely verbose messages (writes out a lot of stuff that you don't need to know) and common use cases often requires multiple steps (ie. add, commit, push if you just want to send a change from your work machine a github repository). Compare this to subversion which is much less verbose, and in general just have one operation pr. use case.

Not sure why this appears to be been down voted. Git's command-line interface IS terrible. Certainly not unusable as most of interact with it every day. A somewhat satirical example of this is Steve Losh's Git Koans. http://stevelosh.com/blog/2013/04/git-koans That's not to say I don't think the underlying ideas of how Git works makes sense. I certainly think it's a lot better than RCS, CVS and SVN (never tired Mercu…

Love it! The hobgoblin one should mention "deleting a remote branch" in contrast to deleting a remote and deleting a local branch.

Re: Gitless: a version control system

#77
post #49

Earlier quoted context omitted.

I use git all the time and prefer it for all types of workflow as a VCS, but this idea that git is perfect and it's your own fault for not learning it properly is ridiculous. UX/UI in programs is important. I believe that git has one of the worst, most inconsistent UX's of all time. You can see this by the fractured commands. Quick examples: 'git reset' vs. 'git revert' and sometime 'git checkout' 'git checkout' vs.…

> What does it say when resolving these problems the easiest thing is to just reclone the remote repo? It says the git works really well because the CLI offers a simple way to "undo" any mistakes you've made. The real reason people struggle with git, and I've seen this in many other programs/places is that they rely on discoverability and just randomly try commands until they work. Git's simplicity is it's downfall.…

> It says the git works really well because the CLI offers a simple way to "undo" any mistakes you've made.

This let's the design off the hook to easily. Yes, on the one hand this is a great feature, but on the other, you are deleting and restarting your workspace. It's not a great UX, it's just a simple workaround for a bad one.

> - every engineer when first experiencing version control

no, wrong. git is unique in the amount of information that you need to know just to get started with it.

Re: Gitless: a version control system

#78
post #50

I don't see any improvement over git. Just another set of commands you'll need to learn from scratch. Some ideas seem not very good, like committing all changed files by default. If you find git commands too verbose - try 'tig' - the ncurses git client, it saves a lot of time and efforts being simple and straightforward at the same time.

wildly guessing from the clone to checkout name change, it probably started as a git for subversion users?

Re: Gitless: a version control system

#79
post #43
post #30

Very cool. The idea which I liked most, is the ability to switch between branches, even though you still have uncommitted changes. With git, I'm forced to either make an extraneous commit, just to enable branch switching, or stash all my changes into a stack which I may later forget all about. Both of the solutions above are really cumbersome and prevent easy context switching. The only feature I noticed missing, is…

Just use the normal git fallback command

me nor my web search engine never heard of it

Re: Gitless: a version control system

#80

Earlier quoted context omitted.

I disagree. It's one of the best command line tools I've seen. It detects errors, gives you suggestions and you can get along with a few basic commands. Yes, there are multiple steps, but that's okay because it can't figure out your intentions. Look: http://imgur.com/xY8dKWD no verbosity here and this is 99% of my git workflow. Working in a team is more tricky, but you should use and IDE with built in git support. If…

This is not objective. Git CMD has terrible flaws that are easily spotted as soon as you start teaching git, because you can see people struggling on difficulties purely created by a bad design. As a professional trainer, here are the most commong problems: - git checkout does so many different things. Git check file, git checkout branch, git checkout commit all do different stuff, and don't get me started on the opt…

  > git is context dependant
In particular, git violates the universal *nix convention that you can operate on a file using a full or relative path regardless of your current directory.
Post reply on HN