What are Reddit's favorite Git Client Apps?

Google Drive has some form of version control. Haven't tried it before but could help in this case. https://support.google.com/a/users/answer/9308971?hl=en

And next time, use git (or tbh any version control system like mercurial). GitHub even has a desktop version, I used it when I was in college. https://desktop.github.com/

GitLab is a pain to set up if you're a solo dev who doesn't use Ruby.

I use Gogs, Gitea is a fork of Gogs that some people like:

https://gogs.io/

https://gitea.io/en-US/

They're just Go binaries that you can drop in and they'll run right away with a sqlite DB. Great for a small shop with 1-4 programmers

In the industry, a single person wouldn't be doing a project. Many people come together to build it. There is where GitHub or Git comes in. It's a tool that allows you to control the versions of a project and collaborate with multiple people on a project.

So, if you have the skill of Git, you automatically have an industry-ready skill.

Now, about pushing projects to a github repository. You don't need to start with the CLI tool. You can download the GUI tool to push your projects to GitHub.

But, learning the CLI commands will be helpful in the future, since all git repositories(not GitHub) will have a GUI client.

The link to the GUI client : https://desktop.github.com

Uploading to GitHub will help people who are looking at your code to see how you implement the project in terms of structure, documentation, presentation and following the coding conventions.

Also, it will introduce you to open source software.

And, even if you don't plan on showing other people your code, you can use it to your own advantage. You can control the commits that you do to your project, and if something goes wrong, you can revert quite easily to a previous version.

GitHub allows you to place the source and the releases in the same place and in an organised manner, and since it's a widely used tool, people won't be stumbling around to understand or locate the required files.

Cheers! :)

Here is an easy repo to get started with. https://github.com/Nguyen17/Hacktoberfest-Sign-In

To create a pull request:

1. Create a github account
2. Click on the button on that page that says "fork"
3. Using either the terminal or a github gui, download or "clone" the repo that you just forked.
4. Make the edits you want to make, in this case you can add your name to the index.html file.
5. "Commit" your changes -- this will save them locally
6. Push your changes -- this will save them on your forked repo
7. Create a pull request by going back to the original repo and pressing the button that says "pull request". Press "compare across forks" and where it has the drop down list saying head fork you should find your forked repo. Choose that and then you can submit the pull request.

Now you repeat 3 more times on different repos.

> it is very hard to even interview people who are 'white'

This is going to work out sooo well medium term. Esp for a company providing a service with low barrier to entry. Anybody can set up a Git server, or many. In fact a number of other companies are offering Git hosting.

EDIT: They don't have lock-in either. Pulling a project down from Github and pushing it to another remote provider takes only a few minutes, and that customer is gone.

Perhaps it's time for a significant tech company to implode undeniably because of SJW meddling, and serve as an example to other weak CEOs and stupid investors.

git makes a lot more sense when you see it in a GUI, when you can visualize and see the branches

try https://www.sourcetreeapp.com/

git made a lot more sense to me after this. then learn the CLI and it's way easier

Hello sir. Have you heard of our lord and saviour Version Control Systems?

Here's a tutorial for git and github:

https://www.youtube.com/watch?v=0fKg7e37bQE

Git is a command-line version control software. There are also graphical interfaces available such as git kraken

Github is the main remote repository that people use, however it is heavily geared towards open-source, with private repositories being a paid feature. You can use Bitbucket instead if you want free private repos.

I don't understand why you were downvoted. There are 100 alternative solutions to Google Drive, self-hosted ones and cloud services.
I'm using git-annex syncing to two locations: S3 (encrypted) and a git repo that's on a server under my control. Works beautifully.

Edit: I just realized git-annex has a special remote for Google Drive, maybe you Drive users could check that out :-)

Do yourself a massive favour and set up a Git repository (I recommend BitBucket together with SourceTree) basically 3 clicks and all your data is backed up on a server, with the added benefits like being able to roll your code back/work on multiple devices

I love Sourcetree. It's fast and easy, has a ton of features. Works super well with Bitbucket. They have an instant setup button on the site that will launch Sourcetree and do a lot of the setup for you.

https://www.sourcetreeapp.com/

...which is why we invented git guis!

I just got hired at Axosoft, we make Gitkraken. I'm told we made it because we also struggled with git, and personally I've been using it for about a year and I think it's pretty great. Check it out if you want to, or don't, I'm not your mom.

> What is a .gitignore file?

A .gitignore file tells Git which files/folders should not be in the repository. It is usually used to avoid committing transient files or files that can be reproduced (csproj and sln files are generated by Unity for example).

> Why do I need a .gitignore file?

Because Unity keeps a massive binary database around that it can recreate on the fly. It also contains per-user configuration that should not be shared with other users.

> Where can I get a .gitignore file?

The easiest way to grab a good .gitignore file is to just create a new repository on GitHub. There is a dropdown that lets you choose a .gitignore file and they just happen to have a Unity one available. Just grab a copy of it and stick it in the main folder of your Unity project.

> Do I need to use the command line?

Absolutely not. There is little to no reason for anyone to need the command line for standard day-to-day operations.

> What is the best application to help me use Git?

The GitHub.app hands down. The GitHub.app is by far the easiest way to work with Git especially for newbs and artsy types. It is dead simple to create a repository (which you should do for all project including throwaway projects). All you have to do is drag your Unity folder into the GitHub.app and add your .gitignore file.

It should be noted that while GitHub makes the GitHub.app that does not mean it only works with GitHub. You can use it for local projects or any other Git server.

> Do I need GitHub? BitBucket? My own server?

Contrary to popular belief you do not need to have a server to host your Git repository. In fact, I recommend not using a server until you actually need to (multiple people working on a project, throwaway project promoted to real project, etc). Just drag that Unity project folder into the GitHub.app as soon as you create it. Make it a habit. It only takes 30 seconds.

Magit is hands down the best git experience I've had, even though it's not really a GUI. Most GUIs and text editor extensions miss a lot of features (like git reflog, patching and advanced rebasing) but Magit seems to have it all.

You know how we love Apple products because the software is crafted specifically for their hardware. It's the same for Pixelmator in the sense that it's made just for the Mac using Apple frameworks (interesting read about it here) whereas Photoshop has to work on several OSes and is dragging years of old code making it similar in my opinion to iTunes which got bloated along the years.

Having both I systematically go for Pixelmator, it's more intuitive for beginners, more fluid, and just a generally more pleasant experience.

Remember that Pixelmator is a one time purchase where Photoshop can't be bought and requires a paid subscription

Check out this cheatsheet. I have a printed version on my wall. Very convenient. You don't have to buy Tower, the cheat sheet is just focused on git.

Considering a move.

Right now we're evaluating Gitlab.com (closest to github's experience) and Gogs as a lightweight selfhosted instance with a much lower ressource consumption than selfhosted Gitlab.

The git code itself is distributed, and could be uploaded as is, synced or downloaded whole. I suppose import scripts would import history and non-code content more or less completely.

Gitlab.com maps Github's featerest the closest, but for smaller projects Gogs could work better for a selfhosted instance than Gitlab's community edition.

Yeah, since your firefox profile is in ~/.mozilla/firefox/profiles.

You can put into a git repo and pull it on most linux computers and it's like nothing happened.

Gogs's great for git storage https://gogs.io.

First of all it's important to know how to do all of these from the cli (which it seems you do. Good on you).

I usually use my IDE's (JetBrains) git manager, but as a standalone app I've head good things about Git Kraken

Not the OP but Tower is light-years better.

I’d also add:

• Paragon’s NTFS for Mac, it’s a bit niche and may not be everyone but helps me write to external hard drives which are NTFS-formatted (extremely common among Windows users)

• OmniGraffle. I really like it, much nicer than Visio

• Haskell for Mac, if you’re interested in functional programming at all

I'm not sure on reclassifying the data, but this might be a good lesson in always using source control in your projects regardless of how small.

It's fairly straight forward to setup and start using and its very helpful to save a new version after each change that you can go back to at any time.

My suggestion would be use Github Desktop Application when starting out and go from there.

Ansible+git to back up the setup and configuration

git for code

git-annex for the odd binary file and random notes

I use Google Play Music and Netflix for music and movies respectively and therefore do not require a large-scale backup solution. I'm thinking of moving some lower-priority files into Amazon Glacier.

Elvind Fonn's Spacemacs ABC Series A lot of tricks I didn't know I could do easily before, and upon seeing it I knew it would improve my efficiency vastly: find pattern in all files in a project (SPC s p), iedit (SPC s e), handle multiple projects with projectile (SPC p l), quick navigation and preview with ranger,

Apart from org-mode, magit is another killer feature for me. Git's native command line is unnecessarily complex. It's difficult to perform line-based commit, ediff, rebase without typos, and soon I lost patience. Now with magit, VC becomes such a breeze. I don't miss the days I tried aliasing in .zshrc or git config.

Also just discover ledger. And oh yes, it's wonderful.

Git itself is much faster on *nix than it is on Windows (and Magit makes lots of calls to Git). On OSX process forking via Emacs was slow before Emacs 26, but I gather that Magit performance on OSX should be fine from that point onwards.

You should read https://magit.vc/manual/magit/Performance.html

GNU/Linux is great, though. Go ahead and dive in! Once you've become accustomed to it, you may wonder how you coped in Windows for as long as you did.

There are GUI git clients out there. A lot of them actually. I personally don’t really like them because I use a lot of hooks and things that just don’t really interface well with GUI clients. Try really buckling down with that site and I bet you’ll enjoy the CLI a lot more. Also, I feel like once you sufficiently understand what you’re doing in a git workflow, you’ll like the CLI. It’s so much faster.

Try https://www.gitkraken.com/git-client

Download SourceTree!

https://www.sourcetreeapp.com/

It's offered on both Mac and Windows, and it's a Git Client but it has a User Interface instead of the command line.

SourceTree saved my life as a new developer because the command line was very scary at first, and Git can be unforgiving at times, so SourceTree helps mitigate those issues.

You can PM directly for questions but I believe you can find videos demonstrating how to get up and running with SourceTree in no time.

Similar to me.

Work got everyone a license for GitKraken, which is a great bit of software. But I tend to only use it to view the graph, and do conflict merges as it's merge tool is nice. Everything else I do using the cli.

GitHub uses the Git version control system. If you were expecting a place to drag and drop files, well, it's not quite like that.

1. If you haven't already, create a GitHub account.

2. Create a new empty repository.

3. Download a Git client such as GitKraken and sign into your GitHub account.

4. Clone your empty repository to your computer.

5. Move your files into the cloned folder.

6. In GitKraken, stage all changes, then commit them.

7. Use the "Push" button on the top to upload your changes to GitHub.

8. In the future, in order to change files, you'd stage, commit, and push.

Git keeps track of the changes you make and you have the ability to revert to any previous commit (in GitKraken, right-click -> Reset to this commit). You can also view side-by-side changes on GitHub showing line-by-line what you added/removed.

> We view GitKraken as a SaaS

> It's a SaaS.

I'm glad to know you feel this way because your website sure does a good job of selling this as (direct quote) "100% standalone" (http://imgur.com/a/LfR3y) (direct link: https://www.gitkraken.com/features)

It sure feels shady to me when one of your main selling points directly contradicts your intentions.

I have no problem with a company selling web-based features as a SaaS, but claiming a "100% standalone" desktop application is a SaaS is straight up lying.

Full disclosure, I'm a lead dev on gitkraken, a competing client, so I'm admittedly biased. That said, I'm building a client because of my opinions, as opposed to having them because I'm building a competing client. More of just a reinforcement lol.

With that out of the way, I absolutely agree. I had 2 primary motivations for wanting to build a git client, the second one tying in to what you're saying.

1. Cross-platform issues (I don't think source tree even ran on both windows and mac yet) meant learning a new tool for each OS (and I develop on all 3 fairly regularly).
2. Pretty much every client out there felt way more crufty than they really needed to. My favorite gui has always been git-extensions for windows, but even that feels like it belongs on windows 2000 or a stripped down xp box. To be fair, sourcetree is probably the least-bad about this IMO.

Out of the major clients, I've always sort of felt like it went git-extensions, tower, source-tree in order of usability. I've bungled up lots of my own data in source tree. I'll admit openly that it was all user error, but I'm a fairly skilled git user and I was trying to do simple things, and I've never had that issue in either of the other clients.

It feels gimped too, even compared to git-extensions (which is still gimped compared to the cli, despite being my favorite). Hiding the force push option and other over "simplifications" definitely make it easier to use if you don't know what you're doing, but they make it harder to learn what you're doing, and harder to use if you DO know what you're doing.

/u/Esvandiary is absolutely correct though, the mac version is substantially better than the windows version, although I prefer tower in that case.

I agree with you that GitKraken can be overwhelming. I think it's really geared more towards power users and teams. That being said I did find Github Desktop to be a great alternative. Much simpler, cleaner UI and plenty of great features. I particularly like the history tool and how it lays out changes

This is a basic question. I don't know why you are getting so much shit.

The answer is that you need to learn how to use git. It is the technology that powers GitHub. It is a little hard to understand at first, but thankfully, if you're on Windows you can just use the app:

https://desktop.github.com/

GitHub Desktop will clone your repo into a local folder and then you can just overwrite the files in the local folder and use the app to commit and "push" those files online.

It will take some work to get it going, but trust me, it is well worth it.

Another reply said git but the full suggestion would be use git on your computer and then use a service like GitHub to host and share your project repository.

The way it works is:

1. You use git to make a local repository on your computer. The repository contains all of your project files (PDF and .tex).
2. When you make changes, you commit the files locally, which saves the changes in git.
3. You then push the repository that includes the committed changes to the remote repository (in this case at GitHub).
4. Someone else that works with you can look at the files in GitHub, and clone the entire repository onto their own computer. You can also use GitHub to view the changes and leave comments on them.

I use git on Linux so I just use the command line. If you are on a Windows computer or a Mac, you can use the GitHub desktop client (https://desktop.github.com/).

Have you considered using git? Since the configs are just plaintext, you can easily diff them via git.

If you're not already running a git deployment in house you could try something like Gogs. https://gogs.io/

Gogs has a very small footprint, and can even be run from something as basic as a Raspberry Pi

Rancid and/or Git is probably the best way to go IMHO.

> odeio o git, odeio o linux

Cara, desculpa, mas acho que você tem um problema de atitude. Nesta área você não tem o direito de não querer aprender.

Tanto o Linux quanto o git foram criados pelo mesmo cara e têm a mesma personalidade: são difíceis de entender, são mais complicados e cheio de manhas e neuroses do que uma namorada com síndrome bipolar. Mas, quando você aprende a lidar com as manhas deles, são muito, muito poderosos.

Depois que você usa outros sistemas de controle de versão (CVS, Visual Source Safe, Team Foundation, etc) o git é uma benção. E tenha certeza que um dia você vai precisar dele. Se você tá afins de usar o git de forma mais acessível eu recomendo o SourceTree.

It's the same as other projects, just make sure you have a proper gitignore and a good Git client.

git-annex is great for syncing content between systems, including Android devices. I have set it up recently to sync photos and files between my desktop, phone and tablet.

Yes, a sensible answer to Magit "getting worse and evolving in directions that I want nothing to do with" would seem to be "use a version that you liked".

Whether that's https://magit.vc/elpa/v1/ or some other 1.x or 2.x version, there's nothing preventing you from committing a particular version of Magit to your personal config and using that henchforth (or using it as a basis for your own improvements, if you so wish).

Yes, I agree with you. Magit takes away a lot of git's pain. The other client I've seen which also does a fine job is Tower. But, Magit is at an extreme disadvantage to both the CLI and Tower when it comes to performance. Large projects are abysmal to work with in Magit.

Well, if you deleted everything, it won't be that way anymore.

For next time here's a few important commands to know:

• git status tells you what files changed.
• git diff tells you what changed in those files.
• git reset --hard clears all changes

Try this cheat sheet if you want to know more: https://www.git-tower.com/blog/content/posts/54-git-cheat-sheet/git-cheat-sheet-large01.png

I literally just when through this, and got a dev team finally onto Git version control. I've found that the easiest way to introduce non-developer types is just through the Github Desktop client. It is pretty smooth to use and the errors are fairly human readable. I've found that people mostly just struggle with the terminology, and having a visual helps them a lot. GitKraken is solid too and if you're on Linux may be the best option, but I've found that it intimidates people until they are more familiar with the process.

On my last project and our current project, I finally went through the keyboard-banging of getting our artist up to speed on directly adding assets to the codebase, and it was 100% worth it. No more "which fucking Drive folder did you hide this shit in" conversations, seriously like a rough 25% productivity boost just by not spending half a day finding the secret "Art/Sprites/More Art/Llamas" folder. /rant /artist-bashing

If he finds this post he's going to talk all kinds of shit lol.

Adding to what others are saying around management buy in (which I think is key), I think you should also start by showing the very basic benefits you can get with source control, e.g.

• Central location with audit-ability/blame
• Change/version history

Start off small and see if you can just showcase these benefits, e.g. commit a change that accidentally wipes out a method/whole script and show how easy it is to bring it back. I'm sure a git revert is a lot simpler than trying to retrieve a file system backup.

I would also find a good UI tool to help people through the process. If they are resistant to moving to source control I assume they would be resistant to using the git cmdline so having a good application is key. I haven't used a GUI for git in a while so I don't know if it is still relevant but I found SourceTree was great. Some editors, like VSCode, have git inbuilt and that makes things really helpful.

One thing you want to avoid is just showing everything and delving into the more advanced features like branching right off the bat. Git (if you choose that) can get really complex and I know it has put some people off due to some people's workflows.

Hey... you might catch some flack for using something like OneDrive to sync a project... but folks need to remember that we all make mistakes.

The lesson is, it's not a good idea to use Something like OneDrive or GoogleDrive to sync your projects to different machines. Although it might seem tempting at first.

Another thing I think you're missing here (And I think this is the most important point)...

...you need to run "npm install" if you want to run or build a project on another machine.

This will take the settings inside your "package.json" and install all the dependancies in your node_modules folder. (Remember stuff inside your node_modules folder does not get shared across machines - it needs to be installed on each machine)

Like the other comment here, I recommend BitBucket rather than GitHub as you can have unlimited private repos on BitBucket whilst GitHub charge a fee for private repos.

There is also a handy GUI app for managing your repos called SourceTree. Especially helpful for less experienced devs.

So TL:dr...

1) Use source control (Git is fine for Ionic) 2) make sure you run 'npm instal' when you use a new machine 3) Get BitBucket and SourceTree to help with code management across machines

Links:

https://bitbucket.org/ https://www.sourcetreeapp.com/

I tried that when I was trying to get into Git. Imo, the interface is not great for a beginner. I had no idea what to click.

Look at the interface. Does not seem suited for a beginner.

Honestly, I am not sure what you're looking to gain that you're not going to get with

$ git log --graph --decorate --oneline --all

(notice I added --all. I think that is important and will show you more branches, etc).

The only difference is that you will have it not in a terminal window.

Let me put it another way, you say you are looking for something "better" but that is rather vague and I am not sure what is better.

Don't get me wrong, while I prefer to do all of my git via CLI, I 100% recognize the advantages of a GUI at times and for convenience (preferably with an understanding of what is going on still). But it sounds like you're looking for ways to view the history; not interact with git. And I am not sure what you expect to get?

Also git kraken.

...4. Change jobs ;)

For clarity, Magit 1.4.x (refer to https://magit.vc/elpa/v1/ ) supports Git 1.7.2.5+

Magit 2.x up until the current 2.13 release requires Git 1.9.4+. Starting from Magit 2.14, Git 2.4+ will be required.

So when you say "Magit refuses to run with 1.7.0" make sure you're actually testing with Magit 1.x? Your version of git is still unsupported by 1.4.x, so perhaps it still won't work; but it's far more likely to work than if you're attempting to use Magit 2.x.

The next option is to go back in the Magit 1.x history until you get to a revision which supported Git 1.7.0, and install that in Emacs. The ELPA repository provides version 1.4.2, and I've checked that 1.4.0 likewise specifies Git 1.7.2.5+ in its README file. The next version back is 1.2.2 which does not appear to indicate a minimum Git version in its README, so I would suggest trying that version if you have no success with 1.4.2.

Magit 1.x is pretty old, and it is far less sophisticated than the current version, but it's still awesome compared to using the command line, and still provides some of the killer features that Magit users love.

GitHub does offer a GUI: https://desktop.github.com

I’ve never used it, and I don’t recommend it, as it will probably make you too dependent on it and then you’ll be too lazy to learn the commands (at least, that’s what I know would happen to me). Maybe use it for 1-2 months to learn the basics, before switching to terminal commands.

download the updated files and overwrite them or use cmd prompt apparently.

however, i got tired of doing the first way and im not good with cmd so i did another way.

1. Download GitHub Desktop https://desktop.github.com/

2. When installing it, skip first screen, then make up a login or use a fake name and email since it doesnt matter if youre not fixing code.

3. in github desktop click file > clone repository and then put the address of the repository youre trying to clone. > ex: https://github.com/SteamDatabase/SalienCheat.git

4 . Save the file wherever you want and add the token.txt like in the readme.

5 . Now run the script. when you need to update close the script then open the github desktop and click repository > pull. it will update it for you.

run the script again to use the updated script.

GitHub has its own application which is significantly easier to use to manage GitHub repositories.

Since you already started the process with Visual Studio, before this process begins, you may have to navigate to your folder with the .sln file and delete the .git folder and any file which begin with .git it may have created.

Anyway, to do this with GitHub Desktop:

1. Download and install GitHub Desktop.
2. Log in with your newly created GitHub account you mentioned above.
3. Click File, then click New Repository...
4. Give your repository a name. Usually the name of your solution is good. Since you have no other repositories yet, basically any name is good.
5. Click Choose... and navigate to the folder your .sln file is in and select that folder.
6. Set your git ignore to VisualStudio. Select or don't select a license. It's not required. MIT License is standard.
7. Click Create Repository, then click Publish Repository on the far right just below the menu bar.

Simple. No weird hoops to go through like Visual Studio makes you go through.

This isn't a direct answer to what you're asking but since the conversation so far is related to performance I wanted to throw out Gogs as another Git alternative. I tried Gitlab first but I very quickly got frustrated with its performance (Pi3).

It feels like there's no way anyone reading this hasn't seen it, but Gogs (and its fork, Gitea) are one-click, zero-config self-hosted alternatives to GitHub that are light and fast enough to run out of a VPS or a RaspberryPi.

They use Gogs, by the way, which is so slim that you can run it on a Raspberry Pi. I've been using it since I left Github paid hosting a year ago and Gitlab had too big of a footprint. Never looked back. Great developers.

I may be wrong, but this reminds me of directed acyclic graphs (DAGs). I would guess that visualising these is well-studied.

For example, Git (a type of version control system for computer source code) stores commits (a single unit of code change) in DAGs. The notion of prerequisites in your case would be analogous to parent commits in Git. For an example of how this DAG is visualised, see something like Sourcetree. I'm not sure if that sort of layout fits your criteria though.

> Git

Sourcetree is by far the easiest way to work with Git.

Make a repository at either GitHub (for public / shared stuff) or BitBucket (for private stuff), and use SourceTree to connect to it. Fill it with code.

Then you have access to your code from anywhere, since it's online. And you can rewind to an earlier version any time. So useful!

GitKraken has supported git flow for some time now.

Having a standard workflow and meaningful branch names, not to mention that all commits to master after the initial commit are by definition deployable if you're using the process, just reduces the friction. But I hear the same people kvetching about git flow that I heard complaining about enforceable style guides (RuboCop et al) five years ago, and the same personality types as those who fought source control 25 years ago. Some people seem to resist change because they value their ability to screw things up ("ensure that I'm the only one who understands everything") more than the survival of the project or organisation.

Bus factor is a very real thing, folks.

It sounds like a simplified version of git-annex. git-annex manages files via symlinks to a special directory in .git where the actual data is stored based on a hash (and a few are available, SHA256E being the default. The E means that the file extension is also part of the hash).

It has a separate branch where it keeps track of what files exist and which client has them. It can automatically move/copy data around and tell you where it's supposed to be as well as check the files for corruption.

See http://git-annex.branchable.com/ for more info, especially the internals page.

But what I really wish for is a tool to interact with any git forge, e.g. to create PR's issues etc. for github, gitlab, bitbucket, sourcehut etc. In emacs, I use the excellent magit git porcellain and via magit forge it allows for PR and issue creation and editing across a couple of forgest, though it's missing support for some other things that gh can (e.g. repository creation, though I think there are other emacs package for that, I just didn't use those yet). But I'm aware emacs is not for everyone and something like a cli tool that works across forges would be nice. Maybe there is, I didn't do any research yet. But since the different forges have different features, I admit that a github-specific tool will be more powerful.

I like the github UI and what it did to boost open source software development by facilitating collaboration, but I don't like monopols and want to avoid lock-in, which is I want to use other forges more when possible.

I would say the most useful place to start with Magit is the Prefix Commands. Each of them will show a little interactive panel indicating what options and actions are available, and what keys to press to trigger them.

Another good reference is the official Reference Card.

The main thing you need to get accustomed to is the prefix keybindings, and play with them in a magit-status buffer. Once you have the basics down I think you’ll rarely wanna reach for the git CLI.

Personally I haven’t used (or felt the need use) the git CLI for years. I think Magit the UI around for working with git. If I somehow ever switched to different text editor, I would still use Emacs just for Magit.

Git-Tower has an excellent one. Additionally, they have excellent training and e-book walk-though and provided git sandbox to do exercises to practice. I highly recommend. The cheat sheet is linked on their documentation landing page. Hope this helps!

> I'm using Git for PC

I assume you mean "GitHub Desktop". If you install Git for Windows, you get a terminal emulator, Bash, and Git binaries. Git for Windows contains no GUI.

Also, what automation do you think you need?

I've used both Git and Mercurial extensively in professional environments, and I promise you that Git is what you want. The way branching is designed in Mercurial is an absolute travesty. The branching system in Git is far more intuitive and much less prone to error.

Some might argue that Git is "harder to use" than Mercurial, but really Git just makes it harder to shoot yourself in the face. Mercurial on the other hand will happily let you make a complete mess out of your revision history's branch structure; for example, you could have multiple "heads" for the same branch name, meaning you effectively have two branches with the same name, and it can be a major pain to sort out that mess.

There are plenty of Windows GUI tools for managing a Git repo, most of which I would say are even better than TortoiseHg. The most popular one is probably git-gui. You can also use the Github For Windows app, even for git repos which aren't hosted by GitHub.

I love my current job, but waking up every day and needing to use Mercurial tastes like ashes in my mouth. I didn't care much for Git when I originally started using it, but now that I've been stuck using Mercurial, I miss Git so badly. I do side projects on my own that use Git, and it feels so good to step away from Mercurial for a little while every now and then.

I think it's great that you're looking to open source something that isn't code. It's amazing how much free software is out there, but the prevalence of free software reminds me of how little effort is put into freeing information in other fields.

Yes - you can store images, PDFs, PSDs, etc on GitHub. The only problems come from storing large files (more than a few megabytes).

Without using git at all you can just upload and update files on GitHub. It would be better to use the GitHub desktop tool, though (found here). The most important part, however, is that you are uploading primarily plain-text files. As mentioned above, LaTeX would be a good option.

The Free Software Foundation has a license for documentation that is similar to their popular software licence, the GPL. The most common way to include a license on GitHub is to stick the full text of the license at the top level of the repository in a file named "LICENSE".

You usually find contributors through word-of-mouth. If you post your repository to reddit and other sites (like hackernews) then you'll eventually find people who will help out.

The Github client isn't specific to Github repos, so you could try that (I don't personally love it though): https://desktop.github.com/

I use Appcode for development and it has really good integrated git support, so you could also try that (it's also just awesome in general): https://www.jetbrains.com/objc/

You can have everyone use the github for Windows client and just dump everything onto a network share. No dedicated server or services required. That's a zero cost solution and the guy client will help lower your learning curve (keep working towards she'll usage though).

If you're a Windows shop your developers might already have a TFS (Team Foundation Server aka MS version control). TFS 2015 supports git instances and you can use the github for Windows client with it as well.

Download GitHub for Windows (if you are not on Windows, there are other versions too) and use that for a while. It is a really nice GUI, easy to use with no experience. I still use it for almost everything even knowing the commands.

Edit: https://desktop.github.com/

A very nice and lightweight alternative is Gogs - Go Git Service.

Features (copied from the GitHub page):

• Activity timeline
• SSH and HTTP/HTTPS protocols
• SMTP/LDAP/Reverse proxy authentication
• Reverse proxy with sub-path
• Account/Organization/Repository management
• Repository/Organization webhooks (including Slack)
• Repository Git hooks/deploy keys
• Repository issues, pull requests and wiki
• Add/Remove repository collaborators
• Gravatar and custom source
• Mail service
• Administration panel
• Supports MySQL, PostgreSQL, SQLite3 and TiDB (experimental)
• Multi-language support (14 languages)

Gogs? Notabug is a free service running a (slightly modified) instance of it. You can also host it yourself.

It seems to be a lot lighter than gitlab both on the server and browser.

what /u/dmgctrl said!

Version control FTW. There's a tutorial on Git here: https://try.github.io/levels/1/challenges/1

There's also tools like https://www.sourcetreeapp.com/ (free) that make it easier to work with source control if you don't like the command line.

GitKraken is a great tool if you're looking for a sophisticated Git GUI.

I would definitely recommend getting used to the git bash. Only differences on bigger projects I would say are more merges and keeping track of submodules. Most problems are quite easy to google though.

one shot version:

on host1: find . -exec md5sum {} \; | sort > files_host1.txt

on host2: find . -exec md5sum {} \; | sort > files_host2.txt

copy both files_host1.txt and files_host2.txt on one of the hosts; then run this: diff files_host1.txt files_host2.txt

long term version: use git-annex, particularly the 'git annex whereis' command, and: http://git-annex.branchable.com/tips/finding_duplicate_files/

Welcome to the wonderful world of git-annex and how it works(video).

Both. I use magit (https://magit.vc/) which is built into emacs and is available as a terminal and gui app. Since it's a git porcelain it can do everything the cli can do, usually with single letter commands.

Just to let you know, if you want the keybindings from vim without all the other packages that Doom brings, you only need the Evil package. I also switched from vim to emacs and Evil was very helpful for me. Another recommendation is magit if you work often with git. It's my favorite interface for git management.

>I know that the Magit project recently added functionality for interacting with remotes but I cannot find reference to where that code lives

Sounds like you're thinking of Magit Forge, but it doesn't do what you're asking.

The solution in /u/magnusmalm no longer works, however it's gotten simpler now. The --since/--until commands are now built-in, but hidden by default. After pressing l to show the log popup, hit C-x l to customize "levels", then =s 1 to make the =s (--since) command have level 1 (where levels below some number are shown by default). See https://magit.vc/manual/transient/Enabling-and-Disabling-Suffixes.html for details.

Magit (Emacs) is how I learned git. It's the best version controlling system I have used.

From the linked page:

> It is possible to find the descendents of a check-in in Git using the log, but that is sufficiently difficult that nobody ever actually does it.

Really? I review the logs multiple times a day. In Magit, the binding is simply lb to show logs of all branches.

More.. (but not all) while in the log view:

• bc -- Create branch and checkout
• bb -- Checkout branch
• re -- Rebase branch
• ri -- Rebase interactively - squash, rearrange, etc
• Wp - Create patch file
• VV - Revert commit

See https://magit.vc for more info.

As i understand it, Magit uses Tramp for accessing a Git repo on a non-local machine. i'm wondering whether what you're experiencing is related to this entry in the Magit FAQ?

I switched to Sublime Merge a few months ago an love its simplicity. Also, it can show you the actual Git commands executed, so it is useful for learning the Git command-line as well

https://www.git-tower.com/learn/git/ebook/en/command-line/basics/why-use-version-control

You can do stuff like

• Show all of the source changes between versions x and y
• Easily (well, with less difficulty at least) remove features which will not be ready for release from the dev branch. You can retain the feature branch, complete it next sprint, and merge it back in
• Allow mutliple developers to work on separate features in parallel, by providing a framework for harmonising conflicting changes
• Keep a full audit trail of changes - who did what, and when
• Support automation - e.g. a pull request into dev requires a clean merge into master to be possible, and the result to build successfully and pass automated testing, before it can be completed

In short, it provides a structured way to manage development.

Have you already created the repository? You can use Rstudio's version control features which are great. I recommend getting used to using git through the terminal though.

Here is a good cheat-sheet for git commands

If you can provide some more specific questions I will help you as much as possible. I use git quite a lot, and I feel it is very important for everyone to be a good user. It will make your teammates very happy!

Yes there is an easier way, you want to look to the 'commits' of the repo.

Every commit is a screenshot of the code.

Here is a detail description of what a commit is if needed : https://www.git-tower.com/learn/git/commands/git-commit

If you use Github or Bitbucket or any services like those, you'll be able to see what has been change for each commit, what has been added and deleted from each modified files.

In Github and Bitbucket, when you are at the repository address, you can select 'Commits' to access the commits lists, if you click on a commit, you see every modification of repository's code since the previous commit.

If you just need to see the modifications dates and commits messages you can run 'git log' from your local repo on a command line, assuming you get this repo locally and running command on unix OS or with Git Bash for windows installed.

Besides branching, one thing that is so important in Game Dev with Git is to understand how Git LFS works.
Git LFS (Large File Storage) is required when you deal with binary files. When you don't use LFS all of your binaries will be located in the same repo with your code. This can bloat up your repo, where every contributor has to download all the binary files (even old versions) when they clone a repo. You reach limits pretty quick.

What does LFS do? In short: It places a pointer (1KB file) in the repository and stores the huge binary files outside the repo. In that case, you can download the binaries only when you need them. (It's a bit like virtual files on Dropbox or OneDrive)

LFS needs to be installed separately. You can also use a Desktop client, like GitHub Desktop or Anchorpoint, which has LFS build in.

Make a copy of your project files and try running YYP Maker on them to see if any corrupt files can be fixed. Failing that, use this experience as motivation to get acquainted with some flavor of source control going forward.

There's a video and screenshots of the dark theme at https://www.sublimemerge.com/, which is available after purchase. Every feature of the app works without paying for it, so I think you're really over-exaggerating.

There's tonnes of other Git clients if you don't want to use Sublime Merge though. Github Desktop is my client of choice currently for doing quick work, and yes, it has a dark mode.

I'd say GitHub Desktop as it is GitHub's official desktop client and it's a lot more simplistic than something like SourceTree. You could probably teach a chimp to use GitHub Desktop tbh. That's how I started out learning Git back when I had just started programming and had no idea what Git or version control was.

I may be in the minority here, but I do like using GitHub Desktop. I mostly use it for personal projects and I find it pretty intuitive and don't have to memorize git commands or keep the cheatsheet around.

Sure that's one effective way to do it, though it's a large download.

I'm not sure if this will work for a user without push access, which is restricted, but the GitHub Desktop client might work for you to update changed files in the future. (We use Git*Lab* because we got banned from GitHub, so this guide might help too.)

Regardless of which method you use, I strongly endorse regular backups of your character folder to a non-game location.

Assuming you have no knowledge of git: http://product.hubspot.com/blog/git-and-github-tutorial-for-beginners

Github also has desktop software you can use to do the job for you. https://desktop.github.com/

You could try the GitHub Desktop client for Windows if you want some kind of UI.

Or if you're comfortable with the command line you could just download git itself and follow some instructions (see the "Links" sticky thread).

Schau dir dazu am besten noch irgend ne versionsverwaltung an. Du kannst absolute kacke machen und im worst-case dein Dokument von heut Mittag wieder herstellen. Oder diesen Absatz, den du letzte Woche geändert hast grad wieder zurück ändern.

Alternativen gibts viele, aber Github ist glaub ich das angenehmste wenn du ne grafische Nutzeroberfläche willst. (https://desktop.github.com/)

Did you read the readme? > Clicking "Download ZIP" will not work! This project uses git submodules so you must use git to download it properly. Using GitHub Desktop is an easy way to do that.

https://desktop.github.com/
Once you've installed it, click here

If you want to maintain your own fork, you should probably fork the repository and maintain it with the GitHub Desktop app (which will save you from learning the git command line while you get familiar with the GitHub workflow).

You mean git? Github is just a cloud hosting service for git. For beginners, I would go ahead with Github's GUI application: https://desktop.github.com/, which sort of works like a manually synchronized Dropbox to be completely honest. Here's a list of resources from Github themselves. If you opt for the command line option, the only things you really need to get started are the clone, pull, push, add, and commit. The rest can be learned on a on-need basis.

NotABug.org is built on Gogs. For a self-hosted service, I think it's OK. Ironically, the Gogs code is on Github, instead on a Gogs instance.

I thought of the decentralized git again, if I build such a service, I'll need a very large disk to store all the repos, because people can fork repos from other servers. Maybe it can be a problem.

We have a little server under our desk which runs a self-hosted Git server using Gogs. Together with TortoiseGit, this works pretty well. Right now, we are making backups manually, but we are also working on an automated backup system.

Why Gogs and not GitHub/BitBucket/Whatever? Because backups and private repository spam. I, for example, have about a dozen repositories there, of which only two or three are "serious" projects. The others are little side projects to keep myself motivated.

You can run gogs without root access. Since it's a Go binary, you just download it and run it, no dependencies or anything else to worry about. (I haven't tried gogs myself, but I've mostly heard good things, especially for less-complicated deployments.)

Alternatively, if some web server is already installed on the machine, you can run another instance of that web server, with access control, on a high port. If you want to do this I can dig up instructions.

Alternatively alternatively, you can run git daemon with --enable=receive-pack to allow anonymous, unauthenticated pushes, which is probably not what you want, but if this is within a corporate network or something, that might be just fine.

Well you can take a look at this thread: https://www.reddit.com/r/selfhosted/comments/3mwyk5/must_have_web_apps/

Otherwise I'm testing Gogs (a github like) intensively and it has become very good.

You write code on your computer, and save it on your computer. You use Git to help maintain changes in your code. It keeps track of things line-by-line, so if you make a mistake and break your program, you can go back and see what exactly happened.

If you want to put your source code online, you can use a service like GitHub. GH is often used by open-source software projects because it makes it easy to accept contributions (the aforementioned "pull requests"), but you don't need to concern yourself with that yet.

To learn the basics of Git and its methodology, I suggest using a GUI like SourceTree.

I've been using the Mac laptop and PC tower setup for the past eight years. I really like it, and I consider it the best of both worlds.

What kind of MacBook are you interested in? If you're looking to best utilize your budget, you might be better off getting a cheaper Mac as PC tower parts obviously have a better price/performance ratio. I'd imagine that a refresh is coming at WWDC (though I may be surprised). I would wait until then, especially if you don't need the laptop until when school starts in the fall.

I'm personally not a fan of Office, but I also don't do much in the way of writing documents. When I do write a document, I usually use Google Docs.

In terms of file transfer, I use Dropbox for general small files, but any other similar product with Mac support should work just fine. For larger projects that need proper version control, I use git. (If you're looking for a good gui-based git client, I recommend SourceTree.)

I'd be happy to try and answer any questions you have about OSX.

Another note: I highly recommend that you get the appropriate cables and connectors that will allow you to connect your macbook to your PC's monitor. For many things, I just prefer using my Mac, being able to quickly access much more screen real-estate is very useful.

On a side note, anybody know a good alternatiuve to SourceTree? It's nice, but feature overloaded. I just want to sync my stuff on my computer with my GitHub/Gitlab stuff.

I learned git with the Xcode interface since it's so straight forward, and I'd probably suggest starting with it especially if you'll be coding in Xcode alot. Now I mostly use the command line because its faster and more powerful, but I still use either the Xcode interface or SourceTree when I need to quickly see what an old commit contains. Eventually you'll reach a point where Xcode wont handle something (like stashing or squashing) and thats when you'll need to use the command line :)