There have been multiple accounts created with the sole purpose of posting advertisement posts or replies containing unsolicited advertising.

Accounts which solely post advertisements, or persistently post them may be terminated.

Sorse ,
@Sorse@discuss.tchncs.de avatar

My git knowledge:

git clone <url>

Wilzax ,

So do you guys pronounce it git or jit

d00phy ,

The holy war we deserve.

SpaceCowboy ,
@SpaceCowboy@lemmy.ca avatar

I pronounce it the correct way you silly git!

Wiz ,

Git off my lawn. Git!

m12421k ,

fortunately this one isn’t an acronym. so the pronunciation is obvious. 😊

Wilzax ,

Acronyms are still pronounced like the words they most closely resemble though

shasta ,

But git is not an acronym

madcaesar ,

This guy jits it

ikidd ,
@ikidd@lemmy.world avatar

Is that what we’re going to do tonight, we’re gonna fight?

jenny_ball ,
@jenny_ball@lemmy.world avatar

lol it’s on now!

DaleGribble88 ,
@DaleGribble88@programming.dev avatar

media1.tenor.com/m/…/that70s-show-kitty.gif

257m ,

Don’t start this. Its not like gif. Git is clearly pronounced like git. There is no possible argument you can make otherwise.

Wilzax ,

Same could be said about gif yet here are

WeLoveCastingSpellz ,

no

RandysGut ,
@RandysGut@lemmy.world avatar

The same as in giraffes giving ginormous gifts

Wiz ,

So, it’s pronounced “jight”?

ohlaph ,

jean, we pronounce it jean.

Sorse ,
@Sorse@discuss.tchncs.de avatar

Yit

Anticorp ,

If you’re pushing to master, then you’re doing it wrong.

zalgotext ,

Yeah main has been the defacto default branch name for like half a decade now

TunaCowboy ,

git whoosh --hard

learningduck ,

Wait. It’s that long?

Felt like we joke about the announcement 2 years ago. Time fly lol

zalgotext ,

Imma be honest I pulled that estimate out of my ass lol, but I feel like it was pre-pandemic? which would put it at at least 4 years ago and so holy shit I’m gonna go cry in a corner because it’s been 4 years since the start of the pandemic

throwwyacc ,

Isn’t this only the case in github? All my repos are based from master, and I would assume that’s because I init on the command line and push up to the remote?

AA5B ,

GitLab also changed a few years back. We host our own, so got the update later than people using the service … it was a bit of an argument at first since everyone wanted to stick with the familiar, but laziness won out. Unfortunately, it’s not really justifiable to go back and change legacy projects, so now it’s inconsistent

throwwyacc ,

If you don’t have any scripts that rely on branch name it should be pretty trivial actually. But I wouldn’t be shocked if you had a few dozen scripts that nobody has looked at in the last century lol

AA5B ,

The question actually came up for a new tool to help automate dependency updates. Do we need to change the config to account for the inconsistency?

It turns out we don’t: it correctly uses the default branch, no matter what it’s called. However we had to consider the question. and investigate. It spent someone’s time

uis ,

git send-email

Hawk ,

Why? I almost always have master/dev/stable.

TunaCowboy ,

You should not be pushing into your main/master/whatever branch.

All the main/master replies completely miss the point, further emphasizing sirsirsalot’s statement.

Hawk ,

I think I’ll keep doing it. It’s worked fine for the past decade 🤷

Solemn ,

It works fine for small projects. I think that with more than 2-3 devs a PR based strategy works better for enforcing review and just makes life easier in general, since you end up with less stuff like force pushes to fix minor things like whitespace errors that break everyone’s local.

Tanoh ,

Different workflows.

chicken ,

If you happen to forget the -m though, you may also need to have mastered exiting vim

jxk ,

Me as an Emacs user, who omits -m on purpose to practice quitting vi in case I really need it

PotatoesFall ,

you’re an emacs user who has vi set up as the default editor on your system?

(You can change it altering the $EDITOR env var)

jxk ,

I only use $EDITOR to launch vi from git. Emacs runs as a single process and is always open.

Wiz ,

Shift-Z Shift-Z to quit vi. Let’s keep it simple, people!

JATtho ,

The day I configured git to use Geany for commit messages with a separate config specifically tuned for this, it improved my life by 300%


<span style="color:#323232;">~$ cat ~/bin/gitedit
</span><span style="color:#323232;">#!/bin/sh
</span><span style="color:#323232;">exec /usr/bin/geany -i -s -t -c ~/.config/gitgeany $@
</span>

Then in git config: git config --global core.editor “gitedit”

Trollception ,

What developer uses Linux in professional work? Maybe for on the side stuff but I haven’t seen any corporate Linux machines.

aodhsishaj ,

Hello, I use a linux machine for dev work and all the servers and containers I touch are linux, all managed through gitlab CI/CD.

git scm is my daily driver and I use it for not taking and documentation as well as active python development.

atx_aquarian ,
@atx_aquarian@lemmy.world avatar

Macs are basically BSD, and Windows has WSL.

Trollception ,

But Mac or WSL are not Linux.

Solemn ,

Everywhere I’ve worked, you have a Windows/Mac for emails, and then either use WSL, develop on console in Mac since it’s Linux, or most commonly have a dedicated Linux box or workstation.

I’m starting to see people using VSCode more these days though.

Trollception ,

I thought Mac was unix which is similar but different from Linux?

Solemn ,

I think someone else said what it actually is in another comment. It’s functionally identical 90℅ of the time for me anyway,and I use CLI and vim on it.

Ephera ,

They’re both UNIX-like, i.e. they both implement the POSIX specification and are therefore in many ways compatible.

But yeah, modern macOS is more directly derived from the original UNIX operating system.
Linux was instead implemented from scratch to be compatible with UNIX.

Ephera ,

The entire IT ecosystem is built around Linux, because it’s so prevalent in servers, containers, budget hardware and the open-source community.

Yes, many companies don’t understand that and expect their devs to be productive on Windows. But in my experience, that’s an uphill battle.

In my company, we get very little IT support, if we decide to order a Linux laptop and we still have significantly less trouble with getting things set up to start coding.
Not to mention the productivity boost from having all the relevant technologies natively available + being able to script whatever you want.

RobertoOberto ,

Everyone at Mentor Graphics did before it got gobbled up by Siemens in 2017. I don’t know if they still do.

Ephera ,

Well, if anyone wants to learn more about Git, I can recommend this: ohmygit.org

JustAnotherRando ,

Another good one, entirely browser based, is learngitbranching.js.org

gazter ,

As someone who knows that they know very little about git, this thread makes me think I’m not alone.

laurelraven ,

I think advanced git knowledge, like RegEx, is the exception, while the norm is to know the tiny handful of day to day useful bits

lhamil64 ,

How is regex git knowledge? I guess you can use regular expressions with git grep but it’s certainly not a git-oriented concept…

MrRazamataz ,
@MrRazamataz@lemmy.razbot.xyz avatar

what. that’s not what they said. they are comparing git knowledge to regex knowledge.

Astongt615 ,

Ah, thanks for the explanation. I too misunderstood the inflection.

MrRazamataz ,
@MrRazamataz@lemmy.razbot.xyz avatar

no worries

laurelraven ,

I don’t even know how to respond to this considering it has nothing to do with what I said…

survivalmachine ,

There are at least two ways to parse your statement, and they interpreted it differently from your intention.

laurelraven ,

I guess, if you ignore the comma…

magic_lobster_party ,

Could’ve written like this to avoid the ambiguity: “I think advanced git knowledge, just like RegEx, …”

lhamil64 ,

Rereading it, I now understand what you meant. I interpreted the “like regex” as an example of advanced git knowledge. I’m not sure the comma helps make it unambiguous though.

laurelraven ,

Yeah, reading it again and I can see that interpretation…

This is why you shouldn’t rely on yourself alone for proofreading your writing, I probably could have read that a hundred times and not seen another way to read it without someone else pointing it out

redcalcium ,

Interviewer: It’s git push origin main now. Get out of here!

cyborganism ,

Just set your default behavior.

OpenStars ,
@OpenStars@startrek.website avatar

I have only ever used simply “git push”. I feel like this is a “how to say that you barely know how to use git without saying that you barely know how to use git” moment:-D.

sag OP ,

Hold Up

Cqrd ,

You can default git to using your current branch and a specific upstream so you don’t have to put anything after git push

sag OP ,

Thanks didn’t know that

bleistift2 ,

Has git never told you that you should use git push -u origin <branch> when you push a new branch for the first time?

PoolloverNathan ,

The first time you manually push like that, you can add the -u flag (git push -u origin master) to push and set the branch’s default upstream. Afterwards, a plain git push while that branch is checked out will push the branch to that default upstream. This is per-branch, so you can have a main branch that pulls from one repository and a patch branch that pulls and pushes to a different repository.

blind3rdeye ,

My strategy is to just type git push and get some kind of error message about upstream not being set or something. That’s a signal for me to take a second to think about what I’m actually doing and type the correct command.

embed_me ,
@embed_me@programming.dev avatar

That’s a signal for me to

… google the error and randomly try stack overflow answers without really understanding them.

( I have changed)

synae ,
@synae@lemmy.sdf.org avatar

Normal distribution curve meme makes sense here - experts and noobs can both git push safely (but for different reasons)

OpenStars ,
@OpenStars@startrek.website avatar

I can follow along re-typing the same commands told to me by a more senior dev just like any average monkey!

This reminds me of something I made a long time ago: img

Since I am calling myself dumb, I estimate my progress to be somewhere perhaps at the 20th percentile marker? :-D One of these days I’ll RTFM and rocket all the way up to be dumb enough to properly qualify for “below average”! :-P

seth ,

It’s git push origin branch and then merge after submitting a pull request from branch to main after a successful lint check, build, deployment, and testing in a non-production environment, and PR approval. What kind of wild west operation allows pushing directly to main?

Michal ,

👆 This guy gits it

redcalcium ,

Employees who push first win and get to leave early. The rest would be the suckers who would merge whatever mess left behind by the early employees.

fckreddit ,

Single person operation pushes directly to main.

Pacmanlives ,

Hey there were like 3 of us lol! No joke that’s what I have done at a few of the smaller shops as an SRE/System Engineer

MR_GABARISE ,

What kind of wild west operation allows pushing directly to main?

That’s kinda the whole point of trunk-based development.

aport ,

Lol no it is not

dan ,
@dan@upvote.au avatar

Our changes land in main at my workplace, once they’ve received a code review and all CI checks pass (which includes tests, E2E tests, etc). We use feature flags rather than feature branches, so all diffs / pull requests are against main. We use continuous deployment which means changes are automatically deployed once landed. Changes roll out just to employees, then to servers used by a small percentage of users (2% I think), then everywhere. All risky changes are gated by feature flags so they can be enabled or disabled without a code push.

nilloc ,

We did a similar way with tag based releases, first a test tag, the production tag when signed off.

SpaceCowboy ,
@SpaceCowboy@lemmy.ca avatar

They laid off everyone else so there’s no one to the code reviews now. So fuck it, we’ll do it live!

AA5B ,

We just had a customer escalation caused by exactly this. One group relied too heavily on tribal knowledge for code reviews and didn’t want any other process. Once the tribal elders were gone, no one knew all the things to look for, and there was no other way to catch issues

As a Continuous Integration and Test guy, I was standing in the corner yelling “I thought you were DevOps. Where’s the automation?” Fine, Puppet/YAML doesn’t work with a traditional build and test, but you could have done syntax validation and schema validation that would have caught before the code review could have happened (and I showed them how a year ago, even offered to do it for them) and set up some monitoring to discover when you break stuff, before customers discover it.

Pacmanlives , (edited )

You kids with your fancy branch support back in my day we had CVS and RCS liked it

en.m.wikipedia.org/wiki/Revision_Control_System

Nalivai ,

You mean “I just sent you zip file with my new changes via email, get fucked looser”?

korok ,
@korok@possumpat.io avatar

Do you not use a fork as your origin, separate from the production upstream repo? I’ll push to my fork’s main branch for small or urgent changes that will definitely be merged before anything else I’m working on.

Solemn ,

If it’s a private repo I don’t worry too much about forking. Ideally branches should be getting cleaned up as they get merged anyway. I don’t see a great advantage in every developer having a fork rather than just having feature/bug branches that PR for merging to main, and honestly it makes it a bit painful to cherry-pick patches from other dev branches.

1984 ,
@1984@lemmy.today avatar

I never worked anywhere where they had this set up. I would push to branches and make pull requests, but always work in the production environment.

I was mainly working as a data engineer though so that’s probably why. It’s hard to have test environments since you can’t replicate all the enormous amounts of data between environments without huge costs.

expr ,

There are many strategies for maintaining test environments for that kind of thing. Read-only replicas, sampling datasets for smaller replicas, etc. Plenty of organizations do it, so it’s not really an excuse, imo.

1984 ,
@1984@lemmy.today avatar

No I know. But it was “good enough” for the company and we never had any serious issues working that way either. If someone pushed a faulty commit, we just reverted it and reloaded the data from the source system.

A lot of companies have kind of bad solutions for this sort of stuff, but it’s not talked about and nobody is proud of it. But it keeps the environments simple to work with.

AA5B ,

No kidding. Never push to main, and you most likely can’t. While I get the joke of the meme, I’d send the person packing if they don’t understand branching, and branch flow, rebasing or reverting. Even if you look up the command or do it all through your IDE, understanding the workflow of using git is important

RustyNova ,

Fuck those that use main. If you’re working on a library fork that has main and a project that has master you’re bound to invert the two.

“What do you mean I can’t checkout main? Oh right, here it’s master…”

For once that we had a standard, it had to be ruined.

huginn ,

Fuck those that use master. If you’re working on a library fork that has main and a project that has master you’re bound to invert the two.

“What do you mean I can’t checkout main? Oh right, here it’s master…”

For once that we had a standard, it had to be ruined.

The standard is now main.

maynarkh ,

The standard is now main.

Git itself does not use that standard yet, so at least now there are two competing standards.

I get that there are cultural reasons why the word master was loaded language, but still, it’s not like institutional racism will go away. Meanwhile, the rest of the world which doesn’t struggle with the remnants of slavery has to put up with US weirdness.

zalgotext ,

Git itself does not use that standard yet, so at least now there are two competing standards.

Just ran git init in a brand new empty directory, and while it did create a master branch by default, it also printed out a very descriptive message explaining how you can change that branch name, how you can configure git to use something else by default, and other standards that are commonly used.

Also, there’s nothing saying your local branch name has to match the upstream. That’s the beauty of git - you have the freedom to set it up pretty much however you want locally.

maynarkh ,

Yeah, that’s what I’m saying, there is no one standard now. The stupid thing is all the problems that causes is mostly because there used to be one, and stuff written assuming master branches are eternal.

I’ve had a company that had some automation built on git but below GitLab that would not let you delete master branches. When main became a thing, they just started hard protecting those as well by name. It’s because of regulatory, and they are very stingy about it.

So when I created a few dozen empty deployment repos with main as the default, and then had to change it over to master so that it lined up nicer with the rest of the stuff, I’ve had a few dozen orphaned undeletable empty main branches laying around. A bit frustrating.

That said, the whole thing is just that. A bit frustrating. If it makes some people feel better about themselves, so be it. I am blessed in life enough to take “a bit frustrating”.

zalgotext ,

Yeah that’s fair, I can see how that would be annoying for sure. I think that frustration stems more from company policy though, not necessarily the standard changing. And you know what they say, there’s nothing certain in this world except for death, taxes, and standards changing

maynarkh ,

It is trash code for sure, but most of the world’s code is trash, so we do have to accommodate trash code when we design stuff. That said, they do need to do this to comply with laws and make sure code doesn’t get lost (it’s finance), and this was the easy way to do it. Doing it better would have taken time and attention away from other stuff.

And standards do change, but they usually change to accommodate new features, or a new software product displaces an old one. I don’t really know any tech standard that changed because of cultural reasons. Point is, change is a cost. It may be worth to pay the cost, but here the benefits were US cultural sentiments that most of the world doesn’t care about.

And the stupid thing is that even when standards change, you are not usually labelled as culturally out of touch if you don’t follow it. Most big orgs don’t follow changes that they don’t need to. Nobody calls you a bigot for running COBOL mainframes in 2023, but they might if you predominantly have master branches.

I guess my perspective is that some people I know were mildly annoyed before lunch about it one day two years ago, since nobody cares about US identity politics, with my personal opinion being if the US didn’t fill up its for-profit prisons with black people who it then those prisons profit off of (just as an example), the word master would not bite as hard, and the whole thing would be moot.

Vikthor ,

Obligatory

BatmanAoD ,

git checkout ma<tab>

If you don’t have autocomplete set up for your shell, get it working. If someone has a different branch named ma…, ask if you can delete it, and get your team to adopt a decent branch naming convention.

Nalivai , 

<span style="color:#323232;">git checkout ma<tab>
</span><span style="color:#323232;">
</span>


<span style="color:#323232;">mai_new_chenges 
</span><span style="color:#323232;">march_deploy_second_final_final_fixed      
</span><span style="color:#323232;">main_fixes       
</span><span style="color:#323232;">mast_not_farget_to_delete_it
</span>
BatmanAoD ,

…yeah, I already said that if there is another branch starting with those letters it should be deleted. You need a naming convention.

Nalivai ,

I really wish to work in a team where people have naming conventions for branches that are concerned about stuff like that. Must’ve been a nice place to work at.

BatmanAoD ,

Whoever named the “final final fixed” one seems to have missed the point of version control. 😑

1984 ,
@1984@lemmy.today avatar

I think the reasons was ridiculous. The fact that people didn’t like the word master anymore. But I’m used to it now, so fine, let’s use main. It makes sensitive people feel better.

go_go_gadget ,

Woah look at mr. fancy pants with his git push arguments.

thirteene ,

I use this in my bash profile in case anyone else finds it helpful. Usage is:

gao fixing a typo


<span style="color:#323232;">function gao() {
</span><span style="color:#323232;">    git add .
</span><span style="color:#323232;">    git commit -a -m "$*"
</span><span style="color:#323232;">    git push origin `git rev-parse --abbrev-ref HEAD`
</span><span style="color:#323232;">}
</span>
Marcbmann ,

I think HR is just ill equipped for technical interviews, but they try to conduct them regardless.

Was denied a position because HR felt my experience “lacked depth” which I still can’t understand 3 years later.

Did the same role at a larger company. Had more responsibility than they were giving me. Developed my own tools for job automation. Grew their business from nothing to half a mil a month. Experienced all stages of growth and realized massive success.

After that interview I kept getting technical interviews and getting passed on because I was too senior for the position

punkwalrus ,
@punkwalrus@lemmy.world avatar

The thing is that for a majority of cases, this is all one needs to know about git for their job. Knowing git add, git -m commit “Change text”, git push, git branch, git checkout , is most of what a lone programmer does on their code.

Where it gets complicated real fast is collaboration on the same branch. Merge conflicts, outdated pulls, “clever shortcuts,” hacks done by programmers who “kindof” know git at an advanced level, those who don’t understand “least surprise,” and those who cut and paste fixes from Stackexchange or ChatGPT. Plus who has admin access to “undo your changes” so all that work you did and pushed is erased and there’s no record of it anymore. And egos of programmers who refuse any changes you make for weird esoteric reasons. I had a programmer lead who rejected any and all code with comments “because I like clean code. If it’s not in the git log, it’s not a comment.” And his git comments were frustratingly vague and brief. “Fixed issue with ssl python libs,” or “Minor bugfixes.”

Ottomateeverything ,

I had a programmer lead who rejected any and all code with comments “because I like clean code. If it’s not in the git log, it’s not a comment.”

Pretty sure I would quit on the spot. Clearly doesn’t understand “clean” code, nor how people are going to interface with code, or git for that matter. Even if you write a book for each commit, that would be so hard to track down relevant info.

mkwt ,

Yeah, I think that guy only got a superficial understanding of what Uncle Bob was saying.

My policy as a tech lead is this: In an ideal world, you don’t need the comment because the names and the flow are good. But when you do need the comments, you usually really need those comments. Anything that’s surprising, unusual, or possibly difficult to understand gets comments. Because sometimes the world is not ideal, and we don’t have the time or energy to fully express our ideas clearly in code.

My policy on SCM logs is that they should be geared more towards why this commit is going in, not what is being done. And what other tickets, stories, bugs it relates to.

PrettyFlyForAFatGuy ,

Lead of a small team of scripters here. The “Why. Not What” is defo a good way of encouraging cleaner code.

Had to request changes recently on a PR like this, big function with comments telling me what it was doing. When they resubmitted for review they had broken it down into smaller functions with good variable/function naming. following what was going on was much easier

AA5B ,

Same strategy here, but recently found myself commenting on the “what”. There was a perfect built-in, but not really readable and I couldn’t figure out how to make it readable, so fine

AstridWipenaugh ,

We solve that problem using naming conventions. Branch names must start with the issue key (we use Jira). You don’t do anything in that branch that’s not part of that issue. If you do, you must prefix the commit message with the issue key that it goes with. The commit itself identifies what changed. The Jira issue provides all the backstory and links to any supporting materials (design docs, support tickets, etc). I have to do a lot of git archeology in my role, and this scheme regularly allows me to figure out why a code change was made years ago without ever talking to anyone.

AA5B ,

To be honest, when I ask a candidate about git, I’m looking for them to describe this workflow.

Heck, I have a new person who I tasked with minor config change, just to make sure she knows how to use git in a professional environment

bleistift2 ,

But when you do need the comments, you usually really need those comments.

It’s nice to see you sharing my experience. My code is either uncommented or very severely commented with comment-to-code ratios of 10:1 or more. I hate the files that are soo green… :(

Valmond ,

Why does

git rebase

work sometimes?

Yeah git can get quite complicated when there ate lots of people working on the same things.

mkwt ,

It’s not git that’s complicated. The work is complicated. git is just one of the tools that programmers use to manage the complexity.

I also think that some people get too hung up on having a “clean” history, and trying to “fix” the history after it has already occurred. I usually have enough problems to worry about in the present, without also trying to worry about the past.

zqwzzle ,

I like to rebase on my feature branches before the PR because it’s a gift to my future self that resolves all the conflicts (if any) before my work goes in. I just find trying to figure out how those conflicts got resolved when there are a bunch of merges in more difficult if there’s a problem later. It’s easier to understand for me. YMMV, this does not work for everyone. Etc etc.

Wrench ,

I find the “clean history” argument so flawed.

Sure, if you’re they type to micro commit, you can squash your branch and clean it up before merging. We don’t need a dozen “fixed tests” commits for context.

But in practice, I have seen multiple teams with the policy of squash merging every branch with 0 exceptions. Even going so far as squash merging development branches to master, which then lumps 20 different changes into a single commit. Sure, you can always be a git archeologist, check out specific revisions, see the original commits, and dig down the history over and over, to get the original context of the specific change you’re looking into. But that’s way fucking more overhead than just looking at an unmanipulated history and seeing the parallel work going on, and get a clue on context at a glance at the network graph.

GissaMittJobb ,

Using curated commits to optimize for pull request reviewability is highly underrated. Liberal use of interactive rebasing to ‘tell a story’, essentially.

andioop ,

you’re they type to micro commit

Thanks for a much shorter and better way to explain this tendency of mine and why I rebase a lot, yoinking this phrase.

ekky ,

“Fixed issue with ssl python libs,” or “Minor bugfixes.”

Red bird going “Hahaha, No!”

In other news, never work more than one person on a branch (that’s why we have them). Make a new related issue with its own branch and rebase whenever necessary, and don’t even think about touching main or dev with anything but a properly reviewed and approved PR (in case they aren’t already protected), or I’ll find and report you to the same authority that handles all the failed sudo requests!

Also, companies that disable rebasing are my bane. While you can absolutely do without, i much prefer to have less conflicts, cleaner branches and commits, easier method to pull in new changes from dev, overall better times for the reviewer, and the list goes on. Though, the intern rewriting multiple branches’ history which they have no business pushing to is also rather annoying.

seth ,

deleted_by_author

    •
    AA5B ,

    To be honest, this is a simple rejection that really doesn’t waste anyone’s time except the perpetrator

    bleistift2 ,

    If it’s not in the git log, it’s not a comment.”

    This is so incredibly dumb, though I’m sure I don’t have to tell you this. That comment will be buried in the git log if anyone ever fixes a typo on that line.

    timbuck2themoon ,

    Your lead sounds like someone who thinks you’re charged per line of code you commit.

    ramjambamalam ,

    git gud

    aeharding ,
    @aeharding@lemmy.world avatar

    git: ‘gud’ is not a git command. See ‘git --help’.

    rekt

    Adanisi ,
    @Adanisi@lemmy.zip avatar

    They should add that command, just to screw up this joke

    uis ,

    git help

    Nalivai , 
    
<span style="color:#323232;">zsh: command not found: rekt
</span><span style="color:#323232;">
</span>
    theFibonacciEffect ,

    git rekt

    samus12345 ,

    Seeing Peter Griffin labelled as “HR”, I automatically pronounce the R as “Ah” in my head.

    cyborganism ,

    Once you understand that everything is similar to a tag, like branch names are basically tags that move forward with each commit, that HEAD is a tag that points to your current commit location in history, and what command moves what kind of tag, it becomes easier to understand.

    Suddenly having a detached HEAD isn’t as scary as you might think. You get a better understanding of fast forward merges vs regular 3-way merge.

    Also understanding that each commit is unique and will always remain in the history and can be recovered using special commands. Nothing is lost in git, unless you delete the .git sub-directory.

    zaphod ,
    @zaphod@lemmy.ca avatar

    For folks unaware, the technical git term, here, is a ‘ref’. Everything that points to a commit is a ref, whether it’s HEAD, the tip of a branch, or a tag. If the git manpage mentions a ‘ref’ that’s what it’s talking about.

    cyborganism ,

    Right. I just wanted to keep it as simple as possible.

    embed_me ,
    @embed_me@programming.dev avatar

    Honestly I’ve come to realise that being precise is the simplest in the long run

    spikespaz ,

    People get overloaded with words. You have to focus on one concept at a time. Let them ask for others.

    zaphod ,
    @zaphod@lemmy.ca avatar

    Oh, no worries, just figured I’d add that extra little bit of detail as it’s a useful hook into a lot of other git concepts.

    docAvid ,

    Orphaned commits can get garbage collected at some point, though.

    cyborganism , (edited )

    Oh fuck. I didn’t think of that. Than you for reminding me.

    Edit: Ah but you can only run this in your local repo. If you happen to push anything, you might not be able to run it on the remote. Many DevOps platforms won’t allow it.

    docAvid ,

    Oh yeah, and anybody else who had fetched in those commits may still have them as well. It’s hard for something to be gone-gone, but it may be annoyingly-hard-to-recover-gone.

    uis ,

    This I call decapitation

    BehindTheBarrier ,

    I made do with my IDE, even after getting a developer job. Outside shenanigans involving a committed password, and the occasional empty commit to trigger a build job on GitHub without requiring a new review to be approved, I still don’t use the commandline a lot.

    But it’s true, if you managed to commit and push, you are OK. Even the IDE will make fixing most merges simple.

    EatATaco ,

    These threads drive home the point that a GUI of some sort is far superior for most users. I use git kraken, but in the past I’ve used git extensions as well, and I take advantage of so much more git has to offer than pretty much everyone here.

    I swear people just want the cli to be better so they claim it is, but I really don’t get how. Especially for quickly scanning the repo, doing diffs, commiting partial files, history, blame, etc.

    ytg ,

    Every once in a while, you can refresh your memory by reading the man page.

    Or if, like me, you use Emacs, Magit exposes everything quite clearly.

  • All
  • Subscribed
  • Moderated
  • Favorites
  • •
  • random
  • [email protected]
  • lifeLocal
  • goranko
  • All magazines
    •