#git log

[peeterjoot]

git diff against previous

[vivektech]

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

[crimeronan]

if you are nice to people they will typically be nice to you. if you are mean to people they will not like you very much and also will sometimes be mean to you. this will make you sad and mad. if people are nice to you then you will feel happy and glad. when you are nice to people you will find fewer reasons to be very sad and very mad. follow for more wise life tips.

[knifetomeatu]

Nancy forcing Johnny to wear ugly sweaters at Christmas but recently he keeps cutting himself out of them

48 seconds!!🥳a new record!!!🎉 good for him👏

[katyspersonal]

Playing Dark Souls 1 is like

[hxkerwxlf]

"What would you do without me~"

[beaft]

apple tv and netflix are tied for most useless streaming service. neither of you will survive the revolution

[mellifiedman]

Been trying to annoy Dan with a bit where I pull up the terminal and enter a ton of useless commands as fast as I can before opening Rimworld, trying to go for that "hacker in a 90s movie" vibe, but he's never looking at the right time. Think I need to start saying "I'm in." to add to it

[queen-scribbles]

Gee, I'm glad I waited until after talking to companions to switch Seth to his new Wrath armor >;3

[recusantalchemist]

Credit: @andeditor7

[exyglass]

me logging into tumblr

[unixbhaskar]

Linux Git Log Show In Various Ways 2024_05_21_02:40:53

[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! ✨👩‍💻👨‍💻

[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.

[l0vegl0wsinthedark]

Zoom In.

Muggle AU, professor of 18C literature and poetry Draco, celebrity Harry ✨️

~

Violet was the first to log in - again. In the minutes before class began - in the "waiting room" - while she stared at her blank screen, it felt like the only real few moments she truly had to herself.

She spent all those moments, like so many others, thinking about Professor Malfoy.

To every single straight girl, and the singular gay guy, in class, Professor Malfoy was prime wank material. Violet hadn't known her classmates to be as desperate for a good word on their assignments from any other professor. To think homework would feature so high on the to-do lists of some of the biggest lunkheads she knew...there was definitely something about him, that Professor Malfoy.

She could see the appeal. The eerily pale eyes, hair, and skin made to appear warmer by the fluffy jumpers - all in elegant shades of scarlet, burgundy, emerald, wine, golden yellow - he wore over crisply ironed button-downs and tailored trousers; the way he used his hands when he talked, long fingers like a pianist's; the slim golden spectacles he was constantly misplacing on his own head, the rich precision with which he pronounced the olde names and subjects that he spoke of - it was very difficult not to admire Professor Malfoy.

All of that, but nobody really knew much about him outside of uni.

They'd switched to virtual classes a week ago; hurrah for the new pandemic. The idea that she didn't have to sit in class with her tittering classmates, a stray cough sounding now and again, made Violet automatically sit up straighter and smile, just as the little boxes on her screen began popping into life.

"Aaaayyyy!"

"Tell me we don't need to have our faces on display."

"So, yes, before anyone asks: this is a real lip ring. An actual piercing. Yeah, I'm not blowing you, Greg, sod off."

"Is Professor Malfoy on?"

"No, I don't see him here yet. Did he grade your essay?"

"Yo, can someone please tell me how to turn this camera off, I am smashed out my--"

"Click on the camera icon, Bryan--"

"It's not even noon, what d'you mean "smashed"?

"No, you've turned off your mic. No, we cannot hear you screaming."

"First icon on the bottom left," Violet said, rolling her eyes.

And then Professor Malfoy was in class.

There was a beat of silence before everyone called out greetings, a chaotic round of cheerful hello's that nobody could quite make sense of. Least of all Professor Malfoy.

He was peering into his screen, his slim nose scrunched.

"All right, so I can see me. Can you?"

Cacophonic confirmations.

"Okay, so nobody can see or hear me. Right."

More shrill reassurances. One loud beer-belch.

"Damn it all to hell, I knew this would happen, I told him that I'll need--"

"We can see you!" shrieked Preiti.

"We can hear you!" Nora bellowed.

But Professor Malfoy was already twisting around in his chair, scowling heavily, and screaming, "OY! COME IN HERE, YOU MISERABLE WANKER!"

Violet, along with her classmates, just stared in mystified silence. The professor never spoke like that. He ticked them off if they did.

A tall figure in a too big hoodie appeared suddenly, hissing back at Professor Malfoy. There was a golden lion printed on the maroon jacket. The hood was drawn in close, and Violet could just barely make out the light from the computer screen glinting off a pair of round glasses, on which a shaggy fringe of dark hair fell.

"You need to turn the volume up. Git," said the stranger. "Your camera's already on."

"I hate technology," Professor Malfoy seethed.

"You hate so much else. I'm getting fish and chips." The man was already walking off.

"I want mushy peas too, with mine."

"What kind of sick bastard." The room door was shut with a thud.

"Sorry about all that. We are now officially in session," Professor Malfoy said, smiling and restoring his glasses upon his nose. "Do you all have--?"

There was a muffled shout from somewhere behind the professor. Pinching the bridge of his nose, Professor Malfoy called back, "No. No, I don't want a curry dipping sauce."

There was more muffled yelling.

"Harry, get out right now!" shrieked Professor Malfoy, and Violet, along with the others, just ogled.

Malfoy sighed. "Sorry 'bout that. Just my idiot husband."

"You're married?!" Violet had asked before she could stop herself.

Professor Malfoy sighed, flipping open a thick, spiral bound folder. "Yes. You've heard of Harry Potter, I'm sure. He's the poor idiot I married."

[hxkerwxlf]

What I love at times, is this girl's sense of danger, or the 'trill' of it.

But this isn't about a past post where I detailed stuff around Blade, or around Kafka. But more something you'll notice in arts a lot. Kafka leaning against an edge, while Silver Wolf would be sitting on the bars. Which gets me thinking.

Can you imagine the many places where this is taking place?

Like imagine some high mountain tops, some of you sitting in a safe part of it, others being a little more daring. But Silver Wolf? Nah, she's got her feet over the edge, without a care in the world. Her eyes locked on her game screen.

The girl legit gives no fucks.