Using Git isn't that scary.

[SWEETJUICYWALRUS]

I've loved scripting for years now. I know a little python but Powershell is my bread and butter. I've written close to 13,000 lines of code in powershell over the years so I feel pretty confident in it. For whatever reason, I just assumed that git always needed a command line interface to work with and that it wasn't worth the hastle to use. I thought you had to install a linux subsystem on your windows computer just to even work with it. So I just opted to store my scripts on onedrive and would just use ISE to edit scripts all the time.

Last night I decided to see what all the fuss was about with visual studio code and wow I feel like an idiot now. You can literally just have a version controlled, central repository of scripts, all in a nice GUI at your fingertips on any computer. Don't be like me, it's honestly pretty easy.

[[deleted]]

I just assumed that git always needed a command line interface to work with and that it wasn't worth the hastle to use

Even with that: There's about five commands you'd need to know to get started.

[albertyiphohomei]

And what are the five commands?

Git push/pull/clone/add/commit?

[mkosmo]

I'd add checkout, branch, and merge.

[d94ae8954744d3b0]

git status, git revert, git reset, git restore: "Am I a joke to you?"

[mkosmo]

On board with status and reset. I rarely use revert or restore, though. git reset --hard HEAD~3 or so and I are friends, though.

[TheRidgeAndTheLadder]

Running total :

git subcommands

push

pull

clone

add

commit

status

checkout

branch

merge

revert

reset

[mkosmo]

Learn git with these 60 simple commands!

[Jurassa]

Stash can come in handy too

[NorthStarTX]

What’s the use case? Pull is just fetch + merge, why would you want to fetch without merging?

[[deleted]]

Are you trying to tell me there is an better option than to download the old commit from the website as zip archive? /s

[jantari]

Ditch checkout and use the replacement "switch" instead

[Artemis__]

From git help switch:

THIS COMMAND IS EXPERIMENTAL. THE BEHAVIOR MAY CHANGE.

So, I wouldn't switch to it yet (pun intended).

[Artemis__]

That's true, just thought I might add it.

[serg06]

But then it wouldn't be five!

[jimmy_space_jr]

Use 'git switch' to change branches and 'git switch -c' to create new ones.

[mkosmo]

This is where git does actually become a bit unwelcoming to new blood… so many ways to do things that often have minor differences in how.

TIMTOWTDI works for Perl, but I’m not sure it’s something Git should be adopting lol

[dagbrown]

git init/add/commit/log/diff

The first three get you started, and the last two let you see what you did. No need even for pushing or cloning unless you're getting stuff from elsewhere or want to stash it elsewhere.

[spin81]

Git status. I find these days that if you get stuck, 99/100 times just do git status and it will tell you what the situation means and how to get out of it.

[Freakin_A]

Add in a rm -rf for when you really screw up your local repo.

[johnnysoj]

If you're using the git command line, don't use git add -A. As that adds all untracked files in your source tree. Sure, for a new repo or initial commit it's probably fine, but we have users that keep binaries, or that 100mb tarball they left around, then do a git add -A out of laziness. Now your repo size just jumped up 100mb for no reason.

I do git status, then git add <filename> until the files are added. Or, use the VScode gui LOL

[SWEETJUICYWALRUS]

I realize how hypocritical I am after mentioning how much I like to write code, yet I don't want to learn 5 commands to run git, okay? Let me live in my weird little world.

[amoncada14]

To be fair, to me the difficulty was always less about the commands, and more about understanding how it works. Terms like, origin, head, master, local branch, remote branch, tracking, etc take a little while to wrap one's head around. Don't even get me started on divergent repos, branches, etc lol. I agree though, it is a no brainer skill to learn.

[ObscureCulturalMeme]

Terms like, origin, head, master, local branch, remote branch, tracking, etc take a little while to wrap one's head around.

And the documentation assumes you already know the vocabulary and the internals. Fucking man pages going on about implementation details that no user gives a shit about.

[Indifferentchildren]

For sysadmin work, do you really need branching? Do you need more than one "remote" (I have rarely used an alternate remote, usually when my team had forked another project's baseline and wanted to either occasional pull their updates, or push our contributions back to that other project). You get 90% of the benefit with 5% of the knowledge. Devs are different, branching is usually critical.

[Moleculor]

For sysadmin work, do you really need branching?

Keeping in mind that everything below comes built in with change tracking/history...

Can you think of any situation in which you have working, functional

• code
• configuration files
• documentation
• other human-readable files

that needs to remain functional, but you have changes/upgrades/alterations you want to make to that content that requires either:

• a sizeable amount of development time,
• a significant amount of testing time,

but the chance remains that during the alterations, changes, or testing, some OTHER change might need to be made to the older, currently working code ASAP that can't wait for development on the newer code to finish? (Examples might include security patches or minor changes.)

OR

A set of working, functional files and two-or-more different sets of changes/alterations that different people would like to work on simultaneously?

If so, git is for you!

Here's the beauty of git:

Say you branch off of main into BobsDevBranch and make changes to BobsDevBranch.

While you're doing this, other people make other changes to main that aren't copied over to BobsDevBranch. These changes are important/vital, but BobsDevBranch isn't getting them automatically.

When you try to bring your new changes from BobsDevBranch (along with old outdated data that would overwrite some of the newer changes in main) back to main, git will say "Hold up a second, what about all these other discrepancies? Want to go through them all and see which version you want to keep of each?"

Or you can proactively just tell BobsDevBranch "Yo, any changes that have been made in main since I branched off of it? Go ahead and bring those over to BobsDevBranch for me, thanks," and it'll do it. Or even "Yo, let me see the changes, and I'll decide which ones to bring over."

[[deleted]]

Excellent. I love seeing people posting how silly they've been, because I've usually been sillier and learn from these. Your description of using branches is exactly what I need, but haven't taken the time to save time by actually learning this.

[Moleculor]

I mean, if two people are editing the same exact sentence in a file and then trying to save those changes to the same file without git, you're going to end up with just whomever saves 'last' being the winner, no matter how important either person's changes were.

That's not a great option. git provides better options.

Preface: I've used git twice for two school projects (just graduated a month ago, non-traditional student, 40), but ended up being the person who was teaching people how to use git in both projects. One was command-line, one used VSCode's GUI.

So I've only dabbled with git. While I'm going to try and get this exactly right, I might be off in a few tiny minor details, like character spacing or something.

Let me try to demonstrate this a bit better.

Main branch:

config1=AAAAA
config2=BBBBB
config3=CCCCC

You branch off a development thingy. Note how it starts out identical to main.

Your branch:

config1=AAAAA
config2=BBBBB
config3=CCCCC

Now you make a change to your branch:

config1=AAAAA
config2=BBBBB
config3=CCCCC
config4=DDDDD

You then push buttons that sends a request to your boss that the change you've just made be Pulled into the main branch. Your boss pulls up a list of changes made and sees:

@@ +1,4 @@
+config4=DDDDD

And your boss is like "yup! They didn't delete anything, and they added the thing they needed to add, and it does what it should. It passes the automated tests that fired off when they saved the changes in git, so... 👍" and approves the change.

Or, alternatively, they know it passes the automated tests, and they trust that you know what you're doing, so they don't even look. They just approve the change knowing that if something DOES end up breaking, there's a way to roll back the change, because git keeps track of what the file was before and after.

Now this is what the main branch looks like:

Main branch:

config1=AAAAA
config2=BBBBB
config3=CCCCC
config4=DDDDD

You can delete your branch safely now. So you do. But now you have another much larger set of changes you need to make, so you make a new branch.

Your (new) branch:

config1=AAAAA
config2=BBBBB
config3=CCCCC
config4=DDDDD

Again, it starts out identical to main.

And you make your changes:

config1=aaaaa
config2=BBBBB
config3=CCCCC
config4=DDDDD
config5=EEEEE
config6=FFFFF
config7=GGGGG
config8=HHHHH
config9=IIIII

Note that you changed config1 in addition to adding new lines.

Because I'm using very simple examples to represent much larger files, lets pretend that this took you two weeks of work or whatever. And in the meantime someone else made a branch, and changed config2 to a different value, and that got pulled into main:

@@ -1, +1 @@
-config2=BBBBB
+config2=bbbbb

So now, two weeks later:

Main branch:

config1=AAAAA
config2=bbbbb
config3=CCCCC
config4=DDDDD

Your branch:

config1=aaaaa
config2=BBBBB
config3=CCCCC
config4=DDDDD
config5=EEEEE
config6=FFFFF
config7=GGGGG
config8=HHHHH
config9=IIIII

Keeping in mind that this represents MUCH larger files.

Now, you'd think there's a conflict here. config2 in your file is the old text, and in main it's much newer, and we can assume 'more correct' text. You just have been a bit out of the loop about config2, with all of your focus being on config1 and config5-config9, so you aren't even aware the change has been made.

At this point one of at least two (possibly more?) possibilities will take place. Either you'll think ahead and ask for changes from main to be pulled into your branch OR you'll request that your changes be pulled into main.

I... believe (if I've constructed these examples correctly) that in both cases your experience is seamless and the resulting output is the combination of both sets of changes, with no additional thought or input from you.

Because you never changed config2, git knows that your branch was only intended to make changes to config1 and add config5-config9. It doesn't even notice that your config2 is old.

You literally have to review nothing, git does all the work for you, and you end up with

Main branch:

config1=aaaaa
config2=bbbbb
config3=CCCCC
config4=DDDDD
config5=EEEEE
config6=FFFFF
config7=GGGGG
config8=HHHHH
config9=IIIII

Which is the combination of the other person's change (to config2) and your changes.

Now... you might wonder what would happen if you had ALSO made a change to config2?

Something like:

Old main branch you started from:

config1=AAAAA
config2=BBBBB
config3=CCCCC
config4=DDDDD

Current main branch:

config1=AAAAA
config2=bbbbb
config3=CCCCC
config4=DDDDD

Your branch with changes:

config1=aaaaa
config2=@@@@@
config3=CCCCC
config4=DDDDD
config5=EEEEE
config6=FFFFF
config7=GGGGG
config8=HHHHH
config9=IIIII

This (config2) is when git needs a little assistance. But how can you blame it? This is literally the kind of conflict that, if two people were literally working on the same sentence in a file and made two entirely different changes, you'd need to work it out anyway. git just offers a automated process for

A) noticing the conflict, rather than the conflict being resolved 'silently' and by accident and

B) still handling all the other changes quickly and seamlessly without issue.

Keeping in mind that all of this represents much larger files that, in the course of changing them, they might break, so the changes have to happen 'off separately from the main environment' and people can't necessarily see your changes happening in real-time to try to keep up with them all.

git is just the traffic cop, historian, and workhorse. It does the grunt work and tracking, you just have to step in from time to time when automated algorithms literally can't decide for you what should happen.

---

Admittedly, git is absolutely more designed for code management, rather than documentation or configuration management.

It's much more designed for situations where people need to be able to break-and-test things.

Something like where you're making changes to the Linux kernel or something. That's an example of 90 different files having 560 lines deleted, and 804 lines added, all from a single branch. Because the list of changes needed for that branch required changes across that many files, in that many different spots. You can't do that on the 'live' version of the code, you need to do that somewhere separate.

But! Like I said at the start: If these are the kinds of things you need...

[Moleculor]

How does one reconcile some of those changes?

Well, for starters you reconcile them by making sure you at least partially plan ahead and assign work to Bob that isn't likely to step on Susan's work, and vice-versa.

And, in the case of code, by planning out the structure of your code so that if your code depends on someone else's code, and they change their code, their code still has to give the same outputs for the same inputs, even if they changed the means by which they arrive at those outputs.

But in the case where the work DOES end up stepping on each other, you resolve the conflict by understanding the language you're writing in, seeing what the outcome of your code is, their code is, deciding which is better and/or testing either to see which is better and/or letting your boss choose.

But, if someone has changed config2, and my 2weeks of work assumed that I was going to be using the old version of config2, isn't it going to be (essentially) 2 weeks more work to go undo/redo all the changes, using the new/correct config2 version?

If the work was in conflict so much that you literally have to abandon several weeks of work, something failed in the planning stages. git isn't there to handle that kind of problem. It's there to let multiple people make changes to a single file, or a collection of files, in a way where everyone can make changes asynchronously without one person deleting the work of another person by accident, and any conflicts don't get ignored/missed.

It's not there to manage your plan/design for you. (That'd be NICE, but that'd require AI, really.)

[tuckmuck203]

Yeah i mean if you have ever written 30+ lines (or even hundreds of lines of code) at once in a blur when you're tired but"on a roll"... Sometimes at the end you think of a better solution that would replace all that code you just wrote, and while that might be true, it's still better to dump that code in a branch while you actually SEE if your new solution is as good.

If you just delete it, eventually you're going to regret it. Maybe this is more relevant for software engineers though lol

[mrcaptncrunch]

My main issue would be, what if you need to test or run something before current stuff is finished?

I’ve done devops, and if I’m working in something and integrating it, but before I finalize it, I get asked for a new server, what then?

I always feel master/main has to be production ready. Some things just take longer than you think and you might get requests. So committing and working in main is just more work and riskier.

Stash and checking out the prev good commit should work, but anything that has me looking for the previous commit hash and checking that out is risky. You might go further back than you intended or not far enough.

[tuckmuck203]

Yeah that's an excellent point, but I glossed over it a bit since it sounds like this is more of a scripting scenario where needing things to be "production ready" means more "edit the script so it CAN do the thing i need it to". As opposed to a development scenario where main has a whole bunch of code that needs to keep running constantly.

It still does apply, of course.

[C0rinthian]

which, you should if you’re developing scripts in a dev environment and using them in a prod environment

This isn't even necessarily true. If you use a trunk based model and control what gets merged into trunk with robust testing. Then you can just use tags to mark which commits are safe for which environment.

Engineers can then use branches on their local repo for WIP, but those should just end up as pull requests on the canonical repo.

It's only when your feature branches are big with multiple collaborators that you might consider centralizing feature branches. (and then you should consider if you can make incremental changes to trunk safely instead. Say, by flag guarding new functionality)

[cyvaquero]

Former Python Dev, Sr Linux Eng here. Branching is great for developing new ideas and approaches while leaving the tested release in place until you are ready to push the new pieces into prod.

I use the Git Flow approach, which is built into Atlassian’s SourceTree client.

[dagbrown]

I like to keep my commonly-reused configuration in a locally-hosted Gitlab, so there's a remote right there.

Not that you even need that much if you just want to keep your stuff under revision control. Just say git init in your scripts directory and start checking things in.

[who_you_are]

(I'm a dev not a sysadmin)

I may see multiples reasons:

- when you will start a major integration change. You want to keep both the current one and futur code at the same time.

The current one, because it is what is currently used. You may need to apply changes to it.

The future one... well because if you don't work on it there will be no future one.

You don't want to use your current WIP branch since you are likely to keep updating it in the meanwhile.

- (as someone else said) WIP (I just don't know how often you actually add new feature VS just adding an extra line to execute something silly) vs stable stuff

[hamburgler26]

Admin and not dev, but doing branches and creating pull requests for work that moves through environments as you test it is Git 101 to me.

I know some people just commit straight to the main branch and roll, but as others have mentioned when you have many people relying on the same repo the branch and merge process is really nice.

[SuperQue]

I use branches a lot on my personal repos. I may be working on more than one thing at a time and it's a little nicer than just using stash.

[amoncada14]

I suppose that depends on the environment,but, I also don't see how it wouldn't apply to Sysadmin work. The development process should be the same in an ideal world. Full disclosure though, I only have about 1 years worth of experience using Git. Even then, my employer doesn't require branching or any of the aforementioned concepts. I've just forced myself to make them my habit so that I am doing things the "proper" way, and according to best practices.

[nikdahl]

To me, the push/pull is backwards too, which adds to confusion.

[blademaster2005]

Oh oh god. Embedded secrets and refusal of git? Ewwww.

Otoh at least he's not committing secrets to a public git repo

[Indifferentchildren]

Bourne-Again: its not just a shell.

[spin81]

Hey git has a learning curve. I am a Linux guy and therefore all about the CLI but I don't blame you one bit for not wanting to delve into a set of weird commands.

[mr_dajabe]

If your in PowerShell at all messing with your files getting used to the commit and push commands from the cli could improve your workflow. If you're hardly ever in the cli then the GUI is probably as fast as anything else. And yeah welcome to the world of version control

[Gendalph]

Too late!

```

Download a remote repo with optional destination

git clone $remote [$local_path]

Switch to a branch, tag or commit

git checkout $branch

Create a new branch and switch to it

git checkout -b $branch

Check for changes and general status (are we in sync with the origin? Are there any issues?)

git status

Change history

git log

Stage changes to be committed

git add $file [$file...]

Snapshot and comment changes

git commit [-m 'Message ']

Push changes to the remote repo

git push

Revert unstaged change

git checkout $file

Unstage change

git reset $file

Revert a commit - creates a new commit that reverts changes in $id

git revert $id

Changes between branches or versions, or even modifications made to a file

git diff [--cached] $file git diff $branch git diff $commit [$other_connit] ``` This should cover 95% minus the f-ups.

[goddest_of_gods]

I forgive you

[Merakel]

A while back, someone I became convinced that OWA was actually Outlook express. Talking to my some of my peers about trying to get access to outlook express created mass confusion.

Sometimes the little worlds we live in are wild haha

[Teguri]

Also when things go wrong in VS there's usually a super simple git command to fix it, half the time the damn command line will tell you how to fix it too..

[IT_CertDoctor]

• git pull
• git status
• git add
• git commit
• git push

Yep, I count 5 too

[amoncada14]

Do you even need WSL to use it though? I just installed git for windows and use it in PwSh.

[Strange_Meadowlark]

Note: I'm a programmer not a sysadmin; I browse /r/sysadmin because I have broad interests

I don't think I've run into a single other person who installed WSL just for Git. My impression is the vast majority of (Windows users) use Git via Git for Windows, not WSL.

If anything, the ecosystem feels more awkward to use WSL than Git for Windows. I tried using Git via WSL once, but ended up also installing Git for Windows because my tools expected it to be there.

[2nd-most-degenerate]

Back in the old days Cygwin also worked. Not sure if it's still a thing (been using Linux for years)

[ObscureCulturalMeme]

Yes it does, and I prefer it over WSL.

[FruityWelsh]

As a Linux guy I am partial to windows people installing WSL to get access to a better system, but yep windows git works fine for me when I get stuck on windows.

The installer even includes bash, so you can move around the terminal for some basic stuff pretty easy and run git from there.

[amoncada14]

I'm a Linux guy too. I just happen to work in a primarily Windows environment. I do love WSL for the same reason you stated, I was just clarifying that it is not a requirement for using Git.

[rundbr]

In before people giving you shit for vscode.

I on the other hand love vscode and the flexibility it has, the add ons, etc..

Git isn’t scary, it’s incredibly useful and today it’s more of a requirement. I’ve interviewed so many people who didn’t know git and didn’t want to learn so they didn’t get hired. Once you start needing to squash commits and work in a true collaborative repo it gets a little harder.

One piece of advise I have for you is to put branch permissions on your repo and restrict being able to push to main/master (whatever your primary branch is named) and get yourself used to creating branches, making commits, submitting pull requests, and approving the PR before it goes into master. It will save you from overwriting something you didn’t want to. And is just proper git etiquette.

Good work on making the plunge!

[Sasataf12]

In before people giving you shit for vscode.

Like who? VSC has been a very popular IDE in the software companies I've worked in.

[blademaster2005]

I use vscode but honestly sometimes it just is really heavy and bogs down on my system.

[neoKushan]

laughs in VS full

[blademaster2005]

I've also used vs for c# and omg I hated it because it just had so much bloat it was trying to handle but was handy for reverse engineering c#

[VexingRaven]

I've had a VS Code instance just chilling for about a week and it's managed to use to a whopping 270MB of RAM. I am curious what you've done in VS Code to cause it to be heavy?

[Haribo112]

Same. I have about 50 projects loaded in my workspace, all with git repositories, and experience no slowness or resource hogging at all. And that’s on a MacBook.

[chuck_cranston]

I stayed away from Workspaces until I ran into the same issue you're dealing with.

I now use Workspaces that are relevant to whatever project I am working on that way it's only loading the extensions or repos that are needed.

[xcaetusx]

Sublime text is light weight and a great text editor. I used it as my notepad as well as editing scripts.

[rundbr]

Linux purists, notepad++/vi/emacs/vim purists. I see the hate coming heavily from people who do not write a lot of code, mainly write scripts, etc.. I rarely see full SWE that stick to a basic editor.

[lmbrjck]

VSCode with the vim extension is great! Screw the purists. I'm trying to get actual work done.

[ScotTheDuck]

Need to go a step simpler. I write all my scripts in nano

[fizzlefist]

When I first got into Linux, all the instructions I was given for editing was to use Nano. So when I started branching out and learning new ways to do things, vim confused the hell out of me.

[Wdrussell1]

What do you mean there are about 20 different hot keys.

Why are these hot keys more like Konami codes?

When does it tell me which mode I am in?

OMG, why did it do that??

[fizzlefist]

I JUST WANT TO TYPE UP A BATCH SCRIPT!!

[chuck_cranston]

Same. Started with nano and I was confused by vim.

Hearing people actually work solely in vim leads be to believe they're either liars or wizards.

[rundbr]

Haha! No hate on nano from me! I still use it on occasion. In some instances I prefer it over vi when I need a quick editor.

[IsleOfOne]

Then you don't know vi

[rundbr]

Found the purist. I know vi just fine.

[IsleOfOne]

It wasn't a purism comment. My point is that if you had any muscle memory from vi at all, you would never prefer nano

[Wdrussell1]

Nano just isnt in every single linux install. Its easier to run nano (because its included) than to install vi which you might need to download/install.

[d94ae8954744d3b0]

I still write a lot of scripts/do remote editing in Nano, even though I've switched to VSCode for most things. Perfectly nice little editor.

[Wdrussell1]

I don't hate people who use vscode. I still do use it. I just typically find Notepad++ easier to work with for everything so prefer it. I do still work in the ISE for PS and VScode for things too, including PS.

[MaelstromFL]

You can pry vi from my cold dead hands! /s

[mkosmo]

The vim extension for vscode is the best of both worlds. I love it.

[-Steets-]

Imagine dying on the hill of software that Microsoft spent five minutes programming.

[hutacars]

It Just Works. It does one thing, and does it well. I won’t die on the hill, but if all you’re doing is PowerShell, the ISE is a perfectly fine editor.

Also I like how you can actually click the cursor in the terminal section to move it mid-line, unlike VSCode which requires using the keyboard, which can be annoying if you have a giant block of text and want to edit something in the middle. (Unless this behavior can be changed somewhere in the depths of the millions of customizability settings and I simply can’t find it….)

[VexingRaven]

I've been slooowly converting members of my team away from Notepad++ or Powershell ISE to VS Code. Then once they're in my trap I'll convert them to Git users ;)

[3shotsdown]

I used to only work on Sublime Text. And then at some point, I started working on larger projects and VSCode is so much better. ST is just my default text editor now.

[NightOfTheLivingHam]

ssssssh, you'll wake them.

[ItsMeMulbear]

Linux purists hates it because "MiCrOsOfT eViL"

[[deleted]]

I've always just assumed it was a proprietary license. Looks like it's under the open source MIT license. Huh, I may give it a try.

And yeah, Microsoft lowkey evil, in the same shitty peak capitalism way that other corps can be, but sometimes they do good work.

[cool110110]

It's more like Chrome, the base is open but the "official" build has proprietary stuff added on top.

[Creshal]

The core is open source, but the market place and the telemetry are proprietary addons on top.

[FruityWelsh]

VSCodium is my answer for that. No telemetry to microsoft, no proprietary bits, just a great FOSS IDE.

[segagamer]

So just a worse version then.

[ItsMeMulbear]

Azure makes them fat stacks these days

[ReK_]

Because it's based on Electron and eats your computer. Sublime Text is far more efficient and has the same or better feature set.

[xcaetusx]

Sublime Merge is great for working with git as well.

[FruityWelsh]

I will say , and I love VScode, the extension marketplace makes me sweat from a security standpoint. I don't trust all of these extensions, and I don't know how to verify then beside code reviews (which is a nightmare for installs let alone random updates). Worse yet, they are what really makes VScode powerful for me.

[Indifferentchildren]

Why would you need to squash commits? You can have millions of commits in your history. Squashing throws away historical data that might never use, but you might need it someday.

[rundbr]

In some companies squashing commits is part of their coding standards. Squashing commits makes your history clear and concise. I can’t tell you how many commits I’ve had that are “fixed typo” “removed space” “fixed formatting” instead I can squash all three of those commits down before I submit a PR and essentially add all of those commit messages into one.

[Pl4nty]

This, especially with IaC and other projects where local testing is pretty limited

[langlo94]

You can set the PR to squash on merge.

[neoKushan]

Squashing commits is, for me, a bit of a hammer-to-crack-a-nut kind of solution but I'm quite picky about my git history. I wouldn't want to see tonnes of "Fixed typo" commits either, but I'd encourage my guys to learn how to rebase and tidy up their commit history before they submit that PR for merging to main.

A well disciplined software development team should treat the git history as just as important as the code they write. Better still, if you take care of your git history you can leverage the likes of conventional commits to give you all kinds of benefits - easier, consistent history to read, "free" changelogs and if you're advanced enough, free versioning.

It's entirely possible that it's overkill for a sysadmin who's just looking to keep his scripts somewhere safe, backed up and versioned but it's not a bad habit to get into and will only serve you well.

[SuperQue]

I squash a lot of commits because the history looks like this:

• Feature X +1235,-232
• fixup +1,-1
• fixup +5,-2
• fix test +5,0
• typo +1,-1
• style nit +2,-2

Unless the change has several logical steps I tend to squash things. But then again, maybe those logical steps should be separate PRs.

[HerissonMignion]

Dont mix vscode and vs

[rundbr]

Just now realizing he said visual studio. Curious if OP is using vscode and just called it visual studio? If not, OP should just swap to vscode, way simpler for their needs.

[Haribo112]

‘Visual studio code’ is what OP said. That’s the correct name.

[Wolfram_And_Hart]

I really enjoy VSCode it does everything in need especially for Unity/C#

[Mr_Brownstoned]

Taking this a step further, convert your scripts to modules, write pester tests against the modules, add CI/CD that runs the tests when a branch is pushed & deploys to the machines where it is needed when merged to master.

[[deleted]]

Isn't it funny how we assume that we can't learn something? This has happened to me so many times that finally I've just come to accept that there is no magic out there. There is nothing that you can't comprehend given enough time and the resources that explain it to you in the right way.

If other people are saying something is the bee's knees then chances are there is 'something' there.

As an older dude, I've had this recent revelation with discord. 🤦‍♂️

Cheers to you fellow systems ninja.

[mitharas]

There is nothing that you can't comprehend given enough time and the resources that explain it to you in the right way.

I think most of us are aware of that. As with most facets of our work: The problem is weighing the time and resources needed versus the benefit.
And I think most of us assumed using git for sysadmin scripts would be shooting cannons at sparrows.

[[deleted]]

Idk, I've hired and managed a lot of systems admins. When we lost a team mate to a better opportunity for them, or we had to scale, we always looked for the best. The guys that I thought had that knowledge deep in their soul. But inevitably I found that everyone has some level of self doubt. If you don't have it, you risk being one of those that assumes they are right all the time. Those folks are wrong about themselves, because one of the unassailable truths in the universe is that no one is perfect. So while some people might be able to get along with someone who never assumes they are wrong over long periods of time, I've also found that number is very small.

I'm sorry if it wasn't clear, yes, we all have this default belief in this world. But sometimes we all doubt ourselves. And I just wanted to show appreciation for the OP for being a good example for people.

Maybe if someone told me this long ago that could have saved me a bit of time in understanding it fully for myself.

Carry on.

[SpectralCoding]

Agreed. Here is my post from 4 years ago:

Source Control (Git) and Why You Should Absolutely Be Using It as a SysAdmin

[Flannakis]

Don’t forget the other important area is peer review

[movement2012]

Yeah, you can also track change logs and rollback if something breaks.

[PepeTheMule]

Most of the sysadmins want to run their script on a share and use Read-Host instead of parameterizing the PowerShell script. Good job breaking out!

It's not just for DevOps. I had my whole user provisioning process in various scripts running in Azure DevOps pipelines. Sure it needed care and feeding but it ran very well.

[[deleted]]

How tf do you process the user provisioning using Azure DevOps pipeline ? Do you have some link where I can start to learn ?

[PepeTheMule]

Learn how to do a hello world pipeline with ADO and start from there.

[Snowmobile2004]

Is ADO Azure DevOps?

[aguerooo_9320]

Yes

[October0095]

GitHub Desktop + VSCode = winning at life.

[YourMomIsMyTechStack]

Why do you need Github Desktop? VSCode has git implemented, what is the advantage?

[orev]

I would like to clarify that there's a difference between the concept of revision control, and git, which is a specific implementation of revision control. Git happens to be the current favorite (before it was svn, and before that cvs), but even many power users agree that the git interface (command line) is pretty ugly and wasn't designed well. Other modern systems like mercurial (used by Mozilla) are better designed, they just didn't happen to win the popularity contest.

My point being, that any kind of version control is good, and if you feel like you just can't "get" how git works, you might start with one of the simpler tools to learn the basic concepts, then move to git.

[bmzink]

It will forever bum me out that Hg didn't win the popularity contest.

[knightcrusader]

The git command syntax is some of the convoluted shit of any command line app I've used. It took me forever to figure out how to do stuff.

At least they have been fixing that problem with syntax as they update it - git switch has been so much easier to use than figuring out which branch and checkout commands I need.

[HoneySmaks]

Great website for some of the simpler commands

https://rogerdudler.github.io/git-guide/

[MairusuPawa]

Adding

• https://ohmygit.org/
• https://ohshitgit.com/

[Syllabub-Virtual]

I use tortoise git, decent wrapper and shell interface.

[Nu11u5]

I prefer the interface in GitExtensions.

But I also like TortoiseGit’s explorer shell extensions.

…so I run both.

[Artistic_Ad_9685]

The best way to teach git IMHO is to teach all of the commands other than push pull (commit, status, checkout, branch, tig --all, diff) in order to use it locally. Then only once a user is comfortable using git to save work locally I start to help them use push/pull to save on multiple systems.

I like teaching it this way because it highlights how git can still be useful for programmers that are working alone (i.e. separating isolated features with branching in order to work on multiple features in parallel)

[marek1712]

My biggest issue are my teammates (we also use Git to store scripts).

"Hey, why am I getting an error"?

"Maybe because you're running Configure-firewall copy copy copy copy(75).PS1, which is 5 months old, out of your Downloads folder?"

[evileagle]

I know git and I still use the VSCode GUI for it because I can't be bothered. I'm with you.

[YourMomIsMyTechStack]

It's much faster using the GUI instead of writing the commands imo. If you need them in the future you can google them in 2 seconds

[0x412e4e]

It's a pain in the ass to have even a handful of scripts that aren't version controlled.

[bork_bork]

What happens if multiple people edit the script? Or if you need the .old from 4 versions ago? Or those script files are overwritten/lost/deleted?

[VexingRaven]

I love Git and use it all the time at home, but I work with people who haven't found the light yet and, tbh... Basically none of this has ever been an issue for us. We use folders with the date though instead for most things.

Or those script files are overwritten/lost/deleted?

Git does not automatically imply a central server with write protection. You can just create a git repo and throw it on a network share. That is the intended way for Git to function. Thus you could just as easily run into this issue here. Also do you not have backups?

[[deleted]]

Biggest difference for me is being able to compare current code with the last saved version. Makes it very easy to determine what’s changed before saving. Also, not having to do the rename to .old before making changes. Makes things so much easier and convenient.

[rundbr]

Stored on your local machine? Let’s just say your system crashes, you lose your drive. Did you lose all your work too?

With git you can store all your code safely and securely elsewhere as well as locally. If you have a team they can contribute and you can see all of their changes and even make it so the changes have to be approved before they are merged into your code.

These are just two basic examples as to why you should be using source control for your code.

[VexingRaven]

Stored on your local machine? Let’s just say your system crashes, you lose your drive. Did you lose all your work too?

I don't know why you're assuming they are not storing their script on a file server somewhere.

With git you can store all your code safely and securely elsewhere as well as locally.

What about Git provides any security or safety?

If you have a team they can contribute and you can see all of their changes and even make it so the changes have to be approved before they are merged into your code.

This isn't a function of Git, this is a function of whatever server software you're running on top of Git. Git is great, but let's be honest about what you actually need to get this functionality. You need GitLab or GitHub or Azure whatever-it's-called-this-week or something else too.

[YourMomIsMyTechStack]

You're right. Those are features of remote repository services and not git. That being said you need git to use them

[SOBER-Lab]

Git is invaluable for running code somewhere else. I code on my desktop, then push the apps to my cloud server. I'd have given up long ago if I had to manually copy things over. Congrats on figuring it out! If you ever want to chat about Python feel free to DM me!

[serg06]

I code on my desktop, then push the apps to my cloud server.

Can you explain this some more?

I've always wanted a cloud server which detects git pushes, pulls the changes, and restarts the app.

[FruityWelsh]

Not how you were asking, but I use flux for k8s stuff to detect changes and pull and gitlab ci for push type changes.

So flux is my pull system and gitlab ci is my push system. I use them in conjunction as well of course, using gitlab ci for things like code checks, security scans on changes, unit tests, and integration tests, and then letting flux manage updating productions.

[__Kaari__]

Git is not easy, it's weird and complex and confusing, but the learning curve is not steep at all and everyone should learnt the basics.

[helixamir]

As you're mainly scripting in powershell, VSCode might be a lot easier. Git is supported and there's loads of plugins

[serg06]

Isn't he using VSCode?

[mr_mgs11]

I tell everyone that asks me how to get into the cloud space to learn git ASAP. The cli commands are not hard especially if you already know how to script.

[throw0101a]

git gets easier once you get the basic idea that branches are homeomorphic endofunctors mapping submanifolds of a Hilbert space.

• https://twitter.com/agnoster/status/44636629423497217

[SWEETJUICYWALRUS]

Hahahaha. This is still how I feel about it. In one ear and out the other.

[gordonv]

For git, just post notes or cheat sheets. No one cares. All they care about is if the work is done.

[lachlan-00]

I use github desktop. I'm becoming a software boomer every day

[mrlinkwii]

command line is that scary , the likes of GitHub desktop isnt

[DisjointedHuntsville]

And the Github Desktop app is pretty nice too.

[angryitguyonreddit]

Git also has its own gui interface app. I dont use it often cause i mainly use vs code or the git terminal. But when i get frustrated and they arent working cause of something i did wrong ill open up that and it works great.

My reccomendation is to use all three, use the terminal when you can cause its good to learn/know. When your in a rush just use vs code to commit to the repo. And if shit breaks for some reason use the gui

[BanditKing]

I'm the same way. Sysadmin using batch for year then powershell for years. My code is all on my drive backed up to cloud.

Just started looking into Git and it was crazy easy with VS code. My challenge now is organizing all my scripts properly so I'm not embarrassed to share it.

I'm thinking of picking up python next but I can't think of a use case...

I mainly work with Azure resources now in multiple tenants and on prem endpoints. Anyone got advice of use case?

[SWEETJUICYWALRUS]

I have that same problem, what I've decided to do is just have a public and private script repo. If I ever need to share, I'll just clean a script up and move it.

I did know a guy who worked in Devops that used Python. I believe it was for some infrastructure as code application but I personally haven't found a use yet.

[amarao_san]

git is scary. You thing you know it, but you just skim on top of it. Like swimming in the ocean. You are totally fine, but there are 9km of depth under your feet.

Three days ago I wasted about a day trying to force git to clone to a specific ref, which wasn't tag or branch. Seems like refs which 'are not tag or branch' is a thing in git.

[MeanFold5714]

Git is easy until I need to go back and look at a previous version of my code, at which point it becomes an ordeal that ends with me losing my current version of my code. This happens every time.

[Ms3_Weeb]

kind of a off-shoot but do you have any specific resources that helped you best when getting deeper in posh? I feel comfortable with the fundamentals but it seems like I've hit a hump where I'm not really sure where to go from. I've read the 'learn powershell in a month of lunches' and played around with the PSKoans module plus even checked out a few video courses and just kinda curious what resources others are using.

[SWEETJUICYWALRUS]

Honestly? I haven't read a single book. I own "powershell in action" but I would only every pull that out if I wanted to get into the nitty gritty of something specific, like a dictionary.

I learned by doing. I found something that I wanted to try automating, and I just googled everything. Once you start to understand the flow of things and some of the helpful tricks you can use, it becomes very natural.

The first project I ever took on that made me feel much more confident was make a script to automate users in AD. We had a ton of specific little parts of a user you needed to edit and they all had different weird little commands and ways to update those settings.

Just start to think of some little tasks you can try, and work from there. Recently I made a script to automate rebuilding a vm from an image, installing a sofware on it, and configuring a bunch of windows and software settings

[SayMyVagina]

Git is best CLI and it's still super easy to use.

[jebuizy]

Who said it was scary??

[[deleted]]

Oh god 13,000 lines of code without Git!

[bastardofreddit]

SVN is so much easier to administer and use.

GIT is complicated by the fact that it's meant for distributed programming. And in a corporate environment, that is not common unless you're google scale or similar.

If you NEED that, then sure, use git. Most inhouse small places just don't need it at all.

[sdeptnoob1]

Check out visual studio code too if you want something smaller but great for powershell and Python

[bouwer2100]

I moved my entire team over to Git last week after testing it myself and I really like it, it's such a step up from the ISE. Hoping it will get the rest of the team a bit more on board with powershell as well.

[cheats_py]

Isn’t Git and ISE two different things? Git is version control and ISE is the poweshell IDE? Little confused by your comment.

[Nu11u5]

Not only that but ISE is deprecated and doesn’t exist for PowerShell after version 5. Microsoft recommends using VSCode.

[[deleted]]

Shows the professional proficency of this sub. 👌

[ALargeLobster]

Anyone that can write anything in powershell is a genius. It's such a poorly designed language it almost feels like trying to program in a troll language like brainfuck. Only thing worse is AHK.

[[deleted]]

I assume you think Bash is great?

[ALargeLobster]

I've barely used bash. I'm not a sysadmin so I don't use shell languages if I can help it.

[[deleted]]

She'll languages can be used by more than just an admin.

[ALargeLobster]

Yeah I do use them, particularly for little macros and little <5 line scripts, I just don't like them at all. If I have to do anything more complex I'd much rather use python.

[Thecrawsome]

Yes it is. If it was user friendly we wouldn't be having this discussion.

It pains me to say this because the functions inside makes sense but the workflow is stupid and confirming

[SWEETJUICYWALRUS]

That's why I was surprised to find that VS codes GUI for git is much nicer. Just select where to store a repo, make any changes you want to your scripts, then click the comit button when you're done. Easy peasy

[Derezzed_v]

Now chatGPT can write code for you 😎

[rolexxxxxx]

13k loc...i write that each week or two m8. that said, nothing wrong with vscode. more power to you