#git branch

[vivektech]

Use Git if: ✅ You need speed and distributed development ✅ You want better branching and merging ✅ You work offline frequently

[kaiserouo]

(prev | next | first)

whoops

[chiseld]

Like... I'm sorry, is it just me, or is this the most ridiculously convoluted way to explain the concept of "HEAD" that has ever been seen?

(regarding this)

[wuggen]

I have no fucking idea how we managed to accumulate this much technical debt this fucking fast

[spookyscarysnails]

call your girl a branch the way im checking her out

[pythonfullstackmasters]

🎯 Git & GitHub Made Simple for Python Full Stack Developers! 

Collaboration is key in the world of software development—and Git makes it easy!

Level up your skills with:

✅ Git Commands – Track your code changes ✅ GitHub Basics – Host and share your code ✅ Version Control – Never lose your progress ✅ Branching & PRs – Collaborate like a pro

👉 Start your journey with Python Full Stack Masters today!

📲 Learn more at www.pythonfullstackmasters.in 📞 +91 9704944488 📍 Location: Hyderabad, Telangana

[21st-century-minutiae]

Git is an early twenty-first century version control tool. It allows multiple people to work on a project simultaneously with reduced issues. For example, multiple people can edit the same file at the same time without a live internet connection and git will allow users to deal with any collisions that occur.

A "commit" in git is the smallest unit of change. Rather than record every since modification a user makes, the user will make a set of changes then "commit" them as a unit. Git would allow them to revert all the changes in a commit, go back in time to what a project was like at the time of a commit, or communicate chunks of changes to other users of the same project. It is a "commitment" to the changes a person is made, which is then "pushed" to other users or "pulled" from other users, and "merged" with other commits.

When using git, a user (if they aren't using a UI to do the operations) will type in 'git commit' as a command, often including a message for other people to see that explains the set of changes. Or rather, that is the intention, as, when projects go on, people tend to get lazier with commit messages. However, "commit" is very rarely used as a transitive verb in the English language. A person "commits to" something or someone, or "makes a commitment." When commit is used as a transitive verb, it is usually in the context of "commit a crime" or "commit suicide."

The above is making a lowbrow dark humor joke where the git commit message is completed with how an English speaker might parse it, turning it into a command for git to take its own life. This may be a reference to the frustration caused by git in the worst case, which is not necessarily the fault of the software and more a natural consequence of trying to coordinate a project between many people.

git commit suicide

[merge-conflict]

source

[soapcloth]

CW: soap x reader, brief mentions of past bullying, religious soap, pushy soap - dividers @/cafekitsune

The mortifying case of Soap having been one of your childhood bullies.

You spot him for the first time in years when he tugs open the door to the corner store just down the street from your parent's house—blissfully unaware of your presence as you duck away behind an aisle in hopes he won't spot you.

Despite being years older, its impossible not to recognize his face.

Last time you checked he had fucked off into the military. Why was he back in town at the same time you were? He never had been before.

Grabbing the last thing your mom needed, you wait until he's preoccupied at the fridge to sneak over to the till, ignoring the odd look from the cashier—of course John's grabbing the same old drink he used to make you steal for him. You can still remember the taunting bark of his laughter when you would sniffle and sob after delivering the beverage, absolutely sure you were going to spend the night in a jail cell if they caught you.

Bastard.

Placing the change on the counter you nod and hastily take your leave, about ready to cry tears of joy once you've made it out the shop door.

It's hard to believe he still has that much of a grip on your psyche all these years later.

Heavy breath billows from your lips as you take the crumbling road back to your parent's place, plastic bag smacking against your hip with each step—always the errand runner around here.

Even if the entire world shifted on its axis, you'd still wager that this town would manage to stay as is.

Three more days until you could go home—your real home; the spot on earth you had carved out for yourself, miles away from this unfathomably deep pit. Your scratchy childhood sheets give you a new found sense of appreciation for the set you had bought for yourself shortly after moving out; soft and well-loved atop your real bed, awaiting your return.

A large hand clamps down on your shoulder.

"Christ! Almost missed ye!" John coughs out, panting from his mad dash to catch up to you.

"Me?" you sputter out, spinning towards the towering man as you calm your racing heart.

The new angle gives you a clear look at the angry scar healing on the side of his head.

He beams, pupils a little out of sorts as he drags you in under a thick bicep. His scent is distinctly more man than you recall and his arms remind you of the sturdy branches belonging to a tree; limbs bigger than the ones you remember reaching for you when he used to chase you around the woods—you had thought them impossibly large then... what were they feeding him in the military?

"O'course! Who else but ye? That f'yer Mum?" he asks, grabbing your bag and taking a brief, distracted peek.

You don't get a chance to reply as switches his attention, nudging his nose into the top of your head to practically inhale your hair. he rumbles happily. "Thought I'd ne'er see ye' again."

you forcefully dig your heels into the gravel and wiggle out of his grip.

"Why would you want to see me? Don't you hate me?" you spit, frowning as you snatch your bag back.

You watch confusion eat away at him for a second before his thin lips press into a frown that mirrors your own, dark lashes trembling a bit as he glares a hole through you.

"Hate ye? Ye think ah hate ye?"

You weren't going to do this—not with the boy that had gleefully isolated you from everyone in your age range during the most important social years of your early life.

"Yer daft!" he suddenly laughs, slipping back into his jovial grin. "-Gave me a fright there for a second!" he pulls you back into him with embarrassing ease and begins to walk again, knuckles grinding into your head before he grabs the bag from you, a satisfied chuckle leaving his lips. "Cannae believe ye thought ah hated ye—Had the biggest crush oan ye,"

No.

"-Thought ah was makin' it obvious!"

No—not this.

"Ah was a jealous wee git, detested ye hangin' out with yer pals. Likely made a right fool o'maself." he rubs at your arm with his large, bear-like palm and sighs contentedly. "No matter, Ah'm no a teenager anymore. How long ye in town for?"

you tug your gaze away from the tight-fitting grey hoodie straining pathetically over his muscles, letting it land on your shoes. he notices your reluctance and laughs, giving you a squeeze

"-God gave me a second chance, ahm no lettin' ye slip away—Full steam oan till we’re wed this time, alright?"

[ajgutierr3z]

ficheros dentro del branch

[codingquill]

Welcome back, coding enthusiasts! Today we'll talk about Git & Github , the must-know duo for any modern developer. Whether you're just starting out or need a refresher, this guide will walk you through everything from setup to intermediate-level use. Let’s jump in!

What is Git?

Git is a version control system. It helps you as a developer:

Track changes in your codebase, so if anything breaks, you can go back to a previous version. (Trust me, this happens more often than you’d think!)

Collaborate with others : whether you're working on a team project or contributing to an open-source repo, Git helps manage multiple versions of a project.

In short, Git allows you to work smarter, not harder. Developers who aren't familiar with the basics of Git? Let’s just say they’re missing a key tool in their toolkit.

What is Github ?

GitHub is a web-based platform that uses Git for version control and collaboration. It provides an interface to manage your repositories, track bugs, request new features, and much more. Think of it as a place where your Git repositories live, and where real teamwork happens. You can collaborate, share your code, and contribute to other projects, all while keeping everything well-organized.

Git & Github : not the same thing !

Git is the tool you use to create repositories and manage code on your local machine while GitHub is the platform where you host those repositories and collaborate with others. You can also host Git repositories on other platforms like GitLab and BitBucket, but GitHub is the most popular.

Installing Git (Windows, Linux, and macOS Users)

You can go ahead and download Git for your platform from (git-scm.com)

Using Git

You can use Git either through the command line (Terminal) or through a GUI. However, as a developer, it’s highly recommended to learn the terminal approach. Why? Because it’s more efficient, and understanding the commands will give you a better grasp of how Git works under the hood.

GitWorkflow

Git operates in several key areas:

Working directory (on your local machine)

Staging area (where changes are prepared to be committed)

Local repository (stored in the hidden .git directory in your project)

Remote repository (the version of the project stored on GitHub or other hosting platforms)

Let’s look at the basic commands that move code between these areas:

git init: Initializes a Git repository in your project directory, creating the .git folder.

git add: Adds your files to the staging area, where they’re prepared for committing.

git commit: Commits your staged files to your local repository.

git log: Shows the history of commits.

git push: Pushes your changes to the remote repository (like GitHub).

git pull: Pulls changes from the remote repository into your working directory.

git clone: Clones a remote repository to your local machine, maintaining the connection to the remote repo.

Branching and merging

When working in a team, it’s important to never mess up the main branch (often called master or main). This is the core of your project, and it's essential to keep it stable.

To do this, we branch out for new features or bug fixes. This way, you can make changes without affecting the main project until you’re ready to merge. Only merge your work back into the main branch once you're confident that it’s ready to go.

Getting Started: From Installation to Intermediate

Now, let’s go step-by-step through the process of using Git and GitHub from installation to pushing your first project.

Configuring Git

After installing Git, you’ll need to tell Git your name and email. This helps Git keep track of who made each change. To do this, run:

Master vs. Main Branch

By default, Git used to name the default branch master, but GitHub switched it to main for inclusivity reasons. To avoid confusion, check your default branch:

Pushing Changes to GitHub

Let’s go through an example of pushing your changes to GitHub.

First, initialize Git in your project directory:

Then to get the ‘untracked files’ , the files that we haven’t added yet to our staging area , we run the command

Now that you’ve guessed it we’re gonna run the git add command , you can add your files individually by running git add name or all at once like I did here

And finally it's time to commit our file to the local repository

Now, create a new repository on GitHub (it’s easy , just follow these instructions along with me)

Assuming you already created your github account you’ll go to this link and change username by your actual username : https://github.com/username?tab=repositories , then follow these instructions :

You can add a name and choose wether you repo can be public or private for now and forget about everything else for now.

Once your repository created on github , you’ll get this :

As you might’ve noticed, we’ve already run all these commands , all what’s left for us to do is to push our files from our local repository to our remote repository , so let’s go ahead and do that

And just like this we have successfully pushed our files to the remote repository

Here, you can see the default branch main, the total number of branches, your latest commit message along with how long ago it was made, and the number of commits you've made on that branch.

Now what is a Readme file ?

A README file is a markdown file where you can add any relevant information about your code or the specific functionality in a particular branch—since each branch can have its own README.

It also serves as a guide for anyone who clones your repository, showing them exactly how to use it.

You can add a README from this button:

Or, you can create it using a command and push it manually:

But for the sake of demonstrating how to pull content from a remote repository, we’re going with the first option:

Once that’s done, it gets added to the repository just like any other file—with a commit message and timestamp.

However, the README file isn’t on my local machine yet, so I’ll run the git pull command:

Now everything is up to date. And this is just the tiniest example of how you can pull content from your remote repository.

What is .gitignore file ?

Sometimes, you don’t want to push everything to GitHub—especially sensitive files like environment variables or API keys. These shouldn’t be shared publicly. In fact, GitHub might even send you a warning email if you do:

To avoid this, you should create a .gitignore file, like this:

Any file listed in .gitignore will not be pushed to GitHub. So you’re all set!

Cloning

When you want to copy a GitHub repository to your local machine (aka "clone" it), you have two main options:

Clone using HTTPS: This is the most straightforward method. You just copy the HTTPS link from GitHub and run:

It's simple, doesn’t require extra setup, and works well for most users. But each time you push or pull, GitHub may ask for your username and password (or personal access token if you've enabled 2FA).

But if you wanna clone using ssh , you’ll need to know a bit more about ssh keys , so let’s talk about that.

Clone using SSH (Secure Shell): This method uses SSH keys for authentication. Once set up, it’s more secure and doesn't prompt you for credentials every time. Here's how it works:

So what is an SSH key, actually?

Think of SSH keys as a digital handshake between your computer and GitHub.

Your computer generates a key pair:

A private key (stored safely on your machine)

A public key (shared with GitHub)

When you try to access GitHub via SSH, GitHub checks if the public key you've registered matches the private key on your machine.

If they match, you're in — no password prompts needed.

Steps to set up SSH with GitHub:

Generate your SSH key:

2. Start the SSH agent and add your key:

3. Copy your public key:

Then copy the output to your clipboard.

Add it to your GitHub account:

Go to GitHub → Settings → SSH and GPG keys

Click New SSH key

Paste your public key and save.

5. Now you'll be able to clone using SSH like this:

From now on, any interaction with GitHub over SSH will just work — no password typing, just smooth encrypted magic.

And there you have it ! Until next time — happy coding, and may your merges always be conflict-free! ✨👩‍💻👨‍💻

[quantumofawesome]

git loves to be like

$ git status On branch main Your branch is up to date with 'origin/main'. $ git pull [...] 347 files changed, 98237 insertions(+), 53968 deletions(-)

[xiabablog]

For Git, I don’t even use that commands that much. I let Visual Studio Code and/or GitHub Desktop to streamline everything. I’ve even forgotten some of the commands themselves now lol-

I love how git only has two functions, but people somehow manage to make this the most convoluted bullshit ever.

I am starting to remember why I hate webdev

[serinemisc]

So I came across this recently.

It's funny, because I think I exactly half agree with it. I do rebase-heavy workflows in Git mostly because every single Git client makes merge-based workflows ugly and hard to use. If GitHub simply displayed merges the way it displayed squash-merges, that would eliminate so much of the need for squash-merges.

But I don't think this covers everything. So let me go through every use-case for rebase separately:

git merge --squash

The squash-merge is one of the most popular ways to merge pull requests on GitHub, and it's an abject failure of the Git ecosystem that it's so popular.

When you do a regular merge on a pull request, you are essentially taking a bundle of commits from somewhere else, and putting it on top of your own main branch. It's an extremely linear thing to do.

But if you do that, GitHub's commit log just gets a bunch of commits interspersed throughout, with zero indication where they're from. And the nicer clients, if they do, visualize it as a tree (pronounced "DAG") (pronounced "a huge tangle of curvy lines"):

This pic is from an article telling you to rebase, and, like, sure, rebasing sure is one way to work around a UI that displays your merges as a huge tangle. But Fossil makes a really good point. Why not instead display your merges as, like, not a huge tangle? git log --first-parent does this (and that's clearly an option in that Git UI), but it should be the default everywhere. And even when expanding the "bundle", the bundled commits should still be grouped together, not interspersed with other commits at essentially random.

The other issue is that, when showing the "tangle of commits", the reason it's so tangled is because it's showing the commits in chronological order of when the commits were made. Which is a completely useless sort order, compared to, say, chronological order of when they arrived in the current branch (i.e. grouping the merged-in commits together). This is why GitHub's rebase-merge is also such a popular alternative to merges.

git pull --rebase

Okay, so. Now you've fixed commit log visualization of merged pull requests. But that's not the only use of rebase! Here's another one: if you're working on some code, and constantly keeping it synced with remote, you'll generate tons of merges that are complete useless noise. Unlike a merged PR, these should ideally be hidden completely, or at least nearly-completely.

Anti-rebase people say that these merges serve the functionality of, like, preserving history. You made one commit when the remote was in this state, and another commit when the remote was in that state, and this is sometimes important history to preserve.

I think they are way overestimating how important that history is (judging by how many people use pull-rebase). I'm fine preserving that history if you can declutter the UIs, but it does require your UI to be able to distinguish between "important" merges (of new features from feature branches) and "unimportant" merges (keeping branches in sync with remotes).

The linked post doesn't talk about this problem at all, so I don't know how well Fossil handles this.

git commit --fixup

That leaves the amend/fixup commit. The link does mention that Fossil supports editing past metadata (e.g. commit message). But sometimes you want to edit the actual changes of a commit.

Now, for a sufficiently published commit, this is a bad idea. But if you have a habit of "commit early, commit often", having 50 bugfix commits makes a commit log really cluttered.

I frequently, like, have to weigh stuff like "is it worth cluttering the commit log to fix one typo in one comment?" for old code. And it would really suck to also have to do that for unpublished code, instead of going in with my trusty rebase scalpel.

git that's all I wanted to say

In conclusion. git rebase is a solution to a number of things that could also be viewed as UI problems, and fixed in other, better ways, and Fossil sure sounds like it's fixed some of them. But some of those UI problems are legitimately hard, and I'm not convinced Fossil fixes all of them, and GitHub extremely has not, so I'm gonna keep rebasing.

[kiwiplaetzchen]

It was late at night, and the corridors of Hogwarts were eerily quiet, save for the occasional creak of old wood and the whisper of distant footsteps. Almost everyone had gone to bed, except for the occasional pair of students hidden in dark corners, seemingly engaged in some kind of mating ritual. Nosy, however, had no interest in flicking nonsense for tonight. No, the little Niffler had a far more important mission.

Navigating the colossal castle was no small feat for someone as small as Nosy. The towering walls and endless staircases presented a challenge even for a Niffler as brilliant as him. But determination was one of Nosy's greatest qualities - well, that and his impeccable taste in shiny objects and other things. Hours of searching through hallways, past common rooms, and even a quick sniff at the kitchens had finally paid off.

There it was, standing proud and majestic: The Christmas tree he had been searching for! The lights sparkled like stars, the ornaments gleamed like treasure, and Nosy's eyes shone just as brightly as the display before him.

The Niffler had overheard a juicy piece of gossip earlier, his sharp ears tuned in on a group of Prefects chatting lazily in the corner. Apparently, they couldn't be bothered to cast protection charms on all the Christmas trees this year. Tz tz. Lazy gits, Nosy thought, clicking his beak in disdain. They clearly had nothing on Mama William, whose attention to detail was unmatched. Still, what was a loss for them was undoubtedly a massive win for Nosy.

With a squeak of excitement, Nosy hopped towards the tree. It was beautiful! The twinkling lights! The shimmering ornaments! The GLITTER! THE LIGHTS!!! It was like a dream come true for the little menace. His heart raced as if it was trying to keep up with the dazzling twinkles.

Nosy paused for just a moment, standing on his hind legs to inspect a particularly large, golden ornament hanging from one of the lowest branches. With a gentle boop, his paw made contact, and it swung lightly on its hook. He let out a squeak of pure joy, giggling at the delightful wobble it made. He could touch it! This was it - this was the jackpot!!

The little Niffler took a step back, sizing up the towering tree in all its glory, before letting out a honk of pure, unbridled joy. This was his tree now. Without further hesitation, Nosy began climbing, his paws grabbing at the lower branches as his belly pouch greedily devoured ornaments of every shape and size. Sparkling stars, glittering baubles, tiny bells - all disappeared into his pouch, his tail wiggling with glee at every piece.

And the lights! Oh, the shiny lights! Nosy couldn't resist wrapping himself in the glowing strands, his fur glowing like a festive beacon in the dark. This was, without a doubt, the best-est day ever! Perched high in the tree, surrounded by all the treasures he'd claimed, Nosy let out a loud, victorious honk that echoed through the empty halls. The Christmas tree didn’t stand a chance.