GitHub Pages only supports hosting static pages. Flask is used for making dynamic web applications, where Flask acts as the "back end" for the website. If you want to host a custom Flask application, I'd recommend Heroku, which can interact with your build environment much the way you would with GitHub Pages.

Is it really any different than?

"Microsoft employee installs Chrome mid-presentation because Edge keeps crashing"

https://thenextweb.com/microsoft/2017/10/30/microsoft-engineer-chrome-edge-google/

Github hosts a git repository. Git is a source code management tool which tracks changes on a project over time. When you download that zip from github you're downloading the entire project and all of its history. Using git you can locally checkout different parts of the projects history.

It's a pretty basic command, so I imagine you don't have a ton of experience with git. Here's a book that you can read online for free that can give you a decently comprehensive understanding if you're interested: https://git-scm.com/book/en/v2

Considering a move.

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

Hey there...

If you only need a Twitter account to automatically reply to certain tweets and you really have no idea how to code, then you might be better off with something like https://ifttt.com

Coding a Twitter not is not complicated but it does require a little bit of familiarity. If you want to learn how to code one, you'll need to decide what language you want to learn and after that you'll find multiple resources online.

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

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

2. Create a new empty repository.

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

4. Clone your empty repository to your computer.

5. Move your files into the cloned folder.

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

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

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

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

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.

Sounds like you're looking for git submodules: https://git-scm.com/book/en/v2/Git-Tools-Submodules

And yes it's probably a good idea to have separate repository for each client as nested submodules can lead to issues in my experience.

The "best" way to normally do this would be to use Orgs, but seeing as it's your code for separate clients. That doesn't work too well here.

You would need to download the Git program or the Github Desktop app. Git is a command line tool that runs in the terminal while Github Desktop is a GUI program. You can download git for windows here: https://git-scm.com/download/win. On macOS, git should come with Xcode tools and on Linux, u can download git from the repos if it isn't preinstalled.

However, if u don't want to install git, you can always download zip files from the Github website as well.

I don't use Macs, but it looks like you'll need https://brew.sh/ to get started.

The instructions in the repo;

> Install SFML and the SFML-headers (libsfml-dev or similar) as well as libusb-1.0.0 and the headers (libusb-1.0.0-dev). Then, simple do ./autogen.sh && ./configure && make .

could be expanded to

1. Find and install SFML
2. Find and install SFML-headers (looks like 'libsfml-dev')
3. Find and install something (looks like 'libusb-1.0.0')
4. Find and install something's headers (looks like 'libusb-1.0.0-dev')
5. Open a Terminal at the project location
6. Run the command `./autogen.sh
7. Run the command `./configure
8. Run the command make .

Homebrew is a command line application that will help you find and install things.

A feature/tip that will be very valuable here is 'tab completion'. If you hit the tab key while using the command line (terminal, prompt, w/e you want to call it) it will try to finish your thought. For example, the command to delete a file is rm, and it's followed by the name of the file you want to delete: rm fileWithALongNameThatIMadeForADeleteExample.txt [ENTER]. That's a lot of typing. We can take a shortcut; rm fileWith [TAB]. The prompt will complete the command, and if you like it, you can hit enter. If you hit tab again, it will cycle through the list of possible completions; fileWithALongNameThatIMadeForAnotherExample.txt? [TAB] fileWithAShortName.txt? [TAB] etc

The way this applies to your current situation is that you can tab complete hombrew's command; brew install libsfm [TAB], and you can cycle through and see your various options.

I hope this helps.

git saves locally, it was designed primarily for offline use. There's a .git folder in the repository's root that holds (technically, can generate) each version of each file. Pushing and pulling just adds to the .git folder- either your local one or the repo one. Every copy of the repo has every version ever committed.

It's not so hard to revert, or 'reset', to an older version.

Example:

• Client asks for blue website

  edit
  git commit -m "Made site blue"

• Client asks for red website

  edit
  git commit -m "Made site red"

• Client wants blue again

  git branch red git checkout master git reset --hard HEAD~1

First you committed a blue site, then you committed a red site. Then you created a branch called 'red' based on the current commit- a red site. Then you made sure you were on the master branch. Finally you reset the master branch to the commit that was blue.

Without connecting online you've successfully reverted, or 'reset', to an older version.

HEAD~1 means one version previous to current on this branch. You could also specify a the hash, tag, or branch of the version you want to reset to (c090e08021ef68360ab73ad99353d0686a164058, tagname, or branchname).

More reading: http://git-scm.com/docs/git-reset
http://stackoverflow.com/questions/1616957/how-do-you-roll-back-reset-a-git-repository-to-a-particular-commit

To add to the other commenter's suggestions, if you want to get an even deeper knowledge of git, check out the Pro Git book (free to read online or download). I had been using git for several years before I read it and it really helped me understand a lot of the whys of how it works, as well as the internals

So since you want to host a dynamic website, you have to get a server to run it on. I am a huge fan of the vps server from ovh, there are cheap and I never had any problems with them https://www.ovh.de/virtual_server/vps-ssd.xml The next thing you will have to do is install UNIX on the server, for beginners Ubuntu 14.04 might be the best solution (you will be asked this during the ordering process). After this you will have to remotely log into your server and install php and apache and the database you are using (if there is any). A good tutorial for this can be found here https://www.digitalocean.com/community/tutorials/how-to-install-linux-apache-mysql-php-lamp-stack-on-ubuntu-14-04 Read the guide carefully and you should be able to do that. After this, You should be able to reach your website over the ip of your server. If you now want to have a domain for it you will need to purchase one seperately and you need to point it's a-record to the ip of your server (just google it, it always differs a little depending where you got your domain name but for the most part it's pretty easy) Good luck!

This is a really good free course. They start out with plain text rexipes, so it isn't even necessary to know a coding language to benefit right away. https://www.udacity.com/course/how-to-use-git-and-github--ud775

Depends on what type of hosting you need?

If you just need something to host a webpage with only HTML, CSS and frontend JavaScript, then you can use GitHub Pages which is free even if you're not a student.

If you want cloud/server hosting, then the student pack provides credits for Microsoft Azure, Amazon Web Services (AWS), Heroku and DigitalOcean.
There's also web hosting via EducationHost part of the student pack.

You can use the portable version of git ( https://git-scm.com/download/win ) which gives you a hierarchy of binaries and libraries that can simply be placed in a path they do have write access to, like their documents directory.

You don't write your code in GitHub. That's like asking, "Where do I makes videos on YouTube?" I mean you can do it if you want, but no one ever does. We code on our local machines and upload ("push") the code to GitHub.

Get yourself a text editor. Atom is good if you're starting out. It supports pretty much every language and is made by the same people as GitHub, so they integrate nicely.

At first, it's simply git, not a git or gits, because git is just the name of the software. What you mean may be a repository, a place where you keep all your files in. GitHub is just a popular project hosting provider, where a lot of these repositories are kept publicly.
Git itself is a version control system, which allows you to save and revision changes you made to your files, you check those in with commits.
Therefore it's language independent, meaning you can have a repo for all languages or just keep your plain text files in there. So there is no way, to "run them just by looking at them", you need to build them all different (for example with their repective compilers, gcc, javac, ...) depending on the language. It's like you could open all files on your hard drive with a image viewer, just because they are sorted into folders, that won't work.

I guess DigitalOcean provides post commit hooks, which may let you build your code after you pushed your changes to your upstream repo, so an automatic deployment. But I'm not sure about that, because I don't use it.

However, there are a lot of sources out there to get started and learn. Maybe you start here.

It is possible to rewrite history but it will change all of the hashes. If you are the only one using the repo this isn't that big of a deal though.

What you want to do is probably use filter-branch to erase the naughty word from history: https://git-scm.com/book/en/v2/Git-Tools-Rewriting-History#The-Nuclear-Option:-filter-branch

Typically you use filter-branch to delete a file from history but with some bash-foo you'd be able to strip the bad line out as well.

There's a portable version of git for Windows a available on the git website. No installation required.

https://git-scm.com/download/win

That link will try and download git automatically. Decline the download and select the portable option on the page.

There are plenty of spaces. The problem is your line endings. More info: https://en.wikipedia.org/wiki/Newline

Based on achivements.mrc, the *.mrc files appear to be in Unix format (LF). If you're looking for a quick conversion, just run unix2dos on the files you care about (or on the entire directory).

From your feature branch, all you need to do is run the command above.

What will happen is your branch will be updated with the current work that has been merged into master by the other developer(s). You do not need to do anything more than run the above command.

For further reading, check out the documentation on git rebase. https://git-scm.com/docs/git-rebase

Github is a hub for gits. Before you do anything on github I would suggest slowing it down and learn a bit about gits.

You want to use git version control and then upload that git to github so prospective employers can see not only the code but how you approach versioning.

You can start learning by watching this video.

Please note that Github Pages is for static websites, not interactive ones. That being said, the requirements you listed can be fulfilled with a simple table and instructions to use the browser (CTRL+F on the desktop) to search the page.

See the instructions on making tables in Jekyll, which is used to power Github pages.

Write the notes. Commit the notes. Push the notes.

For details check the git book: https://git-scm.com/book/en/v2

Use the command line client first. Tools are nice but they'll hurt your ability to understand what happens underneath.

Done.

If you have a build process that's generating CSS, it any other files for that matter, you should add the files to your .gitignore file in the repository root. If, say, you were building a web app that would get placed in a dist directory, you could add dist/ to the file. Any files and directories in the .gitignore file, will, surprising, be ignored by Git! For more detailed information you can give the Git docs a read.

>On January 31st 2017, we experienced a major service outage for one of our products, the online service GitLab.com. The outage was caused by an accidental removal of data from our primary database server.
>
>This incident caused the GitLab.com service to be unavailable for many hours. We also lost some production data that we were eventually unable to recover.

https://about.gitlab.com/2017/02/10/postmortem-of-database-outage-of-january-31/

1) To get a website at username.github.io, the repo should be named username.github.io - note: that will only work for your username. Full details here

2) GitHub Pages is a hosting service, that uses Jekyll to auto build if it needs to, but can host any static site.

3) Jekyll is a static site generator. Basically, it takes a directory of markdown files, applies a theme to them and produces HTML for them. The official site will go into more detail about how it does that. It was initially created by one of the GitHub founders.

4) If you are using Jekyll, you can apply different themes to your site to change the aesthetics. It's all HTML, CSS, and JavaScript at the end of the day so they are the main ways to alter the aesthetics.

edit: added link to pages documentation

GitHub Desktop and Git for Windows are two completely separate software packages. GitHub Desktop does not set up its private copy of git to work in a console environment.

The default configuration for Git for Windows should include Git LFS.

instead of a commit hook, you could consider a pre-push hook or a pre-receive hook. both could prevent poorly named branches from landing in your remote and they would not drastically interrupt a developer’s local workflow (unlike a commit hook) https://git-scm.com/docs/githooks

Don't be embarrassed, that's really normal especially for side projects. Most people will never notice, let alone care.

I think you're fine to just leave it and change how you commit going forward (utilizing branches as someone else mentioned. Or you could make many commits but don't push any of them. Then when you're ready, do a Git rebase locally to squash the commits. Then push the one commit. Multiple possible workflows out there).

If you really want to, you can rewrite the commit history and make it appear the same as if you had done all the work in a single commit instead of 30. But you should only do that if you feel confident about what you're doing and are sure it won't impact anyone else (like if you were working with other people on a team -- you can't just change the history, you need to be extra careful and generally should only be changing history if you are sure you are working on a branch that no one else is working off of). This documentation has good info about rewriting history: https://git-scm.com/book/en/v2/Git-Tools-Rewriting-History

Up to you. Either way its totally fine. :)

No, but this would be ideal for use with private repos at work. I'm currently using gitlist for my work-only repos, but this is much cooler. I'd be more comfortable switching if I knew a little Go though.

It's really simple really. It's basically just a service given by Github that allowes you to use Github as a webserver, hosting your website.

>Can I use GH Pages to exhibit my website project and provide a link for linkedin?

Definitely!

>how do I add the files of the website (html, css, and images inside the img folder) and have a link where people can access my website.

Read through https://pages.github.com/ and https://help.github.com/categories/github-pages-basics/
It should give some more technical details.

> Are there easier and free/cheaper alternatives to GH pages? Can I just provide a link to the dropbox?

I'd totally go with GH pages. It's so dead simple.

You can use the block code snippets and specify a language directly in markdown for syntax highlighting across a large range of languages. Take a look at this reference.

I'm not sure about only removing the passphrase prompt for git pull, but for persisting between logouts you might want to look into keychain https://www.funtoo.org/Keychain

I use it for my Debian VMs and only enter passphrase on startup.

If you don't mind putting your Chromebook in developer mode, you can use Chromebrew. It lets you easily install both Git and a ton of other programming tools. IME it's almost never failed (well, there was the time I ran out of disk space and crashed my file system, but that's another story...).

Just follow these steps to be able to get to a shell, and run the commands on the Chromebrew website.

You need an actual git client or gui, or a diffing tool like KDiff3 if you don't want to maintain your own fork on GitHub. Clone the repo and then copy your changes over it, then use git diff or your diffing tool. You'll see a mix of stuff you've changed and stuff they've changed - for the best experience I'd recommend actually using git as intended. Ideally you should check out the commit you originally cloned from, apply your changes as a new commit, and then diffing will be much better.

CMake is a build tool, they have a download link here: http://www.cmake.org/

Qmake is a tool that comes with Qt, which is a big GUI library. There's some instructions here: http://qt-project.org/doc/qt-4.8/install-win.html

They don't mention it, but you'll also need a C++ compiler. On Windows you can choose between Visual Studio (made by Microsoft), and MinGW, an open source port of GCC which comes from the Linux community. I'm not sure which compiler will be easier for you but I'd guess Visual Studio. Google for Express Edition (aka the free edition) and you'll find instructions.

When downloading Qt you get to choose between the binary version (precompiled) and open source- I haven't used Qt in a while but I would recommend binary version, it will be much faster to install, and it has better support.

Hopefully that gives you enough to get started. Sadly, setting up a dev environment on Windows tends to be a pain.

Most maintainers wouldn't care about a lot of merge commits. But if it becomes an issue, the tool you're looking for is <code>git rebase</code>. Basically you take the last X commits in your git history and squash them into less commits, or even just one commit, and you get to rewrite commit messages as you go and even leave some out, like WIP commits or merges. So when you PR, the maintainer only sees a nice, clean commit history on your branch.

But when you rebase, you are in effect changing history. It is possible to seriously bork your work with rebase. My advice would be to branch off master, do your work there commiting as you go, then branch off again and rebase, and PR your rebased branch. If you screw up, you can always branch off from your working branch again.

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

Expanding on what u/nordcomputer is explaining.

git (the technology/tool that github utilise) does not track folders. If you make a folder let us call it Dir and in that folder make a file fi to add the file you will need to run git add Dir/fi and then git commit -m "add fi" and then push. This will push the file to your remote git repository on GitHub and because the path of fi is Dir/fi this will on GitHub show up as a folder and on local cloned instances as well.

&#x200B;

However, you should be able to on your local machine to run git add Dir to add all files in Dir in a single command or cd into Dir and type git add . to add all files as well. Take a look on how git works in more detail before continuing :)

If your IDE doesn't allow you to add a remote, it's easy enough to do on the command line.

In the project folder you run something like git remote add origin {github-url}

I can recommend reading the docs.

Hmm. Looks like my only HTTPS options really to either cache the token for 15 minutes (un-user-friendly), or store the token as plaintext.

Maybe I'll look into using SSH...

And why can't you?

Just configure git correctly and tell it which editor to use. Or correctly set your sytems default editor.

Read https://git-scm.com/book/en/v2/Customizing-Git-Git-Configuration about the core.editor setting.

I started here just last week. Chapter 2 was my aha moment as I did a few adds and commits. Once I git comfortable with that I the made a an account on GitHub and pushed my local repo up as private. I’m only a week in but I feel comfortable navigating it. Might be a different story when I try to distribute the app.

If you want to keep your changes to one branch you should commit after creating new_file.

See https://git-scm.com/docs/git-checkout:

>git checkout [<branch>]
To prepare for working on <branch>, switch to it by updating the index and the files in the working tree, and by pointing HEAD at the branch. Local modifications to the files in the working tree are kept, so that they can be committed to the <branch>.

(In your last step I suppose you did git checkout master. Otherwise you would create a branch master based on your current working status)

You mus tell Git who you are (name and email address):

git config --global user.name "Your Name" git config --global user.email ""

See: https://git-scm.com/docs/git-config

You have a long journey ahead of you. Yes you are in the wrong location. With that below link you can start your path. Good luck!

Python is a popular language for webscrapping: https://www.freecodecamp.org/news/tag/web-scraping/

You can alao find some drag and drop non coding webscrappers out there if you look around for them. Less control but easier to put together sometimes, depends on your exact use case.

Git submodules may be what you are looking for. They allow you to specify that a subdirectory under the repository should actually be another repository. https://git-scm.com/book/en/v2/Git-Tools-Submodules

The command “git pull” is shorthand for “git pull origin master” by default. “origin” is the default name for the “remote” of a Github repository (Github’s version of the repository). “master” is the default branch created by git when initializing a repository.

Both commands will do the same thing if you’re just working on “master” and you haven’t changed your default remote name “origin”.

Both commands will fetch changes made on Github that you don’t have locally and automatically merge them in.

tl;dr they are the same (if using defaults) and either will update your local code.

See https://git-scm.com/docs/git-pull for details.

looks like the commit was pushed (can pull up the commit online with the hash), I guess everything isn't syncing correctly due to outage

https://stackoverflow.com/questions/35053397/git-push-failed-after-github-went-down

I think the build system only applies if you’re using Jekyll, otherwise GitHub pages just assumes the final HTML is already available in a certain location and then it will just serve those new changes on a new commit. Definitely check out all the info here, for a readme it might be built into their system as well. https://pages.github.com

But with GitHub Actions, you can use that to build your site using any SSG technology, and make that output HTML available for GitHub pages to host.

Learn git, because it's not just the tool, it's also the concepts. After you have a wrangle on git, then find a tool that makes git easier / faster for you, whether that is Android Studio's built in utility, or something else. If you learn git, it doesn't matter if in the future you stop using Android Studio, or there is a different Android Studio-like tool that doesn't include git in it.

I recommend starting with http://rogerdudler.github.io/git-guide/

And then moving on to https://git-scm.com/book

Read: https://git-scm.com/docs/gitignore Use: https://www.gitignore.io/api/django

After you create your .gitignore and start tracking that file, you can remove the settings.py from being tracked from now on using ```

git rm --cached settings.py

There is an hidden .git folder in that directory. Where all your changes are stored. In the explorer you only see your current working directory. If you switch to another branch git will change/replace/... the files in that spot for you so you. For an more detailed explanation look here for example

I actually got it working thanks to some help from some kind soul on stack overflow. I've been using the UI in combination with the command line, and it works well for me.

Home Assistant has a nice write up on setting it up: https://home-assistant.io/docs/ecosystem/backup/backup_github/

The best part is it allows me to track changes overtime as I add/remove components and re-image if needed or when I upgrade hardware.

Hey OP I’m a set learner using The Odin Project, and am coming up on learning more about git. I figure I’d share the link of that part of the course for you because it also shares videos and such that might be of help along with your studies. Can’t hurt to give it a look.

I think you may be thinking of GitHub Pages. But GitHub Pages will only host your static files, not your node app.

Take a look at Node.js' wiki on Node hosting. That's a good starting point, lots of options.

username.github.io is meant to be your personal website. As in you as a developer having a portfolio or similar type of site to showcase all of your projects. You can only have one of these because it corresponds to your username.

username.github.io/yourproject is a project website. You can have one of these for each project/repo.

https://pages.github.com

In case you don't know, documentation on github (and many other places) is currently written in the markdown language (.md).

Here's a great guide on how to get started with it: https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet

You can also use markdown editors if you prefer to get a "what-you-see-is-what-you-get" experience. The ones I've used do require that you write in markdown, but it's valuable to learn! Once you've gotten used to it you can quickly format text. :)

As /u/your_power_is_mind said you can add images to an issue you've created on github, or upload the images to another host like http://imgur.com and then include them in your documentation.

Git-SVN is bidirectional. One can read/svn-clone from a Subversion repo and commit verbatim history (EVEN MERGE!!!) to a Git repo.

Alternatively, if for whatever reason that doesn't jive with you, you could maintain an SVN read-only clone, and a working Git copy, manually merge (KDiff or something similar) then commit to Git. Although, git-svn was literally developed for this scenario.

If you're both working on this project simultaneously one has to raise the point that someone has to concede defeat and go for a singular solution. Git-SVN works well for situations where one might migrate, it's not intended to be a long-term bridge between two CVS though. If it's a constant back and forth you might be better off just using SVN. (Not something I thought I'd ever find myself saying)

If its a different repo couldn't you use submodules or subtrees to include this code? Does their repo have the binary?

• https://git-scm.com/docs/git-submodule
• https://git-scm.com/book/en/v1/Git-Tools-Subtree-Merging

Typically you don't organize your commits.

Standard github workflow (as I know it) is you want to implement a feature in your code. So, steps are:

1. Make a new branch off of your (hopefully stable) master
2. Code featureA into your new branch
3. Run tests on your new branch to make sure it's up to merge spec, then merge it into master
4. Repeat

This doesn't do much to organize your commits per se, but is just good practice in terms of workflow.

The issue with "organizing commits" is that there isn't really a good way to group some amount of commits. You can label specific commits as specific versions of your code, (i.e. after you add in features A B and C you decide to tag a release--the commit where you merged in C would get 'tagged' as whatever version you decided to name it), but that doesn't "group" commits at all.

maybe you'd like to try Eagle? https://en.eagle.cool/
it's not on github yet but it's a super useful desktop-based file management tool that can easily sync through the cloud and provide tagging and annotations.

You can categorize assets (image/videos/gifs/audios/docx...etc) across different dimensions very easily (e.g., by platform, by subject, by style, by shape, by color etc.), and can easily create custom queries, smart folders, auto-import and even use your tag label to create a custom folder (e.g. one photo with two different tags can appear in different tag folders without duplicating and taking two spaces, which is extremely thoughtful).

I've found it to be very useful in managing my workflows and optimizing my organizing process. also, beautiful interface is a plus too
hope this helps

So a pull request is basically asking the upstream repo to merge any changes (commits) from your repo. And a Issue is a question/bug report.

You can check out an example of an issue here. You can see some discussion between the owner and the person whom opened the issue.

One example of a pull request would be here. You can see that the project wants to review any changes and make sure things meet with the code style and vet any possible bugs/ideas before merging into the master branch.

It's worth mentioning that some projects would ask that you create another branch instead of opening a pull request against the master branch. While it's not common it does occur.

You forgot Chromium. My to-go Browser on Servers since it's ez af to install and actually works instead of IE etc. https://chromium.woolyss.com/

For less treacking with chromium i'd suggest the product Iridium. But it's not updated that much: https://iridiumbrowser.de/downloads/os-not-detected

GitHub doesn't host your DNS. Name servers are where your DNS is hosted.

If you want an all-in-one solution -- DNS (name servers), CDN, CI, cloud functions, etc, I'd recommend Netlify. Their free tier is extremely generous and I use them for all of my sites instead of Github pages (and I don't pay a dime, all of my usage fits in the free tier). What's great about netlify is that you can still deploy on push, but you can use any static site framework you want and they will build it and host it. Even if you don't host your DNS with Netlify I still recommend them over Github pages.

This is a good intro to what you need to learn. A very important thing to take away from it is the second heading: you cannot break things. Other than that it merging actually pretty self explanatory and git itself will guide you through most of it.

I just found https://stackedit.io/ which was awesome to let me preview markdown as I type, and it saves drafts without login, or syncs across devices if I login. Not connected to github though, but copy/paste works pretty ok. :)

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/

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.

Yes. You need a Git client on your computer. You can use either a graphical client or command line Git (sudo apt install git on Linux, or Git SCM elsewhere).

Likely conflicts of some sort, you'd need to rebase your branch.

The "GitHub Desktop" app is a very sub-par Git client. I don't know how to help you out with that, but I recommend GitKraken. You can rebase just by dragging and dropping branches.

Fork is the answer, but not the mere pressing of the so-named button in Github. Clone the repo, push it to a new repo that was made the normal way. Note the in the readme that "this is a divergent fork of xxx", pull in some more committers who agree and have time, tackle the trademark issues - maybe by giving the project (and consequential distributables) a unique name, host a web site and go forward with a PR agenda.

Then when 'that weird guy' is done with complaining and wants peace, merge back again with shared leadership of the project.

Ref https://nodejs.org/en/blog/announcements/foundation-v4-announce/ and https://iojs.org/en/

Splitting a repo into smaller ones is easy:

• start by cloning your repo into multiple copies
• for each copy, git rm all the files except one mini-project, then commit
• for each copy, git mv the remaining files to sensible locations (for example up to repo root if they were in a subdirectory), and then commit

When you have done that, it's time to think about how to store them. You can upload them directly to Github (which would obviously clutter your repo list) or you could upload them as Gists (haven't done that, but according to docs each gist is a small repo that can be pushed into).

And the next step... well, if you want some kind of "master repo" containing links to the smaller ones, then Git submodules are propably the best choice.

Looks a lot like https://play.google.com/store/apps/details?id=by.aleks.ghcwidget&amp;referrer=utm_source%3Dgoogle%26utm_medium%3Dorganic%26utm_term%3Dplay+google+github+contributions+widget&amp;pcampaignid=APPU_1_Qd1zWM70CYOqsAGv0YrICw

your work in the repo.then commit the changes. no copying, ever.

your repo is in a folder. just work in that repo.

https://git-scm.com/book/en/v2

since you are brand new, this is the book you need, free online.

This is a git question, not a GitHub question.

But you need to update the remote that your local repo is pointing to. You can do that by either:

• Using <code>git remote set-url</code> to change the URL
• Editing the .git/config file directly

Rebasing means changing the base of the branch, so essentially the point where you branched off. If you really want to do it on the website, you could delete the branch and create it again (as long as you merged everything properly, it should have the dame effect), but you probably should use <code>git rebase</code>

Yes you can always go back to any commit and see the state of the entire repo at that commit time.

Also you can "tag" commits with labels (like alpha-1, beta-3, v1.0.0, etc.) which makes it easy to go back to important points during your game making.

https://git-scm.com/book/en/v2/Git-Basics-Tagging

Awesome suggestion. Sadly I didn't think to try that.

So it's worked up until the dir -exclude old_a | %{git mv $_.Name old_a} step. [Git docs[(https://git-scm.com/docs/git-mv) made me think $_.Name needs to be the name of the repo that I want to hold all the assignment repos (the one with the name of the class), but when I entered that name, I got dir: invalid option -- 'e'. dir --help doesn't list an -e or exclude option, so I'm not sure what's going on.

Git isn’t a test system, it’s a means of recording changes and transferring them between systems.

If you want to test and see what the changes would do, you want a test (CI, CD, etc.) system.

If you make a misteak, put it in misandwich, I’ve been in a mood for a good Philly for a while now.

Git also has nothing to do with Shopify.

https://git-scm.com/book/

Commits (and other git internals) are stored in the .git folder in your repository. It's a fair bit more complicated than a specific file storing all the commit data, but if you're interested I'd recommend reading chapter 10 of the Pro Git book (Available online here).

>is my assessment of "commits being valued in a repo" somewhat true?

Yes. In a way you can see the commit history as proof of how the code was written. A repository with just a single commit in which a full project is developed would suggest to me that the project might've been plagiarized, unless it's a very small codebase.

Additionally, if someone else contributed to your code, they are automatically attributed through the commit history (although a thank you in the README can't hurt either). Removing the commit history will remove their attribution as well, which again is a form of plagiarism.

https://git-scm.com/book/en/v2/Git-Tools-Rewriting-History

Give that a read, you'll have to rebase and do a forced push. I would highly recommend working off a branch in the future and merging into the main.

Okay, since you asked:

> If you are learning to code, it is often hard to discover and learn about all of the Git commands.

Not really, you can discover and learn all of the git commands at https://git-scm.com/docs

The difficult parts of learning git are getting started and comprehending the fundamental ideas that git is based on. A great git game would be where each card you play is a commit, and you combine stacks of cards with other players in order to merge branches together.

> STJ: Git Flashcards make it super easy. They combine state‑of‑the‑art memory techniques with a fun-to-play card game to help you learn about Git commands faster.

Based on the "science behind STJ" section, the state of the art memory technique is to just add an irrelevant image beside the text. I get it, its a flash card, great. But flashcards do not make for fun or compelling learning games.

Under different circumstances I would enjoy the absurdity of this project and would appreciate the time and talent that went into making something aesthetic and silly. But the overbearing marketing makes it clear that this is intended to be a low effort money grab, and that just leaves me with a sour taste, you know?

You need to rewrite history and then "git push --force". Depending on the amount of history you can go back, you might find this useful:

https://git-scm.com/docs/git-filter-branch

The GitHub Pages feature that lets you have a CNAME for your own site isn't designed to support this.

If you want to be able to `git clone ` you will have to do a whole lot of very clever sysadmin work, including running your own VPS and setting up SSH keys.

You might be able to use a server-side Git hook to teach your own Git server to first clone from GiHub such that you can then clone down from your server. I wouldn't know where to start with that though! https://git-scm.com/book/en/v2/Customizing-Git-Git-Hooks#\_server\_side\_hooks

so if a youtube tutorial isn't helping can you at least tell us what about the video is confusing or not straight forward?

There is always the official book

https://git-scm.com/book/en/v2

1. This is r/github, not r/git, this is not where your question belongs (GitHub ≠ Git).
2. What you want to do has nothing to do with pulling, because Git already has all that data. That's the point of a version control system. In fact, if you try git diff
3. (this is gonna sound very mean, sorry about that) You should probably rm -rfd .git and stop version-controlling your project with Git until you have learned at least the basics. There are a log of good tutorials out there, for example https://lab.github.com - or go to https://git-scm.com, they also have good ones, as u/mitch_feaster already commented.

If you are really in a pinch and have to do this urgently:

>!Use git checkout HEAD to discard all uncommitted changes, which seems like what you want to do here.!<

Now, in case someone else comes across this, actually with the question that is in the title:

> One of the posts I found said you can't pull a specific commit - which doesn't sound right

They are right, you can not pull a specific commit. If you want a specific commit, you can use the method described in the source OP linked:

git clone <repo-url>
git checkout <commit-id>

This will clone the repository and then check it out at the specified commit, so that your working tree will now reflect the repo at that commit.

https://git-scm.com/book/en/v2/Git-Tools-Rewriting-History

Scroll down to the "Removing a File from Every Commit" section.

> $ git filter-branch --tree-filter 'rm -f passwords.txt' HEAD

> Rewrite 6b9b3cf04e7c5686a9cb838c3f36a8cb6a0fc2bd (21/21)

> Ref 'refs/heads/master' was rewritten

The Obsidian Git extension sounds super cool! It consistently gives me the error that it "cannot run git command," though.

I currently only use four things:

• Obsidian MD
• Working Copy (for syncing to iOS)
• GitHub Online (for storing files)
• GitHub Desktop (For uploading my local changes to GitHub Online)

It looks like I need to download git-scm for this plugin to work? But I'm not sure if I need to configure anything else?

Maybe a good question to ask your employer. How do they envision you using git in your daily workflow?

Everything you do sounds like solo coding so git/GitHub doesn’t make a lot sense to me either for simple coding/analysis tasks. However, I also do a lot of solo coding or with one other person but on big dashboards that have a lot of quirky components. I or my partner can branch off the master and experiments and play around with stuff. I can then merge my updates back in the master if I think everything is legit. Git and GitHub let’s me see everything that has changed in my code and allows for easy code review. A huge help! I can also revert back to a previous version if something goes awry. No need to save files with different names anymore. Unfortunately, this maybe it’s y useful for you! So I’d start asking your employer how do they see git and GitHub enhancing your workflow! Sounds like it might make it more cumbersome…at least for a bit.

Git came about because the developer of Linux thought the current version control at the time was inadequate for his needs. He and others developed it so they could speed up and enhance their development.

https://git-scm.com/book/en/v2/Getting-Started-A-Short-History-of-Git

Appeal was a success. Just letting people know here that using offensive emails for your account from cock.li will get your account susspeneded apparently. Also apparently people can report you for your email name despite that not being publically visible which is really odd.

Yup, there is a wonderful application called GitTrends, you can see the traffic stats of each of your repos, and the total number of views and stars.

I know for sure that Hotspot Shield can get through, and I'm not sure about Tor. Either way, students and teachers shouldn't need to find ways around this block to access GitHub.

Git you should download git… before you even continue ANY FURTHER with using GitHub you will sit down and read up on git and GitHub so you know what you are actually using. Start on the git web website https://git-scm.com/

You can do whatever you want to do.

Git is a utility for tracking changes... GitHub is a Source Code Repository platform. https://git-scm.com/book/en/v2/Getting-Started-What-is-Git?

What you're asking really just doesn't matter. Do you want what you have so far to be used as a 'checkpoint?' then yes, commit. If it doesn't matter... then dont. Up to you.

if you have the submodule checked out as part of the main repo you can do:

git push --recurse-submodules=on-demand from the base of the main repo

https://git-scm.com/book/en/v2/Git-Tools-Submodules