Git and GitHub Tutorials - LOUD-Project/Git-LOUD GitHub Wiki
Table of Contents
First Steps
To start with GitHub, you'll need an account. Go to the GitHub website (https://github.com/) and make yourself an account.
Once you've created an account, go ahead and sign in. Once you've signed in, you should see this page.
But what is GitHub? GitHub is used as a repository, with version control.
But how does it work? A "Branch" is a instance of the repository at the time you created the branch. It has two parts, a local branch and a remote branch. This describes where the branch is located. When you work from a branch, it is Local to your machine. When you decide to commit your work, you push to your remote branch.
A repository will always start (And should always have) a "Master Branch". This should be treated as the final place where all your work goes. It'll be the most up-to-date and complete version of the project's files. If you look back at the first point I made about "pushing to your remote branch", the next step after that would -- if you're happy with your commit -- be to "Merge" the pushed files to the Master branch, thus updating the Master to hold your new files.
So, for example: I have the "Master" of LOUD. I make a new Branch which I call "Sparky-Buffs", which is at this point a clone of "Master" stored locally to my machine. I make some tweaks to some files, and I am happy that Sparky now has 300 build power. This now makes my branch modified, different to the Master branch. So I decide I want to commit this, I "Stage my changes" -- I also add a comment on what's being changed -- and I Push the commit. This pushes the newly changed files to the remotely stored branch "Sparky-Buffs", which I will then "Merge" with Master. Thereby fully committing my changes to the master branch. I can then delete "Sparky-Buffs", but I can't cover up the evidence of my tweak because every single commit is saved in the version control history, and every single file that's been changed, added or removed, even if I haven't added a comment when I staged the changes and committed, has been recorded.
Or something like that, anyway.
https://i.imgur.com/oIBXZ3h.png
When you've logged into GitHub, you can see this drop-down menu on the top-right of the browser, along the black bar that houses the "Search Github" field.
Click "Your Profile" and that'll take you to this screen:
You're mostly interested in this button here, "Repositories":
https://i.imgur.com/kzS6FyJ.png
Clicking "Repositories" will list all of the repositories you're currently a owner or contributor to. You'll have to give me your GitHub username so that I can add you as a contributor to the LOUD git repository. When that's done, you should see this appearing:
https://i.imgur.com/8FkCZqP.png
Clicking on "Git-LOUD" will take you to our actual repository. This is the main repository page, and the place you'll spend most of your time if you're going to use the web interface of GitHub for any reason. https://i.imgur.com/MB9A5zU.png
If you ever need to download a zipped up copy of the "Master" branch, then you can click the green "Clone or Download" button to do so, as seen here: https://i.imgur.com/tG9PkDD.png
Things to note about the Web Interface: It's shit, plain and simple. You can use it to upload files here, but it's a horrendous interface and is very tedious. That's why we have two options for handling GitHub outside of the web interface. My personal choice is GitKraken, and Balthazar uses Atom's in-built GitHub functionality. Generally speaking, you'll only ever need to use this main web interface if you need to download a Zip of the current master, or link it to others so they can download the master branch.
Now you've set up your GitHub account, you can move to phase 2: Setting up GitHub with either Atom, or GitKraken.
The fundamental differences between Atom and GitKraken: Atom is an enhanced text editor, that doubles as an IDE with real-time collaboration, Built-in GitHub support (Which allows you to quickly edit code and commit it without alternating between programs) and also has a very nice project folder hierarchical view. GitKraken is an application purely designed to manage a GitHub; it shows the commit-tree, allowing you to easily read the versioning history and trace back merges and commits. It also allows some use of the more advanced features of GitHub, but is also very user friendly and allows some more finer detailing of commits. For simplicity, pick one -- not both. Atom could be great, GitKraken could be great. Personally I prefer the look and feel of GitKraken whilst being familiar with using Notepad++ so I don't feel the need to switch to Atom as an IDE/Editor But I can certainly see where Atom can be a very useful tool. Atom is what Balthazar uses. I have used GitKraken since last year.
New link to the Git: https://loud-project.github.io/Git-LOUD/
GitHub with Atom
NOTE! This is what Balthazar uses, and he can probably be more assistance where this guide may not. This guide has been written by Tanksy, who has only followed Atoms instructions but not used it as extensively.
What is Atom? (https://atom.io/)
It's a text editor, with built-in GitHub functionality. It can also do collaborative text-editing in real-time, and can also be integrated with a Development Environment for writing code faster. Overall it looks like a pretty powerful tool!
(It also helps that it's the GitHub developers themselves who have made Atom.)
Getting Started with Atom
Step 1: Installing
https://i.imgur.com/gDXnvDc.png
You're going to want to visit the Atom website, and click on the Download button seen in the following image:
Download and run the installer. When the installation is complete, Atom will open for you and look something like this:
https://i.imgur.com/8t8Z9p3.png
As you can see, the program splits a view into two tabs. I have the "Welcome" tab open on the left, and the "Welcome Guide" tab open on the right.
AT THIS POINT, YOU MUST BE A COLLABORATOR ON THE LOUD PROJECT GIT. IF YOU DON'T KNOW WHAT THIS MEANS, WAIT FOR ME TO HELP. YOU MUST GIVE ME YOUR GITHUB USERNAME, AND I MUST INVITE YOU AS A COLLABORATOR.
Step 2: Cloning the Master
To get started, You want to look at the top bar of the program and click on "Packages" > "Command Palette" > "Toggle"
https://i.imgur.com/FfT61vT.png
Next, type "GitHub: Clone" and select the only option available:
https://i.imgur.com/yBoufDs.png
You'll be greeted by the Clone window. Here, there are two fields: the "Clone from" field and the "to directory" field. In the "Clone from" field, you'll want to enter this text: https://github.com/Tanksy/Git-LOUD And in the "to directory", you want to create a safe place to store the files. I have chosen my usual LOUD development environment, buried on my Desktop.
https://i.imgur.com/1yNAmGk.png
NOTICE: Make sure the "To directory" ends with the "Git-LOUD" name, to match the "Clone from" ending. This is the name of the folder where the repository will be stored. You'll be greeted by this spinny thing when you click "Clone".
https://i.imgur.com/8zaFqpJ.png
After which, you'll be greeted by the usual welcome screen, except there's now a Left and Right additional panel. It should look like this:
https://i.imgur.com/1VRtNA7.png
Step 3: Authorise GitHub and Atom together
On the left, is the "Project" panel. This has loaded the entire repository as a project, where you can add files, select them and edit them, or delete them, and it will all be listed here. This is probably too over-powered for a mere text editor and will be nerfed in the next patch.
On the right, is the Git panel. This will be used by you in the future (If you choose Atom over GitKraken) to stage changes and push commits, as well as make or select what Branch you're operating out of. On the top right of the Git panel, you want to select the "GitHub (preview)" tab shown here:
https://i.imgur.com/jVvQQrt.png
then click the log in button shown here:
https://i.imgur.com/94iXezd.png
After clicking "Login", you must click the link they provide to visit the authentication page of GitHub's website.
[[https://i.imgur.com/MDaQeN7.png]
You must click "Authorise" and you'll be given a "GitHub token". Click "Copy Token" or manually do it, and then go back to Atom, and paste the token code into the field, like this:
https://i.imgur.com/VONY83R.png
For now, that should be all you have to do to authenticate Atom's use of your GitHub.
Using Branches in Atom
Step 1: Finding the damn thing.
https://i.imgur.com/Gt8TlNj.png
In the bottom right corner of the Git panel, on the right hand side of the program, you should see this:
This button allows you to select which branch you are working on. If you select the word "master" you should be greeted by a dropdown:
https://i.imgur.com/Bloh0k6.png
ALERT: It's always safer to make a separate branch from Master to work on. Click on the drop-down and take a look at what branches may be available. If you don't see a branch that's relevant to your line of work then you may need to make one of your own. This is okay, just don't spam up the place with branches. Usually (and this is professional GitHub practice) you make a branch for a specific task, work on said task on that branch, then after you have finished that branch and merged it to the Master branch, you delete the old branch. In this example, there are no branches for me to use. So I will go through the process of creating my own. This will be the bin-dump branch!
https://i.imgur.com/k6N2Ucm.png
Click on "New Branch", and after a brief load time, the previously "master" branch will have changed to the "bin-dump" (or whatever you call your own branch) as can be seen here:
https://i.imgur.com/qUnI9JT.png
This shows that we are no longer operating from the "master" branch, but are now safely in the confines of our own branch. Remember, TRY not to ever work from Master unless you're trying to fix something that's broken in the master.. In fact, just let me handle anything that breaks there. It's very easy to make everything 10 times worse if you don't know what you're doing. To double check, you can click the button to reveal the drop-down menu and see that your named branch is the selected option. Feel free to make some test branches to try things out and get used to the interface, how to create them, how to select them
Step 2: Creating the remote branch
After you have created your branch, you want it to go live. This is the act of creating a "remote branch". Atom allows us to simply push the branch, which is neat. Click on this icon next to the branch name:
https://i.imgur.com/m77B9WK.png
This should reveal the following:
https://i.imgur.com/B3Bq84z.png
Select "Push", then login when it prompts you up here:
https://i.imgur.com/Jn6W7hR.png
After you've signed in, wait a moment and then click the "Arrows" button next to the branch button again:
https://i.imgur.com/DAKj8UP.png
This will confirm if it worked, as there will be no "Note:" message.
Step 3: Stage Changes
You can add, delete or change files in the project directory and Atom will automatically update the project hierarchy view in real time. You can find this on the Project pane on the left side of the screen:
https://i.imgur.com/63l9xAQ.png
The ".git" folder is necessary for the github to function, but should always be ignored (Hence it's a darker grey color). New files will be green, modified will be orange (I think. I'm not too sure on this) Remember: Ignore the .git folder. Pretend it isn't there, and definitely don't delete it! As you can see, I've added the "bin" folder. if I select this folder, it'll show the contents:
https://i.imgur.com/pDRnzIb.png
This will be my first commit to the master. The intention is to eventually have all the necessary files to run the game directly from the Github repository folder as if it were an unpacked development environment. This may mean we have to miss out on sounds, and definitely movies, due to GitHub's 25 MB file-size limit for free accounts.
To stage our changes, we need to look to the right panel, and ensure the "git" tab is selected here:
https://i.imgur.com/jOYV8i0.png
If we take a look at the entire panel, we can see we have all of my added files listed as "Unstaged Changes":
https://i.imgur.com/48OuSOk.png
This is essentially a way of forcing you to confirm what files you wish to push, as you must select each file OR "Stage all".
After you have staged the files you wish, you can add a commit message. Here, I prefer GitKraken's feature to both have a title and description, whilst Atom has only a description field:
https://i.imgur.com/H0quNkC.png
Finally, we can click Commit. A few things have changed here. Firstly: The staged changes have disappeared as the changes are now waiting to be pushed. Secondly:The project view has replaced any green colors with grey, to show they are no longer "new" but now "integrated":
https://i.imgur.com/hCpp41C.png
And thirdly, we have a "1" next to our "Arrows" button, on the bottom right. I don't understand why Atom chooses to make this the smallest button ever, because it's a very important button which I will explain now:
https://i.imgur.com/oIoOJ0J.png
Step 4: Pushing your Commits
So, now we have a "Commit" that is waiting to be pushed to the Remote branch. This will make it available for others to "Pull" from, so that they have the more updated files, and can resolve any conflicts if they were to arise. Click on the "Arrows" button, and, before we do anything, you need to get into the habit of clicking "Fetch". "Fetch" is a safe button, and will only check for any updates that might have been posted in the time between your most recent "Pull" and the "Push" you are waiting to do. Fetching will allow you to Pull the latest changes (if any) and then you can resolve conflicts that way, before pushing to the remote branch. However, this may or may not work as I am describing exactly. I am unsure if it will fetch from Master, or any other branch than the current one being used.
Once you've fetched, we can click "Push". Once again, you'll need to enter your GitHub login credentials. After which, you should see this icon appearing:
https://i.imgur.com/2sHkc7y.png
Eventually, this will stop spinning, and the "1" will disappear. You can now go to the GitHub web interface if you wish, to double check the branch has been pushed to.
There is still another step required before this update process is complete. As I am happy with my commit, I feel it's ready to be "Merged" into the master branch.
Step 5: Merging with Master
This is where the differences between GitKraken (my choice) and Atom (Balthazar's Choice) are most apparent. Within GitKraken, the merge process is fairly straight forward (and will be explained in the "github-with-gitkraken" section), whilst Atom requires some Web use. As you can already tell, I think the web interface for GitHub is not very intuitive. Regardless, you nowneed to be looking at the GitHub page:
https://i.imgur.com/5R507Nw.png
If the previous steps have been done successfully and you are still logged into GitHub's web interface, you should see the "You recently pushed branches" bar, and you should see the green "Compare & pull request" button. You need to click this button, where you'll be taken to the following page:
https://i.imgur.com/BgqHZFD.png
This is worded poorly. "Open a pull request" really means "Merge to master" in this case and this case only. You are going through the act of Master pulling from bin-dump (or whatever you named your branch). Here, we see the comment we entered in Atom, as the title of this pull request. We can -- and should -- make some comments here in the comment field to describe the changes we've made. An important part of this page is to double check what we're merging, seen here:
https://i.imgur.com/alwgmqR.png
If we're merging our work to the master branch, the base must be master and "compare" must be our branch. Be very sure that this is correct, because if not you could inadvertently force your up-to-date branch to be overwritten by the older Master When you're ready and sure, click Create Pull Request.
You will now see the following:
https://i.imgur.com/zWOKEyd.png
The area that states "This branch has no conflicts" will initially be orange in color as it performs some automatic checking on the site-end. Just be patient, wait for it to turn green. If it turns red, there's a problem and some conflicting files have arisen. I'm not sure how to handle conflicts through the web interface, but I believe Atom should catch them before they even get this far anyway. Balthazar can probably confirm or deny this.
Select the "Merge Pull Request" button. You'll see we're given a third commit title and description, and honestly I don't understand which one is the proper one we can see in the commit history. Click "Confirm merge" and we're taken here:
https://i.imgur.com/beAcCox.png
Step 6: Deleting the old branches Deleting old branches is good, as it prevents them from causing any problems in the future if the branch's purpose is fulfilled. However, in some cases you may want to keep a branch active for future usage. For example; if you have a branch to handle any and all unit changes, as opposed to specific unit changes. For instance, our recent Nuke launcher changes could be listed as typical "Unit Branch" changes, or an entire branch purely named "Nuke Launcher fixes". This is where we tidy up this loose end, and we can click "Delete Branch" or not. This page provides a good overview of our commit's history.
We can see the comment, what we done and an option to revert this change, and where I deleted the branch and the option to restore the branch. GitHub is all about version control, after all. Finally, to get back to the main page we can click this link
And now, we can see that the "bin" folder has been successfully merged into Master and is present there. We can also see the commit change:
https://i.imgur.com/tvI9fTy.png
Step 7: Pulling from remote
Return to the Atom program, and go to the bottom-right and ensure we're on the "master" branch. Click on the "Arrows" button and click "Fetch", then "Pull". This should update our local copy of the master branch. I have had a couple errors when pulling, however I can't determine if these are always going to happen as I could fix these issues by simply clicking "Pull" again.. And all worked fine.
Afterword
As a final note, I personally like Atom but feel the GitHub features are lacking. I want to avoid using the web interface anywhere it is possible, and that's why I will be using GitKraken. If you choose to use Atom, but run into issues with it, then I may not be able to help as I am much more experienced with GitKraken.
GitHub with GitKraken
What is GitKraken?
(Git GUI for Windows, Mac & Linux | GitKraken) GitKraken is essentially a neater, more organised and faster front-end UI for the GitHub Web Interface. It allows you to easily see and manage your branches, your version history and commit comments and the files that have been changed. The one and only downside I've found to using GitKraken is that you need to create a GitKraken account.
Getting Started with GitKraken
Step 1: Installing
Go to the GitKraken website linked above, and click the "Download" button seen here:
https://i.imgur.com/8dKfgOX.jpg
Once it's downloaded (Which might take a small amount of time as it's 90 MB), run the setup and GitKraken will gleefully install itself, giving you this screen:
https://i.imgur.com/L0lX2Vg.png
Step 2: Authenticating GitKraken with GitHub
Once GitKraken has opened, you should be greeted by a similar screen as the one shown here:
https://i.imgur.com/KaQUd9H.png
You want to click on the button labelled "Sign in with GitHub". This will open a window in your browser where you can proceed to log in and authenticate. The website should display the following message, after any log-in or authentication prompts (For me, it automatically done it, and I can't find the registry entry I need to delete to have a truly blank-slate starting experience)
https://i.imgur.com/CceFenh.png
When you see the above image in your browser, you can switch back to GitKraken itself and focus on the prompt below:
https://i.imgur.com/K4yvBu9.png
Like GitHub, GitKraken has a premium service we can safely ignore. Tick the "Hide the "GitKraken Pro Free Trial" button, and then click "Not now, thanks". To check we've correctly authenticated with GitHub, we can go into our Preferences. On the top-right of the application is three horizontal lines that typically denote a menu. Click on that, you should see a "Preferences" button shown here:
https://i.imgur.com/dsCZ8NR.png
Clicking on this, opens the Preferences menu. You'll see general settings here, but you'll want to click on "Authentication":
https://i.imgur.com/ICAJMwt.png
In this screen, you'll by default be on the "General" authentication tab shown here:
https://i.imgur.com/iczq6G4.png
Click on "GitHub.com", and if all is well and the authentication process has gone correctly, it should show the following: If it doesn't say "Connected", there should be a button you can press to manually authenticate once again. Remember, you need to be authenticated if you want to properly do anything with GitHub. Once this is done, go ahead and click "Exit Preferences".
https://i.imgur.com/Rn1KdxV.png
Step 3: Clone the Repo
Now we're properly logged in and authenticated, we can clone the Git-LOUD repo, and begin working. First thing's first; select the folder icon in the top-left corner of the GitKraken window, after you've closed the Preferences screen.
https://i.imgur.com/aeW6ld2.png
Clicking this icon brings up the "Repository Management" window, which looks a little bit like this:
https://i.imgur.com/43UqvZJ.png
Click on the button on the left that says "Clone", then in the central panel click on "GitHub.com". On the right panel, this will change to show you a list of Repositories you are a collaborator or owner of and the directory you wish to clone to.
AT THIS POINT, YOU MUST BE A COLLABORATOR ON THE LOUD PROJECT GIT. IF YOU DON'T KNOW WHAT THIS MEANS, WAIT FOR ME TO HELP. YOU MUST GIVE ME YOUR GITHUB USERNAME, AND I MUST INVITE YOU AS A COLLABORATOR.
https://i.imgur.com/QcETL5K.png
Lets first choose where to clone to. This is the same process as in Atom, if you've read that guide. I've chosen a folder which I can easily find:
https://i.imgur.com/Mwlab3J.png
Next we'll choose the "Repository to Clone". If you've never used GitHub before and you're set up as a Collaborator, there should only be one option available here. Select the "Git-LOUD" repo and you should see the following "Full path" be auto-filled. This is fine, just click "Clone the repo!" afterwards.
https://i.imgur.com/ApqrlOV.png
As the repo is being cloned, in the top-right you will see the progress of the cloning:
https://i.imgur.com/4BaNFm0.png
Once cloning is complete, the top-centre will show the option of opening the repo. Click on this!
https://i.imgur.com/3hkN9Mo.png
You'll now be greeted by the full GitKraken UI experience. It can be a little overwhelming, so I'll go through each part individually before we try any committing or branching.
https://i.imgur.com/X2Zzguj.png
Step 4: Familiarising
In the top-left, we can see the Branch we are currently working on. Without any branches made or selected, you will default to master. We will change this when we come to making our own branch. Generally, you can click on the "master" as a drop-down button to see all available branches.
https://i.imgur.com/4aEQJeU.png
In the Left panel, we can actually see a breakdown of all branches, both local and remote. We can also see other info such as Tags and Sub-modules, but we can ignore those quite happily.
https://i.imgur.com/TuRddQv.png
The green selected "master" branch under "LOCAL" indicates that any changes we are making are going to be part of that branch. If we were to push these changes, they would be pushed to the "REMOTE" master branch, which then allows everyone to pull to get the most up-to-date files you just posted. Just like in Atom, we'll make a separate branch later. On the top-centre of GitKraken we can see our command buttons. These are fairly self-explanatory and you'll only really be using them as and when they're needed.
https://i.imgur.com/vuOjvUV.png
The central panel is the most powerful and the prettiest. This panel shows you the "Commit Tree", or "Version History" or whatever you want to call it. You can see every single push, and every single merge, and their comment title here. It also has handy links showing you – at a glance – where things are moving. You can select individual commits in order to get more details, or even revert to that specific commit, or create a branch from that specific commit. It's just too powerful.
https://i.imgur.com/pL20vFB.png
As an example, we can see my Branch from the Atom guide. If we select it, it should be highlighted as such:
https://i.imgur.com/ehfUsaV.png
Selecting this, we can get the information on the right-side panel:
https://i.imgur.com/6VN2uY7.png
This information shows us the commit message, who done it, the ID, when it was done, and any – Changes (Yellow files), Removals (Red files), Additions (Green files), or Moves (Blue files) made in that commit.
Practice Run
Step 1: Create a Branch
On the left-side panel, right-click on "master" and click on "Create branch here".
https://i.imgur.com/BFlI8o0.png
When you select this, it might seem like nothing's happened. Don't worry, look at the central panel in the top-left corner, you should see this:
https://i.imgur.com/atbHzSy.png
This is self-explanatory. For this example I'm going to create a branch to take the Maps folder from OneDrive and dump it onto the Git. Type the name of the branch, and hit the enter/return key. Immediately you'll notice some changes; firstly, this notification:
https://i.imgur.com/MbX0JVa.png
Secondly, the branch we're working on has changed:
https://i.imgur.com/6azYg3m.png
This, like when I did this example in Atom, is not yet Remote, and is only Local. To make this Branch a live branch that doesn't just exist on our machine, we need to do the initial "Push" of the branch to become remote. To do this, select "Push" in the top-central bar. You'll see this:
https://i.imgur.com/Ls2lhp5.png
Don't worry too much, just click "submit". After a short time, you'll see that our new branch has been pushed to the Remote branches. This means it is now available for others to pull from/push to/etc.
https://i.imgur.com/rDkeSuI.png
(Make sure that you remain selected onto the local branch. When other branches exist that aren't present on your machine, you'll be able to select from this list of remote branches in order to pull them to your PC, thus making it a local branch. This won't be covered in this example, but I will cover it when it's necessary).
Step 2: Pushing to the Branch
Now we have our branch ready, I'm going to put some files in that I will then push to the master branch – Just like I did with Atom, and will go through it step by step. To put files in, or remove them, or edit them, we'll need to go into the folder they're located in via windows explorer just like we'd navigate any directory.
https://i.imgur.com/BnPWo3h.png
This "Map Dump" is only going to consist of small maps for now, as the larger maps are exponentially larger in file size than GitHub allows for free. Going back to the GitKraken we can see this appearing:
https://i.imgur.com/Ze6Lsix.png
This shows that there's file changes waiting to be "Staged". This little "// WIP" indicator is a good way of seeing if files have changed without you realising, too. So, let's select this and on the right-hand panel we can see our Staging area. If you've read the Atom guide, this will look immediately familiar.
https://i.imgur.com/blJxoHn.png
As with Atom, we can look at our individual file changes, or click "Stage all Changes", shown here:
https://i.imgur.com/ssk2drG.png
After you click that, the files will move from the top box, to the bottom box, showing they're now Staged. You can add a text summary and a description, before hitting "Commit changes to # files":
https://i.imgur.com/jsbyaC1.png
Committing, on its own, is a form of check-pointing your work. You can make several changes and commit them without pushing, multiple times, and the commits will work as "save points" for the work done. After clicking Commit, we'll see that the central panel has updated:
But, this isn't done yet. This is only a Commit, and is only on our Local files. If we want it to go live, to be merged later, we still need to push it to the Remote branch. First, take a look at the left panel:
https://i.imgur.com/kvEmWe9.png
The small "1" with the up-right arrow is telling us we have 1 commit waiting to be pushed. As well as this, we can get a down-left arrow that shows how many "Pulls" we are behind by.
https://i.imgur.com/bb5FNkN.png
To push our latest commit, we click on the top-central "Push" button:
https://i.imgur.com/bb5FNkN.png
When it's complete, we'll get this notification:
https://i.imgur.com/H5vdfnc.png
This means that our local files have been pushed successfully to the remote branch, under Origin. Origin is where everything goes, although it still remains relegated to separate branches. Step 3: Merging with Master Let's drag our branch down towards Master on the left panel, we do this by left clicking and dragging. This is how we start the Merge process:
https://i.imgur.com/C4yiQaw.png
When you do this, you'll be given this context menu:
https://i.imgur.com/kTVbuRd.png
Click on "Merge (branch name) into master", then right-click on master and select "Push".
https://i.imgur.com/oT9RVs7.png
When the operation completes, if all has gone well, you should see this notification:
https://i.imgur.com/xxgnDQn.png
Be aware that conflicts can happen where files are being modified by multiple sources and the changes being pushed by one person are conflicting with the pushes of another. We'll deal with that hurdle when we come to it, but with the scope of our project it's unlikely to happen. We can now see our branch, and how it paths on the version history view. We can clearly see from where the branch was created, how many commits were pushed, and where it gets merged into the Master: Now we're finished with this "map-dump" branch, we can safely delete the branch. If we need to add more maps in the future, we can make a new branch following this guide. Eventually it'll become second nature and is really easy to pick up. First, double click on "master" on the left panel to switch our "Checkout" to master.
https://i.imgur.com/3uDPLE2.png
This means we're now working to master, like we were originally when GitKraken was first set up. We can confirm this by checking the notification:
https://i.imgur.com/FueUMXb.png
We should now be able to delete the unused branch, clicking the "Delete (branch name) branch" on the context menu:
https://i.imgur.com/KT5MFjx.png
You'll then see this bar appearing at the top:
https://i.imgur.com/9BkW0pa.png
If you're sure that deleting the branch is okay, go ahead and do so. This will only delete it locally, but you can repeat the process for Remote:
