What is Reddit's opinion of Sourcetree?

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

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

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/

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.

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

Look into using source control software the programmers do. Set up a repo at https://bitbucket.org/ or https://github.com/ and use https://www.sourcetreeapp.com/ for a GUI and upload / download your files. This gives you versioning and branching. (Gives you save points and what if options.) If you want something real simple, look into dropbox.

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.

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!

Like other people mentioned, CMake to create Visual Studio project on Windows, but still being able to build on other system.

If you push on github, you can try SourceTree. Try also to link your account with travis or drone.io to build your project on linux if you don't have a build system (but you may want to configure your cmake in your vm first, try to install virtualbox + vagrant for a quick VM)

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.

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 :)

Your environment doesn't really matter, since most tools are environment agnostic. Linux and Mac are great for development, but they aren't required and if you're learning you don't really need to add learning Linux to your huge list of things to learn.

If you want to get in to version control, I highly suggest Source Tree as a Git GUI. It's extremely easy and important to get started using git to check your stuff in. You don't have to worry about command line or forking or merging or anything like that until you're ready.

Bitbucket if you want to keep your git repos private. It doesn't matter who your remote host is. Github does not offer free private repositories. Git is the source control, Github is just the name of a popular site/repo.

There are tons and tons of tutorials out there. Just google around until you find one you like. CodeSchool has a specialized Git course. I have not done this, but I'm willing to bet the free course is enough to get you started.

I make separate commits on every logical part. For example, if I fix a bug that maps an object to the proper URL and another bug in the same file that generates its QR code properly, these will be two separate commits. A client such as SourceTree makes this a joy to deal with.

SourceTree (https://www.sourcetreeapp.com/). They have clients available for windows and Mac. I find its pretty close to command line git with an occasional gap.

I configured it to use beyond compare for merge since I like that tool better for merge conflicts.

I haven't found a good git command line toolset for windows though.

A high quality and clear explanation of several basic work flows (that applies equally well if your remote repos are in github) is here. It is straightforward and presents simple solutions to simpler problems.

They also have an excellent visual tool (source tree ) that you can use alongside the command line to be doubly sure of what you're doing as you learn.

I've been using bitbucket for those personal projects that aren't meant to be public for a few years now.
Would highly recommend it. Also, take 30-60 minutes to learn Sourcetree - I have brought it with me to every job/project I've moved to, it's just too comfy to give up.

I found this tutorial pretty helpful for getting the basics down: https://www.codecademy.com/learn/learn-git

For the most part, I really only use the command line when setting up a git project, or when doing something more advanced. I find that Sourcetree handles most daily tasks (push, pull, merge, change branch) pretty well. https://www.sourcetreeapp.com/

You can download old versions from here: https://www.sourcetreeapp.com/download-archives

I use 1.10.23 personally and it runs well. I tried twice to "upgrade" to the latest version and I've downgraded back both times. They did something bad in v 2.*+, maybe different management or team leader, I'm not sure, but it went to shit.

Yeah, I just gave it a try, changing the repo in the settings tab still wants you to sign-in to github on publish.

Honestly though, this plugin looks terrible, no change preview on the commit panel? wtf :P

> https://www.sourcetreeapp.com

After you modify your source files, you can either use a gui such as sourcetree https://www.sourcetreeapp.com/ or via the command line. When inside a directory in the command line, you can do: git add . git commit -m "Your commit message here" git push origin master

Bitbucket has instructions on how to connect your local repository (project folder) to Bitbucket and "the cloud".

No, but the Github Desktop app is really limited, I'd recommend you to take a look at SourceTree maybe, which does have this feature and is available on both Mac and Windows

For adding hunks/lines of code to a commit, for the longest time I've been using git citool. It fires up a crappy, but functional TK UI that's bundled with git. (If you're using XCode's bundled git, it may be broken. install Homebrew's git for one that works.)

Though, as much as I generally hate Git UIs, I've recently started to use https://www.sourcetreeapp.com/ for staging all my changes. It's pretty and fast.

log -p is amazingly useful, though. You can also git log -p -c to see how merge conflicts were resolved in merge commits. And I often use git log -p -S$some_change some_file to see exactly what commits introduced some change into a file I'm working on.

Learning to use GIT will be a live saver... Use a managed service for the important stuff (BitBucket), but heard some great things about GitLab lately. You can have your master branch for your stable code, and then dev/staging/feature branches. https://www.sourcetreeapp.com/ is a nice GUI and integrates with BitBucket nicely.
Try running something like Vagrant or Docker to help manage your environments. I use Vagrant with Parallels for local dev, but looking into running it on another box with ESX or something. https://puphpet.com/ is a good starting point.
As others have suggested, Let's Encrypt is awesome - I use it through acmetools.
I saw this a little while ago, it is a very nice collection of tutorials/videos for common server management (mainly Linux stuff) https://serversforhackers.com/
Oh, almost forgot: I hate dealing with email on client servers, it has always been a bane for me. I'm sure there are better ways to handle it, but lately I have defaulted to using Amazon's SES. I made a library that adds some common use-case functionality onto the official libs and do everything that way (when I need to send a user email, etc). I just create an IAM user for the client and away I go, no more dealing with shared hosting mail queues or everything going to spam. We use AWS for other things like Route53, so it ties in nicely. I generally don't trust EC2 too much (had trouble with their EBS), but I am sure it is fine if you know what you're doing. Great customer support too - I accidentally setup MSSQL on their RDS in a desperate attempt to run a copy of a client database and forgot about it when we got another solution working. Ended up costing like $750, but they gave us a full refund and $40 credit towards our other services when I wrote them an "I'm an idiot" email.

You can use git to interact with it, or you can use the web interface (I think) or you can use a client like https://www.sourcetreeapp.com/

Their site can run down the features better than I can. https://bitbucket.org/product/features

Ah, it's pretty easy and worth it for open source projects.

Just use the github for desktop application or sourcetree. You can also just use http access if you don't want submodules so you don't have to bother with ssh (Probably the part you had trouble with).

Something to keep in mind with Git is that it's decentralized, meaning you technically don't need a site like GitHub, BitBucket or GitLab at all. Anything that has Git installed, including your own computer, can serve as a remote repository.

What these sites do offer is mirroring your repository and some nice tools around it.

The GitLab Community Edition can also be hosted on your own servers (if you happen to have a VPS around for instance).

If you really do want to get into Git you could give something like Git from the Bottom Up a read.

You can also uses tools like SourceTree to make starting out with Git a bit easier, but I recommend learning how to use it through the command line eventually anyway.

I generally try making my scripts all generic and not include customer data when it can be avoided.

However there are times when it can't be avoided.

So I setup bonobo git server, works great. I then use source tree app to work with the server. The git server makes use of windows authentication, so nice and easy to control using iis access rules.

The webpage is down at the moment, hope it's not permanent. Download at https://bonobogitserver.com/ good tutorial on how to set it up as well.

Edit: here is a link to source tree app https://www.sourcetreeapp.com/

Also the files are stored where you like and are monitored for changes by the source tree app. When you are ready to commit your changes you can detail what you have done for reference, then upload. Also works great as a backup should your change break the script.

I’ve actually been in the Ruby/Rails world for the past couple years and haven’t done WP/PHP stuff in a while, so I’m not really the best person to ask. But my setup was using the environments I mentioned above (I used both Windows + Mac, and preferred the dev environments linked to). For Git, you can use a GUI like SourceTree if you’re new to it, and this really helps clear up what exactly Git is doing and shows you everything going on (I still depend on a Git GUI after years of using Git).

For deployment, there are many guides such as this one which monitor a branch (in this case, master) and deploy automatically. In general, it’s good practice to treat your master branch as the “production” branch, do your work in dev (or whatever you want to call it), and then just merge as you need to. So you make changes, commit to Git as you work, and whenever the master branch gets updated, it deploys to your site (some people prefer a production branch; it doesn’t matter as long as you decide one branch is the production branch).

Edit: why not FTP for deployment? FTP is OK if you’re the only one working on a server. But Git is essential for teams, has an advanced file history (as well as who did what), and Git has the superior edge over FTP in file collision: Git can automatically detect which lines of code have changed and keep only the updated lines, compared to the heavy-handed FTP approach of simply overwriting entire files or forcing you to compare every file manually (not only a huge time sink, but prone to human error).

I used sourcetree (https://www.sourcetreeapp.com) when I was learning, and found things to be a lot easier after I got used to everything in a GUI. I recommend that and digging through some tutorials.

SVN is dead. Set up a free git account at github.com (if you want your changes to be public) or bitbucket.org (if you don't). Use the super simple https://www.sourcetreeapp.com/ GUI to manage it all.

In addition to versioning, you'll also be protected in case you suffer a hard drive failure / fire / etc.

If you do want to switch away from the bundled Git GUI, but carry on using Git (uploading everything to GitHub or similar) then a few of the clients I'd recommend looking at are:

GitHub Desktop (developed by the GitHub team)
SourceTree
TortoiseGIT (for a more bare bones wrapper)

For newer Git users I'd pretty much always recommend GitHub Dekstop (especially for those who are using GitHub as their host).

Another popular visual tool is source tree. https://www.sourcetreeapp.com/ I prefer it over gitkraken. Though I generally prefer either over the things that come build into editors these days. I use way too many editors to learn how to use their source management tools independently.

For beginners though I always recommend learning how to use the command line and only using the visual tools to verify what's happening and help with understanding.

Some of Git remote repositories may have feature that you can drag & drop your files to repository by web panel and it allows to do changes in files, BUT IMHO it's not so comfortable and fast. Or you should wait for Github Codespaces editor integration that comes in Q2 2021, where you can write your code by web.

To start with local Git repositories, as here was mentioned, you can use GUI applications like Sourcetree to do it without command line commands.

Also, to have easy start with Git in command line, check the simple guide of Git and simple Git cheat sheet.

Worst case scenario, make a new solution and use the "Add > Existing File" (shift + alt + a) to solution function to re-add all your source files. Hopefully you haven't configured too many file properties (e.g. Build Action: Embedded Resource, etc.) so this won't be too painful.

Otherwise, this may be a good lesson to encourage you to start using Version Control like git + source tree. Here you could have simply done the commands:

git clean -fdx git reset --hard

And it would have dropped back to your latest saved commit (last snapshot of source files). In the case where you have a catastrophic failure of your local environment (someone drops your laptop into the sea), you can simply make a pull request to your remote repository and be back on your feet in seconds.

I use CLI most of the time, but when I am cleaning up branches that have been merged I usually use Sourcetree (https://www.sourcetreeapp.com/) to cleanup the local and remote branches.

Flask is what I was going to recommend because you really only need 1 view, a view for when the user is redirected from yahoo back to your site with the verification code. Verify it in the view and then the template can just say Successful.

If you ever wanted to see what I'm talking about in action, I remembered what program stood out as using it in the best way. SourceTree is what I use for all things git and if you go to Authentication in Options and add or refresh an existing account, look at the browsers url when you're redirected back and sourcetree says successful.

Tangent re the "get on the command line" idea: I like to start people off on https://www.sourcetreeapp.com/ (I'm not affiliated with it) It has a nice UI, having the tree right there can help understanding what's going on until you just have it in your head, and unique among the Git UIs I've tried it can show the commands you've been running (the "show command history" option)

I use a mix of Command Line + Source Tree (https://www.sourcetreeapp.com)

I mostly use source tree for verifying changes, commits, pull, push.
Command line for force push, rebase, interactive rebase.

I don't use IDE to source management. But I quiet often use Timeline option on VSCode to figure out what changes happened on the file and what exactly changed in each commit in the past.

Example from one of my side-project - https://imgur.com/EwftavH

There are git GUI tools that you can use that makes visualizing the changes easier. Atlassian has one called Sourcetree.

https://www.sourcetreeapp.com/

I found that once I was able to see how it works, using simple git commands wasn't as hard to understand.

I noticed that it's better not to use IDE for git commits and repo management, because it's easier to migrate to another tech.

Recently I switched to the external client - Sourcetree https://www.sourcetreeapp.com/

but I also want to check Fork https://git-fork.com/

I'd never get anything done if I didn't take screenshots (and make a lot of Git commits on a development branch) to remind me what I was doing. SourceTree works wonders for seeing differences between my many commits (I then squash merge a dev branch into the master branch when I'm ready).

You're talking about Git, not Github. Github is a completely unaffiliated website which offers free/tiered hosting of Git repositories.

For a GUI, Sourcetree is a fantastic option.

I recommend you understand the basic concepts of source control. Like, what a repository is, how the structure of commits and branches works, and what it means to push and pull commits. Then you can find supplementary material to show how to work with those concepts on either CLI or the GUI of your choice. It's understanding these fundamental concepts that will trip you up more than anything.

Also, I highly recommend that even if you plan on only using a GUI, that you learn most of the CLI commands as well. I find that a GUI works great for most of my daily needs, but when I have to do something more complicated or fix a mess, it's CLI all the way.

You should have your own source control that you administrate, you don't give your clients access to that, there would be a branch structure that suits the way you run your business.

For my personal work projects I've got a master branch that's always up to date, a develop branch that I do all my work in, it then gets merged into master as the source of truth.

The methodology I follow is called Git Flow.

I also use SourceTree.

I then have client branches that are a source of truth of their environment. Once their work is complete I'll merge master into their branch and push to the origin, CI/CD processes take over and automatically run testing and deploy to their environment.

Resetting a client branch to a specified point in time is trivial, when I push the reset to the origin it'll rebuild, retest and redeploy.

I've built my workplace DevOps environment in a very similar way which is why I was able to do what I replied before.

You need a project setup on the TFS server to house all your items. When you create a new project you pick the back-end type: TFS or git. This controls the type of source control in use. If you pick git then you can use any git client (from the command line to Atlassian Soyurcetree or others).

Much of the functionality of TFS doesn't apply to you just storing scripts. You don't need to create tasks to track use cases or bugs. You just want to back-end technology as a repository.

You may want to look at using some sort of version control such as Git. Using GitHub and Sourcetree this allows you to basically keep a capability to revert to a previous version if you screw something up.

It has the benefit as well as being able to create "branches" of your master code if you want to try something out without affecting the master build.

If you try something out, like how it works, then you can "merge" the branch back into the master code.

Can also use branches if you bring in another developer, they do their work on the branch and then when ready you merge to the master. This means that you both can be working on something with decreased risk of overwriting each other. This is my primary use now for it.

https://www.youtube.com/watch?v=Yq32Ifx0bXw

I concur with u/techslaves_org - Git is specifically designed for what you're trying to do.

If you have trouble working with the command line version, Atlassian has a fairly nice GUI wrapper called Sourcetree ( https://www.sourcetreeapp.com/ ) which may help you.

After reading Pro Git and learning enough Git at the command line to stay out of too much trouble I started trying out GUIs. In my experience Magit is a really good Git GUI built right into Emacs and SourceTree is a really good git GUI built outside of Emacs. Both work great for different things and I use them both on the same project. Your opinion might matter more when you can give a presentation about the pros and cons of a single Git GUI app before comparing two of them. If you compare them before that then the comparison might come off as less credible and you might be disappointed, and the viewers might feel the same way.

On the other hand some users might enjoy trying Magit right away and that is proof enough so set up an alias that lets them start Magit in the current directory:

alias magit="emacs --no-window-system --no-init-file --load \

~/somestartupcode.el --eval '(progn (magit-status)

And then watch a video playing around with their project.

Either way the best to learn is to have fun, so help them have fun: their time is precious and they will be glad them spent their time listening to what you have to share.

if your staff is at all technical you can try git. This is exactly what version control is built for.

Especially since you only need a single txt file. It's way easier than you think and can even use a GUI like sourcetree

https://try.github.io/

this is the only thing you'll need to do, after setting up accounts and everyone has access to the repo:

only once ever:

git add remote
git add origin

any time you make a change: ``` git pull origin master ... make changes ... git add . git push


with the GUI, like sourcetree, it's even easier. You can branch, go back, keep versions, have releases, see who changed what. literally what git is built for.

Hi,

If you are not familiar with the command line (and tbh I like using this app even though I know the git commands) then use Source Tree. This will allow you to very easily check-in (known as a 'commit' in Git) the files with a comment of what's changed.

You can always just initialize a local git repository in your UE4 project so this is technically not needed, but will be essential if you are collaborating. But make an account on Github which will allow you to 'push' your commited changes to their servers (known as a remote repository) for others to get (known as clone).

Sourcetree has a tutorial you can follow although it uses bitbucket as it's hosting (instead of Github) but the principle is still the same. Infact, iirc BitBucket has free private repositories so it may better suite you.

There are a ton of ways to use git in any project. Everyone goes about it differently. I use WP core in a submodule. We us git flow: https://danielkummer.github.io/git-flow-cheatsheet/

Just google "beginner git workflow for wordpress".

This guy has a good article (quick search): https://torquemag.io/2015/10/beginner-tutorial-use-git-wordpress-development/

I am with him for using sourcetree (whether you are in github or bitbucket, etc). Keeps you out of command line until you understand what's going on. https://www.sourcetreeapp.com/

If you have to do it FTP, still pull it down locally and develop and then push the new theme and DB. Your live site has to be stagnant during this time.

Do you use git CLI or a convenience product? I would say go for tags (but solution #4 isn't bad either, do it a few times before you start copying everything around) but a git client may help drastically in managing branches, tags, merging, etc.

>Git is the most complicated source control solution

I realise that no one wants to have this argument, but WHAT git so ez

I'll give you the git doesnt handle large files thing well, and I'll give you that maybe command line git can be weird when you want to do lots of stuff, but SourceTree + Git = EZ PZ

SourceTree from Atlassian is pretty fantastic in my opinion.
Git in VS Pro is OK, the inline commit info is nice, but last I checked it didn't support git over SSH which is problematic for our use.

git is really good, but you should be aware that it doesn't handle large(r) binary files very well. For an RpgMaker game it's probably fine though - it's not like you have lots of 4096x4096 textures or videos around I guess :)

Anyway, you can also take a look at SourceTree, a really nice Windows client for git.

Practice, practice, practice.

Think of a project idea, however simple or as ambitious you like
Go for it. Run with that idea for as long as you can
If you get stuck, use Google and /r/javahelp to take the idea as far as you can towards completion
If you're totally in over your head and aren't making any progress - don't get frustrated, start a new project. Let the problem simmer in the back of your mind while you improve your skills. You can always come back to it later.

At least 50% of learning to be a good developer is learning how to read documentation and search online for answers.

One other suggestion: start using GitHub and learn how to use Git (either via command line or a GUI like SourceTree or SmartGit). Not only is it a really important and useful skill to learn but it will also give you a really easy way to track how far you've come and let you easily go back to finish old projects.

Bitbucket dev here, my Git LFS unity projects have been solo efforts so far, but I have used LFS to collaborate on Keynote presentations with a couple of marketing folks, who are probably roughly equivalent to artists when it comes to Git aptitude/appetite. I usually contribute directly to the repository via the Git CLI, and then get them to contribute using SourceTree (disclosure: Atlassian maintains SourceTree, but it's free).

SourceTree's good for people more comfortable with a GUI, but it also has top notch support for LFS, because the developer who built SourceTree (Steve Streeting) also happens to be the #2 contributor to the Git LFS project. Git LFS is actually a joint project between Atlassian & GitHub - we actually launched support for LFS on bitbucket.org just last week.

Password protection would be cool, too! Maybe even password protection or user authentication for collaboration on a language? That might be tricky to implement, but it might be cool.

As for "no profile editing/updating capabilities, when you're on your Profile page, it looks like there's a space for an avatar picture and there's no way to edit it. Plus I don't see if/how you can change your email address or password or if you can delete your own languages or account. Those are some important features.

Github is kind of a tricky beast. It requires the use of Git, which is a source control management system for code and puts it on your Github profile publicly. It's where the term "open source" comes from, because anyone can see the source code of your program. Sourcetree makes it a lot more manageable and easier to understand, but you'd still need to learn how to understand what Git is and how it works for it to be helpful. It's kind of a steep learning curve, but if you're gonna do programming work for a while, Git (or some other source control system) is essential.

In addition to what everyone else has said, I find it useful to use a program like SourceTree to visualize all of my git branches and commits.

I do recommend learning the CLI as well though, because sometimes you won't have access to a GUI!

GitHub still may be a good tool for it.

You can edit Markdown files from its web interface.
It displays Jupyter Notebooks.
While Git might be hard to start by non-programmers, tools like https://www.sourcetreeapp.com/ greatly lower the entry barrier.

For small projects I use Git(Hub) for code, but for tasks and description - https://hackpad.com/. There is no need to have everything at GitHub.

Or just use SourceTree. While I know there's a lot of value in knowing the command line usage of git, SourceTree is like gitk on steroids. I haven't touched the cli in months.

SourceTree can do most of what you would want. I don't think there's a graphical UI that does 100% of what Git can do, however. The command line for Git is where all the power (and simplicity, believe it or not) is at.

My recommendation would be to use SoureTree is a short term crutch, but really learn Git from the command line as you can.

What is Reddit's opinion of Sourcetree?
From 3.5 billion Reddit comments

➔ Sourcetree website

By popularity on Reddit, this Service is:

79 reviews of this app found across Reddit:

What is Reddit's opinion of Sourcetree? From 3.5 billion Reddit comments

➔ Sourcetree website

By popularity on Reddit, this Service is:

79 reviews of this app found across Reddit:

What is Reddit's opinion of Sourcetree?
From 3.5 billion Reddit comments