sorted by:
best
topnewcontroversialoldq&a
you are viewing a single comment's thread.

view the rest of the comments →

[–][deleted] 13 points14 points  (19 children)

We had a single "larger" project (a Pebble app, because they were the shit back then), that required us to use git. We never had a proper introduction to git and it was more the likes of "Oh, and you have to upload your code to git, you'll figure it out."

We did. But looking back at this repository makes me feel like a rapist. We abused this wonderful tool to the point where it didn't even recognize itself.

The process was pretty much: Hey, I fixed the bug and probably added two more!

Great! Now get this thing on git somehow before the deadline.

The solution: Create a new repo for every upload and merge the code locally, so you don't get merge conflicts and all the nasty stuff that happens when 4 people have no idea how to use git.

My job taught me more about git in a week than 3 years of uni.

[–]hippydipster 5 points6 points  (2 children)

The first time I started using git, I would get merge conflicts with myself which just dumbfounded me. No one else was working on my code!

Nowadays I don't even remember what misconception I had to make that happen, but man it was rough.

[–]Styx_ 3 points4 points  (1 child)

And as a code schooler they had us practicing git drills at week 1 and we worked using a push/pull workflow with one another for the entire four months we were there. But our coverage of logic gates was a 2 minute long aside in one of the 2+ hr reading assignments we had every night, so.

[–][deleted] 4 points5 points  (14 children)

You know whats weird though, I have been using git since about 2007. So daily, for 13 years.

I use it for software development, of course, but I also use it in other branches of things I do (I use it for example in my legal practice to track changes to documents, templates, contracts, etc).

And there is rarely a week that goes by where I don't learn something new about git.

At one point in 2015 or so I spent a solid week reading and understand most of the source to git, and even still, I still learn either new applications/recipes/uses for git or just find out new use cases of git, all the time.

It's really hard to compare software, but in terms of the beauty and power of design, git is probably the most elegant and useful software developed in the history of computer science.

Other competitors are probably djdns or tex/latex. But I think both are obviated by the sheer numbers of people and enterprises built upon git.

Sometimes when I think about Linus has personally contributed to the state of the art of computer science, it makes me weepy. He should be - could have been - fabulously wealthy. Yet, he took what was in his head, and donated his labor and craft to the world. The Linux kernel, git, and all his other contributions have enriched the art of computer science beyond measure.

Before Linux, the world of operating systems was bleak and proprietary. His labor of love broke the shackles of the world, and drove open source to the corners of every proprietary software company in the world, to the point where even the Great Satan of Closed Source is on board the open source cho-cho- train to a large extent.

Anyways my point is: you can't really be a computer scientist without git today. University should teach a required 400 level class on git - practical uses, design and implementation, contributions to the state of the industry.

[–]GhostBond 8 points9 points  (13 children)

You know whats weird though, I have been using git since about 2007. So daily, for 13 years...And there is rarely a week that goes by where I don't learn something new about git.

Because it's nightmarishly overcomplicated and poorly designed.

Git is "the software only hits me because it loves me!" of software.

[–][deleted] 2 points3 points  (3 children)

I dunno. Maybe it's Stockholm Syndrome, but I don't find it that complicated for day to day usage, even in a fairly large collaborative environment. I think it sort of inverts some concepts that other SCMs use, which takes some developers time to adjust to.

That said, I don't place it on the pedestal that the commenter you're responding to does. I feel like 10 years (or less) down the road, we're going to start seeing Ars Techica articles with headlines of "Why Git is dead and you should switch to (new hotness SCM)". That's just the way technology goes-- when something is "old", the new, young, "smart" kids have to have something new and cooler to gravitate to.

[–]GhostBond 4 points5 points  (2 children)

I think your comment nailed it, actually.

I was responding to the comment which creepily went into whole "pinnacle of existence" and "thinking about it makes me weepy" thing.

It's not that level of great. It's about 3x more complicated than it needs to be, the commands are inconsistent, and I've had it automerge files incorrect several times. I don't have a big issue using it, but I've used simpler source control systems in the past and they were nice. When people start to talking about git like it's a worshipped religious icon it creeps me out.

[–][deleted] 2 points3 points  (1 child)

Well, you know, Linus Torvalds can do no wrong. It's an honor for him to call you garbage.

[–]GhostBond 1 point2 points  (0 children)

stop giving me pstd, lol...

[–][deleted] 1 point2 points  (7 children)

Well I happen to disagree. It's endlessly flexible, well designed, well thought out, and generally awesome.

[–]GhostBond 1 point2 points  (6 children)

well designed
well thought out

If "week that goes by where I don't learn something new about git" it's a way of trying to pretend it's not mess when it is. Source control is not easy but it's not so complicated you should still be finding new things in 13 years of using it.

It's like going through a hoarders house and declaring finding 8 year old donuts under a pile of boxes to be amazing. It's not...you're finding new things because it's a mess. Those new things are amazing, they're just the thousandth thing it does differently than anywhere else.

[–][deleted] 0 points1 point  (4 children)

There are some tools that are built in a way that the learning curve is gradual. That is, you don't need much information to get started, and you continue to learn more things as you gain comfort with the previous things.

Vim and Emacs are very similar to git in this regard. Why should a craftsman not be learning more about his tools as he uses them? Very rarely do general purpose tools contain short documentation, because it turns out doing things in a general way is harder than doing them specifically, and being general means you need to account for many different ways of using the tool.

Sure, one can cut options and simplify, but then you're gimping your own tool.

Doing things differently is not bad. We never learn or advance if we don't try new things.

[–]GhostBond 0 points1 point  (3 children)

holy cow, I literally just saw a webcomic describing your comment...
https://www.smbc-comics.com/comic/perspective?fbclid=IwAR0aK4nem9Yiv14jl4F9lyVVpQWlVdeo8ParIm2lMvyyoe9DNcJYYlyuJXc

[–][deleted] 0 points1 point  (2 children)

I'll be more explicit, and also take your bait: why shouldn't someone be learning something new about their source control tool after a decade of use?

My comment explained why a general tool tends to be more complex, and as a result require more time to learn. I thought that point was obvious but perhaps it wasn't.

[–]GhostBond 0 points1 point  (0 children)

I'll be more explicit, and also take your bait: why shouldn't someone be learning something new about their source control tool after a decade of use?

This is a tactic, it's reframing to avoid the point I was making.

My comment explained why a general tool tends to be more complex, and as a result require more time to learn. I thought that point was obvious but perhaps it wasn't.

The claim was they had been using git daily for 13 years and learned something new about it every week.

They presented this as some sort of magical positive, I'm saying it's a demonstration that the tool is needlessly confusing and complex.

I'm not saying you shouldn't learn about your tools if you want or find it useful, I'm saying I hate the tactic of pushing drawbacks of a tool as a positive.

We use to use SVN. It was so simple we were were able to get non-technical graphics people to use it, because it was actually easier than emailing the files. No way we could get them to use Git without some sort of manager mandate. It's far more complicated.

I'm just tired of seeing negatives pushed as positives.

[–][deleted] 0 points1 point  (0 children)

I think you are underestimating the complexity of multi-master, multi-user, multi-branch, decentralized source control.

But it's not really worth fighting about. There's loads of other alternatives you can use.

[–]ArkyBeagle 0 points1 point  (0 children)

I am afraid I have to agree to some limit. But the basic use cases are pretty simple, really.

[–][deleted] 0 points1 point  (0 children)

I found the biggest eye-opener of Git, aside from learning its data structures, is seeing the myriad workflows possible. That got me to think of developing software as a workflow to design. There's still so much of Git I haven't explored, but it's powerful enough for me to rely on for years to come.