What is Reddit's opinion of GitHub Desktop?

From 3.5 billion Reddit comments

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/

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.

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

Actually that is the release name for v3.0.7 (2015/10/29)

There are some other good ones, check out release notes for a complete list:

• Mac release notes
• Windows release notes
• Linux release notes

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.

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

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.

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.

キーボードランチャーならspotlightで代用できると思う
じゃなかったら、Alfredかな

画像ビューアは標準のプレビューで簡単な編集ならできたりして最強すぎるので他のアプリの必要なし
あとはQuick Look（Finderで選択してスペースキー押す）で動画も見られる

ソース管理はあんまりやらないけどGitHub DesktopとかSourceTreeじゃダメ？

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

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

Here's how I did it:

Install the GitHub desktop app

Go to Greengrove's github page for the filter, click that green Clone or download button, then click Open in Desktop. It'll ask you where to save it, I just created a Github folder and put everything there.

From then on, to get the latest updates just open the github app and press the sync button in the top right. Click on the history tab at the top to go to the history view to see if anything changed.

For the links, I basically just followed this.

After that program is installed, go to that github folder and go to the filter folder. Once you get to the actual filter files, highlight the ones you want, right click and select Pick Link Source. Then go to the PoE folder where you normally paste the filters, and right click and select Drop As > Hardlink. That makes the filter files in the poe folder essentially shortcuts, but ones the game sees as real files. Every time you sync in the github app those files will be updated!

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.

This is a great breakdown. I'm not sure why you don't want to use git; a VCS is an important thing to learn in contexts like this, and git is the most widely used. If you're intimidated by the command line interface (CLI), you could instead use an application like GitHub Desktop for a graphical user interface. Any of the alternatives above would suffice, as well.

In my experience, Godot is one of the easiest game engines to use git with. All code and level files can be saved as text (*.tscn, vs *.scn), and thus can be versioned.

As mentioned above, you don't have to use a VCS, especially with few collaborators. However, it protects you in a lot of circumstances. I use git even when I'm developing solo.

I agree with the others, knowing Git is really helpful but not critical at the beginning.

If you want, you can start out with a GUI client for GitHub or GitLab. There's an official GitHub client for Windows which is pretty easy to use, if you'd like to start putting your code online even before you know Git, and it can help you get familiar even with the console commands.

My recommendation: Dropbox (or Google Drive) is the easiest. Git, if you want full revision history for your notes (incidentally, my upcoming web app Cerveau uses Git as well).

Before I start, I must ask why GitHub for this kind of task? I might be missing something, but I feel like a shared Google Drive folder or another simpler file sharing service might be easier to setup and maintain rather than GitHub.

Full disclosure; just a uni student with a little experience with Git on Windows so forgive me if I don't know everything you may want to know. From your previous comment, you mentioned you have no experience with Git so I'll try and do my best to get you set up, but as for maintaining a public repository I don't have too much experience with so you'll have to do some more digging.

To start a GitHub repository;

1. Download Git to your PC. I'd also recommend downloading a Git GUI if you don't have much experience using console commands (I recommend GitHub Desktop)
2. Make a GitHub account, and create a new repository (If you're using GitHub Desktop, click on File > New Repository. If you're on GitHub.com, click on the green 'New' button once you login).
3. Name the repository what you wish. You can add a description if you want. Make sure the repository privacy is set to Public! I would also check the box that says 'Initialize this repository with a README'. I'm not sure if there are any licensing laws governing what you are doing, but if there are make sure to select the license you need from the License dropdown or add your custom license later. Once everything's done, click Create Repository.

You should be all set up now. Share the GitHub link to those that might want to contribute.

I'd recommend using Git on the command line or GitHub Desktop. The website upload is useful for small changes but for large projects, you need to be using Git. I fear you'll go wrong otherwise :)

Here's a good guide for initiating and pushing a repository to GitHub on the command line:

https://help.github.com/en/articles/adding-an-existing-project-to-github-using-the-command-line

Or use GitHub Desktop, which is a GUI for Git:

https://desktop.github.com/

1. "Open Source" is about the licence you choose to use - not where it's hosted. You could put your code on any web site you want and make it open source. It's about assigning copyright not about using a particular hosting platform.

2. Probably the easiest way to publish code to Github is via the Github Desktop app: https://desktop.github.com/ although there is a Unity plugin too: https://unity.github.com/

I've tried using Git through Visual Studio itself like... once, and it was a bit of a challenge. The advantage is that Visual Studio is aware of where you are in your repository, and you can move back and forth through it from inside VS.

I find the actual GitHub desktop app much more intuitive. You may wish to give it a try: https://desktop.github.com/

Once you fundamentally are comfortable with GitHub and how it works, it'll be much easier for you to try to contend with Visual Studio's integration with it. Eventually you will want to commit to GitHub every time you make changes, and you will end up referring back to GitHub to see what you did and when.

Some advice: 1. Play with a folder that is NOT your only copy of your project until you know how to use source control. Make backups. Git controls what version of your software is actually in the folder, and you can undo your project if you aren't careful. In my case, I actually copy my code into my Git folder on my PC, the one I work with in Visual Studio is different. (On my tablet though, I work directly in my Git folder.) 2. Make sure you do NOT commit any passwords or 'secrets' to your GitHub repository. This requires you use good practices like not including passwords in your source code to begin with. ;)

This is my project as an example: https://github.com/ocdtrekkie/HAController and you can see each time I committed changes here: https://github.com/ocdtrekkie/HAController/commits/master

Se non hai voglia di sbatterti con la linea di comando, il client grafico di GitHub è banalissimo da usare e supporta repository privati e branch, che assieme alle pull request dovrebbero bastarti per un progetto universitario. Quando sono su Windows dove il terminale è pessimo uso solo questo.

No, they made an actual user interface that makes sense (which, to me, they should've done from the start).

https://desktop.github.com/

This hits home for me and I am very much used to terminals professionally: https://image.slidesharecdn.com/giten-161104194008/95/git-fail-force-make-it-up-with-your-pull-requests-10-638.jpg?cb=1484319427

> The fact that both mechanisms require a wrench doesn't change the fact that one stores the wrench for future use.

You're right, of course. And reading over my previous comment, I did sort of gloss over that point. But I think at the end of the day, your argument boils down to "don't use CredSSP because there's no Restricted Admin Mode equivalent." And if that's your argument, then I guess you would also argue that no organization should be comfortable using a normal RDP implementation (i.e. without Restricted Admin Mode), which I feel might be a little extreme in a lot of scenarios where teams can trust their endpoints.

> why not use Start-Job -Credential instead?

Maybe I just haven't had enough coffee yet today, but I can't see how Start-Job is actually capable of "Run As Administrator" if you're not already using it in a shell that was "Run As Administrator".

> What is this function that cannot be run as an administrator?

It wasn't the function specifically, it was the GitHub Desktop installer that was downloaded and installed as part of the function:

https://github-windows.s3.amazonaws.com/GitHubSetup.exe

However, it looks like there is a new installer available now on the main site (https://desktop.github.com/), so I'm not sure if it'll still refuse to install if you "Run As Administrator" (also it looks like there's an msi available now too). So the specific problem that inspired the PowerShell Sudo solution may no longer be present (I don't know, I haven't tested the new GitHub Desktop installer), but that by no means invalidates the solution itself. A similar problem could arise in the future with a different installer.

Are you developing on Windows? Github for Windows does a great job abstracting out git commands, and makes it easy to get it in a Github repo without having to remember any git commands.

1) Make an account in Github.

2) Download the Github desktop client. (It's possible to use the git command line client, but the desktop client is easier to work with.)

3) Make a fork of the spni repository (click on the fork button on the top-right corner of the web page).

4) Download your fork using the Github desktop client. Your fork's page will have a "clone or download" button, click on that then "open in github desktop".

5) The desktop client will ask you to save the repository somewhere on your computer.

6) Make your changes to the downloaded version of the repository. (You can just copy/paste your new files in here. Remember to change the listing.xml file to add your character.)

7) In the desktop client, click on the "changes" tab up the top.

8) The panel on the left should list all the files you've added, removed, or changed. Make sure all your character changes are selected. (All the changes are selected by default, so you should be OK.)

9) Fill out the boxes on the bottom of the side panel, and click the "commit" button.

10) Wait for that to finish. It can take a while, particularly when adding images.

11) Along the grey bar across the top, click on the arrow in the top-left corner, and select "spni/master". You might need to type it into the search bar that appears.

12) In the top-right corner, click on "Pull Request".

13) Fill the boxes out here, and click on "Send Pull Request". This can also take a while, especially when uploading images.

14) Tell me or /u/josephkantel about it, so we can take a look at it and add the changes to the game.

Let me know if you have any issues or questions about it.

In terms of how to use Github, I suggest you start by reading this.

http://readwrite.com/2013/09/30/understanding-github-a-journey-for-beginners-part-1/

It gives you an explanation of both Github and git, so that you can look at where you want to go from there.

Ignore the parts that teach you how to use Git with the command line unless you want to work primarily with the command line. That article was probably written before Github created a desktop client that you can make changes from.

In terms of contributing, you can edit code from the github webpage, or sync file changes from a git client or the github desktop app. You can also post issues on the github website for mapping out what needs to be done or reporting bugs or offering suggestions. Kinda like a message board.

Github also offers an internal wiki, and github hosted webpage that you can edit from github, should you want to use it.

Here's the github desktop app, should you prefer a GUI over a terminal or command prompt commands. Or don't have a preexisting application with git support that you've somehow modified to work with a byond project.

https://desktop.github.com/

https://help.github.com/desktop/guides/

You'll need to create an account on Github first.

Once you're logged in. Click the Fork button in the repository. The website will guide you through creating your own fork, which means a copy of the repository - you need your own copy because you don't have write permissions on the original one.

At this point you'll need a git client. Github provide their own with a nice user interface so that would be the simplest option - you will see your repository as soon as you log in to it.

You will have to download the repository somewhere to your computer. Do whatever changes that you like and then Commit them. There should be a Commit button somewhere in the interface, it will show you a summary of the changes you've made and ask you to comment on them.

Once that's done, you can push your commit to Github. Their client has a big Sync button for this purpose if I remember correctly.

At this point you have your update on your own copy of the repository on Github - now you want to send those changes to the original one. You do that by creating a Pull Request. There is a button to do it on the website and I believe also in the client.

It will again show a summary of your changes, similarly to when you were doing a commit, in fact you will see that commit on the page. You can write some message and create the request.

Now the only thing that's left is for the owner of the original repository to look at your changes and accept them if they are good.

This covers the minimal scenario of using Github to share a few changes. I haven't covered how to keep your fork updated for example - that's pulling latest changes to your copy of the repository from the original one - something you would have to do if you want to contribute over a longer period of time.

You can PM me with questions if you like.

umm, maybe they show that if you don't have any repos?

Let's try this : go create a new project and select the 'initialize directory with a readme.md'

http://imgur.com/a/JaJNB

If you can do that and get a view like the 2nd image you should be ok. You will likely have to delete the your_name.github.io project (go to settings > delete repo), it'll prompt for name, enter it and then click delete. Remake the project with that option selected.

If it doesn't work. You will have to grab a git client but it isn't that hard to do with a desktop program. https://desktop.github.com/

Did you configure Git locally or do you use web interface? As far as I know, there is no possibility to upload files via web interface. Therefore you have to set up Git at your computer.

If you prefer graphical user interface, check out GitHub Desktop. If you prefer CLI, check out this GitHub help page.

You can try GitHub Desktop which is a very very easy to use GitHub/Git client.

​

You can obviously use non version control syncing software like Syncthing but its just wrong in so many levels to use for Flutter projects.

Whelp, unless you had copies of the sprites (like if you manually kept a folder of PNG files or something somewhere outside of your project files) or are using some flavor of source control (if you aren't, I'd recommend getting familiar with GitHub Desktop right now), the original versions of those sprites are most likely unrecoverable at this point. In my experience, when you you resize sprites in the sprite editor or edit them in the image editor, GameMaker saves over the PNGs in the project files.

It looks like it works! At least, the error no longer shows. The git-unfamiliar link in particular is super helpful.

Could I ask two more clarifying questions?

1. From a non-tech-person's perspective, does the Obsidian Git plugin eliminate the need to bother with this much more technical walkthrough? (It's linked to in the plugin's about page)
2. GitHub Desktop and Git-SCM seem to be functionally very similar..... is the desktop app just a more visually-friendly but limited version of Git-scm?

Make sure your OS and hardware drivers and stuff are all on stable versions and make sure to setup some sort of version control to make sure that if something does crash, stuff is still recoverable.

The usual advice is some combination of backups and version control.

Also, don't try to run projects directly from cloud storage. Always copy/pull to local storage. I've seen a weirdly high number of people corrupt projects by running them directly out of OneDrive/Dropbox folders over the last two years or so.

Hi! It certainly does have a steep learning curve! I found reading some of the Atlassian documentation related to Git and different approaches to branches helpful. You can find those helpful articles here: https://www.atlassian.com/git/tutorials/comparing-workflows/feature-branch-workflow

If you want a GUI, try Git Desktop: https://desktop.github.com/

Good luck and getting hands on is key!

But as I said there're many different GUI tools to connect to a Git repository if you don't want to deal with command line. Here is a list (I just discovered Github Desktop I didn't even know there was an official Github client now

It's people that try to run the project from a cloud folder that tend to run into problems. Download a local copy to work on and then copy whatever you worked on back to the cloud.

That being said, it takes maybe a few minutes to get setup to use GitHub repos with GithHub desktop.

If you're new to Github I highly recommend getting Github Desktop: https://desktop.github.com/

It's a easy-to-use GUI for Git and makes the process a lot easier for people with less experience

For the non-pipeline part

Export measures as text: https://docs.tabulareditor.com/Useful-script-snippets.html#generating-documentation

Export PQ as text: select all queries -> copy Then paste into an editor. It's everything in one paste.

using git

This is a nice client to get started with git without having to know the commandline

https://desktop.github.com/

Quick steps is to download github desktop, log in and create the project there with Add>Create New Repository, and select the existing arduino project folder.

Once it's there, you'll see all your files haven't been added yet to the git repository. Press the green [+] on each file/folder, then enter a quick summary and optional description and press "Commit", then push repository menu->push.

I am guessing you are referring to making folders inside github web, to do that, you could do that by going to Add File -> Create New File and you can write your file path name like this:

{ repo name } / "folder1/test.html".
And the input is the one in quotes.

But, usually github is used with a tool called git, and there it is much easier to add files to your github repostirory.

You can try using Github Desktop

You can / should look into Git for saving your project at different stages safely.

Easiest way is using the GitHub Desktop client on Windows or MacOS : https://desktop.github.com/

This will store the code part of your app, you should not store your database in it. You can store requirements via a requirements.txt file or a pipfile using pipenv.

LBRY version here
song featured: Jimmy Fontanez - Floaters (YouTube Audio Library)

SOURCE CODE / THIS GODOT PROJECT AVAILABLE TO DOWNLOAD yESS. GNU GPL v3

Use GitHub Desktop to easily download source codes from Git repositories

Size: 3.5 GB (don't judge. sorry. I've got alot of stuff here. I'll clean whatever Godot won't load and leave the export that Godot can load.)

​

I'm sorry. I'm a bad person. Please, don't scronch me. I'm sorry.

It's actually super easy if you use GitHub Desktop.

You don't need to learn any of the command line stuff, the idea is you create a new "repository" (a folder) which contains your notes. When those notes are updated, you can "commit" (save) your notes, and then you "push" them to be stored in the cloud.

There's some solid getting started documentation here.

You'll want to do some searching on Version Control.

Personally, I recommend looking into GitHub using their desktop client. There are plenty of tutorials around the web that explain what git is and how to use GitHub.

TL:DR you don't need CMake and git submodule, just download the source files (*.h and *.c) and add them to your project

First, don't be afraid of git and github. Git is a tool used for code versioning. In your case, we do not care. Github is a website that host code written by other people and versioned with git. In order to get the code on your computer, you should install the git software on your computer. I used to recommend https://desktop.github.com/ for people not used with git.

Once the tool install what you want to do with it is downloading the project on your computer. Notice that you can also download the project as a zip archive. In the git world, downloading is called clone, so you might need to look for the cloning option in github destkop.

Now you should have the files on your computer. From what I read from the project, the only thing you need to do is add all the source files to your project in Atmel Studio 7 (I don't know how to do it, i never used it). Once you have added those files in the project, the IDE might be able to compile them as they do not require any specific treatment.

The submodule thing is a bit confusing. Actually this project is only a smaller part of a bigger project. If you want to use git and add it to your project (repository) with version tracking you will use git submodules. Now, I doubt that you will need this at all, so just ignore it.

Yep you have an ALC294, you can see a list of layouts from AppleALC for your codec here https://github.com/acidanthera/AppleALC/blob/master/Resources/ALC294/Info.plist I think 28 is going to work best since that seems to be closest to your laptop.

Is this the guide you mentioned you looked at? https://dortania.github.io/OpenCore-Desktop-Guide/post-install/audio Also, can you send me youur IOReg? (you can download it from the previous link, File -> Save, upload it to your favorite file sharing site)

By the way, you may want to look up a git/hub tutorial. I recommend using Github Desktop if you are new to git. The idea with git is that you can track changes to individual files, you should copy your entire EFI folder to your git repo instead of compressing it to a single file. When you make changes that work, commit those changes to the GitHub repo so you have working stages to fallback to and go further back if you need to see why something stopped working

I highly recommend you learn how to use Git. GitHub has a very simple desktop app that you can use. It makes sharing unity projects super easy with just the click of a button.

Did you try to download and install Git from the official website?

https://git-scm.com/

After that, you should be able to access git through Powershell using:

git <whatever command you want>

Here is documentation for the commands: https://git-scm.com/docs

Or if you just want to clone a git repo manually yourself, maybe use this GUI application: https://desktop.github.com/

> i use website to upload

There's your problem right there. Uploading via the website is ok for quick hacks but it's not actually using Git properly.

May I suggest https://desktop.github.com/

My grandma has backups. You're a developer. You should have had on-site AND off-site backs AND been using a version control system.

Here:

https://www.backblaze.com/

https://desktop.github.com/

github desktop if you are more of a UI user than a CLI user https://desktop.github.com/
then as /r/nicolaerio says you still need to understand the fundamentals but this makes it drag and drop same as Dropbox.

GitHub Pages would be the quickest, easiest and you don't have to pay for it. Just commit a static page. If you know basic HTML and CSS then it would only be a little challenging to use something like https://desktop.github.com/

The thing you have to realize is that command-line tools are very much expert-level interfaces. High performance at the expense of a high learning cost. This is something software developers who seek command line tools over WYSIWYG want and expect. They don’t want to touch the mouse.

A good way to feel this difference is to look at the arcane inputs of regular expressions, which I had to learn to start doing some property clipping in Mixpanel. Another good thing to look at is using Git from the command-line versus GitHub’s Desktop GUI that they offer. I personally can’t use Git without something like this, but I’m not using the advanced features of Git.

If this is for developers, I would take the short, succinct style as a constraint in your design since this is the existing convention. I’d definitely want to get some feedback from developers about the command words that they would use to execute certain types of actions. There are definitely conventions in how CLIs work, even if they feel unnecessarily arcane from a UX perspective.

Note also that when you type in something like “npm” a short list of commands appears. That’s where I think a UX perspective can be really helpful. What are the most common commands? What order should they be presented? What are logical groupings of commands?

There’s not much thought and care about developer UX. Usually developers have to write their own intermediate tools to make these experiences work better (homebrew is a great example, solving for easier installation of libraries with nested dependencies). I hope you can share your experience when you are done, because I’d love to learn what you find!

It's not a language, it's a tool. You can control the tool via command line, is that what you mean? The basics of git on the command line consists of maybe 4-6 commands.

If you really, really don't want to learn text commands, then yes you can use a GUI. GitHub even has its own official desktop app. But if you're making websites and learning Python, I can't imagine you'd have difficulty learning 4-6 text commands.

Those commands are for a Unix-like shell, e.g. Linux, Mac...

I'm not that familiar with Windows, but I think you can either install the bash shell for Windows and use the commands as they're written, or install a Git GUI like GitHub Desktop or one of the others and click buttons to install the thing.

Can you please elaborate on that. E.g on Github or which part of the development is troublesome?

https://desktop.github.com/ might be a helpful link for cloning a GitHub repository so that you can easily get the newest marlin versions.

To get you started:

1. GitHub has its own graphical interface to Git, which is supposed to simplify working with Git https://desktop.github.com/ .
2. There's a GUI program bundled with typical Git install, accessible through command line as git gui.

Neither is a great way to use Git, but they are decent ways to have a reference point, to start asking questions: you can try doing something using one of these programs, encounter a problem, and then ask a more specific question about the problem.

Alright you need to install git and make a repo and an initial commit to get the code into git.

After that you need to make a github account and a repository there.

Then you make a keypair on your computer and store the public key in the github repository. This will give you privilege to push your code to github.

Then you add github as a remote repository to your git config on your computer.

Then you push it.

There's apparently a github desktop client which might make the entire process almost automatic so you should probably start from there. I haven't tried it myself, though, but I'm happy to help if you have questions.

I recommend you start with some test code and try with that first so you don't accidentally the Dragon_Quest code.

I suggest that all writer have a look into Git. It's primarily used so that programmers can backup their code, keep track of changes, try new things without affecting their code, and revert back.

One thing code has in common with writing, is that they're basically the same thing... Plaintext.

I recommend that every writer who is writing in plaintext use something like Github, and Git Desktop.

• Download and install git.
• If you're on Windows, and not using terminal, a simple program to use is GitHub Desktop.
• Login to your account.
• Create your repository on GitHub (I think you can also do this in client, but haven't used it in a while).
• Clone/download your repository to computer using GitHub Desktop client.
• Make any change in that directory, like create your file, edit it to your liking etc.
• Go back to desktop client, commit, push.
• If you make any change online (not through client), you must first pull.
• Rinse and repeat.

>When and how do I show my work on GitHub

The "when" part is pretty much up to you. GitHub is a combination of source control and a social network. But the Source Control part is the most important. The social aspect is mostly a side note at the beginning.

As to "how", I guess I don't know if you mean "how do I start using GitHub in general" or if you're asking "how do I use GitHub's Pages feature to serve my sites?"

I would say: at least at first, don't worry too much about learning how to use Git from the command line; you can use tools like Github Desktop to simplify your life.

Check out the sidebar for good books. If you haven't already, get using git, right now. If you're on windows, this is my favorite client. ( https://desktop.github.com/ )

I learned how to use git on the command line, which is useful in learning how it works. But for daily work, I use a client.

My other suggestion is to pick a basic program to write. If you're interested in games, you could make a console based game. (That way you don't have to learn an API at the same time.

The easiest way is to use GitHub Desktop It's as simple as write a title, commit and push.

It's essentially like a Dropbox folder but instead of automatically syncing you have to manually push/pull. And you have a version history which shows the changes of every file and every commit.

Would be good to describe what seems unintuitive. As a git expert, I still think remote -v is unintuitive (probably other commands too).

At first, just commit everything (git commit -am"what you changed here"). Later, you can learn all the other commands, and staging, and log pickaxe, and so on.

You can also get a lot out of git using tools: in your editor via plugins or standalone like Github Desktop (which feels like it's built for beginners).

sure you can just create a zip and put it on pastebin, I'll put your stuff on the mechenginemod repository. just create an account (tell me your account name there), install https://desktop.github.com/ and then connect to my repo which I will give you full access too. there are also alternatives on how to work but thats easiest for a newcomer for now.

Actually, if you feel up to it, you could use git directly to push your changes to github (git clone my repo, incorporate your changed into the clone, git commit and git push).

That looks interesting, I'll have to give it a shot.

My go-to terminal in Linux has always been 'guake' but that's not working -yet.

Speaking of electron, I may have to try out the nix candidate for GitHub Desktop in a container, it works well in my crouton chroots.

Are you on Windows, Linux or Mac? The instructions are generic enough to work with them all, but it is instructing you to enter that info on the command line in the terminal. You open a terminal window and then change directory into the folder where you want to put the download. I think Windows will open a terminal with WIN+X.

But I am a fan of Github Desktop There seems to only be binaries for Windows and MacOS. It will let you choose your download folder and the repository. the repository is https://github.com/qmk/qmk_firmware.git and the folder is of your choosing. You could also just get it all as a ZIP file... but then you can not update it later.

Have you installed the build tools yet? That should be done first. If so, the instructions for getting GIT should have made sense. Where are you at with using the command line?

Take a look at GitHub Desktop -- I've been using SourcreTree as well, but felt that it's becoming slower and buggier with each release, so GitHub Desktop is my choice right now. Don't be mistaken, it does work with any remote, not just with GitHub, and it's also free.

Yup, as exodian95 says you're stuck with trying to find a backup and restore from that.

While we're here, this is the perfect time to talk to you about version control. Look into using Git to track your changes, then you'd be able to revert to any point in a file's history with ease. If typing arcane commands isn't your thing there's always the Github Desktop client. Despite the name, it can be used with non-Github repositories.

GitHub calls this electron app "the new native" on https://desktop.github.com. But the app does not look or feel native. It has an active appearance even when it's in the background, content lags the window frame during resize, menu items are enabled even when they don't apply or work, some buttons with the default appearance don't respond to return, you can't drag and drop text, many context menus are broken, rubber band scrolling doesn't work, the title bar text is absent, selection modifier keys don't work properly...

If native is to mean anything, it can't mean this. Calling it "the new native" is an affront, because its UI regresses in so many places relative to real native apps.

Always need more help in adding more thumbnails!

1. Install GitHub https://desktop.github.com
2. Get the repository https://github.com/libretro/libretro-thumbnails
3. See which ones are missing https://github.com/RobLoach/libretro-thumbnails-check/tree/master/out
4. Add the new thumbnails for those that are missing :-)

1. Make a github account.
2. Click "New Repository". (Name it)
3. Get Github Desktop
4. Log into it with your account info.
5. It will have a tutorial repo (right-click it -> remove)
6. Click the +, Clone, select the repo you made, Click Clone (check icon)
7. Select where you want it, wait till its done.
8. Copy all your code into the new directory.
9. Click "Changes", fill out the summary and desc then commit (check icon)
10. Click Sync.

Done. Its now on Github.

Now whenever you edit it all you have to do is go to changes, fill out the form to describe you changes, commit, and Sync.

I recommend learning version tagging that way when everything is working you can give it a version number and github will create a release for you (By zipping the current repo and putting it aside)

I personally think the easiest way would be to have a main Python script that calls other scripts. I personally think the "cleanest" style would be to have individual functions in each of the individual script files, and then have your "main Python script" take in the user input and import the relevant functions from the other files (which would entail rewriting the non-Python scripts in Python). However, you can call Perl scripts and run R code directly within Python if you don't feel like rewriting

GitHub sounds like a good plan for keeping your stuff organized and for revision control / collaboration. You can use command line git, or if you have Windows/Mac, you can use GitHub Desktop to manage all the git stuff via a pretty GUI

If you want to start with git, a desktop client like the Github app - https://desktop.github.com - might help to get started.

My judgement may be off though, I'm a programmer and do like the git command line. I think everyone will have to fall back to the command line git at some point, but at first it's a bit overwhelming.

*sigh* okay now I'm not exactly familiar with Git but what you got there is a simple code snippet, the site was even kind enough to lay out the URL and project names for you.

> Step 1, install Git for Windows, the text on the grey boxes is a bunch of commands to run on the project folder from the Git Bash terminal or whatever terminal you prefer for that if you have such a setup.

> Step 2, run the aforementioned commands, specifically those from the "create a new repository" section in order, make sure you're running them on the project's folder, nobody wants to see a repo made out of some guy's root folder or something.

> Step 3, expect something else to be done.

> Step 4, realize there's nothing else to do and you're done, that was literally it.

> Step 5, reflect on your life decisions, maybe get a milkshake or something while you're at it with all the spare time you thought you'd be spending on something like this.

Alternatively, be a scrub and use the desktop GUI

It sounds like you have it all setup.

With the GitHub Desktop app installed on each computer, all you need to do is sync the local repo and select the branch you want to work on every time you start and end work on each computer.

Keeping a Git repository in sync is a manual process. It does not work like Google Drive or Dropbox sync client.

The one thing that could really help you is to make sure you have the "Automatically Sync after Committing" option enabled in the GitHub desktop client on all computers. That option can be enabled under the "Edit" menu item.

This will combine the commit and sync into a "one-button" process and prevents you from forgetting to push your committed local changes back to GitHub.

The process of working with a git repo takes a little more discipline and mindfulness. It's not automatic, but the GitHub Desktop app makes it easy once you have the "Automatically Sync after Committing" option enabled.

You might want to check out the GUI clients by either Github or Atlassian. They're significantly better than the official git gui and make it easy to use, even for beginners. I've had a lot of luck with it.

Downside is that it's Windows+Mac only and you'll have to use either Github or Bitbucket. The latter is free for private repos too.

I don't think there's any Git integration like Pycharm has. However, Git is really a versatile tool that works to manage versioning for any type of file. So you could easily create a Git repository in the directory where you have your .ipynb files and commit them to a repository hosted on Github. You'd have to learn how to use either a) The git command-line tool or b) A graphical client like Github Desktop

If you're planning on using GitHub they have a nice desktop app for Windows and Mac.

FWIW the CLI version of Git is better than any other cli I've used--I forget to do stuff all the time and it is very good at reminding you, for instance when the remote branch is newer than your local one, when automatic merging will work, etc. For instance:

Mistyped command:

$ git aad src/ git: 'aad' is not a git command. See 'git --help'.

Did you mean this? add

Commit with nothing changed:

$ git commit On branch master Your branch is up-to-date with 'origin/master'.

Changes not staged for commit: modified: src/index.html modified: src/pages/track.html

no changes added to commit

My previous experience was with SVN which totally sucked in those regards.

Cheers!

There are many graphical applications that handle pushing your files to a version control repository. GitHub's own desktop app (https://desktop.github.com/) makes it just about as easy as dragging files from one folder to another (but less error-prone).