Android Developer Tools Android Developers Android Development Android Studio app development github

everything you need to know about the code sharing platform

If you’ve ever explored the world of software program improvement, then likelihood is you’ve heard of GitHub.

This code internet hosting platform is one among the most popular ways for builders to host their tasks and share them with others. Immediately, some of the best-known open source tasks use GitHub, together with Firebase, React Native, and TensorFlow. Google even have their very own GitHub repositories, the place you can find all of the Android pattern apps.

There’s plenty of totally different explanation why you may be excited about getting to grips with GitHub. Perhaps you’ve seen an incredible venture but are not sure how to get its source code from the GitHub web site and onto your local machine, or perhaps you’ve developed your personal Android app and need to share it with the world. Perhaps you’ve fastened a bug in a venture that’s hosted on GitHub and need to contribute your code again to the unique venture.

On this article, I’ll provide an entire introduction to both GitHub and Git (and explain the differences between the two!) By the finish of this article, you’ll have created a repository in your local machine and a distant repository on the GitHub web site, related the two, and may have pushed a number of information from your native repository, to a publicly-available GitHub repository.

Since collaboration is a large a part of GitHub, I’ll additionally show you how to create a number of branches inside the similar repository, and how to submit a pull request, so you can start contributing to any challenge that’s at present hosted on GitHub.

What’s GitHub?

GitHub is an internet site of repositories where builders can retailer and share their tasks, and contribute to other individuals’s tasks.

GitHub supports all programming languages, and all file varieties together with pictures, movies, spreadsheets and textual content information. Though we tend to assume about GitHub in the context of software improvement, you might use GitHub to host a undertaking that doesn’t include any code, for instance Microsoft retailer all of their Azure docs over at GitHub.

GitHub can even assist builders collaborate on a venture, whether or not that’s working with different members of your improvement staff or collaborating with individuals who simply like your challenge and need to assist out. Anybody can use GitHub to increase issues, recommend new options, and even contribute code to one other individual’s venture, so by hosting your challenge on GitHub you might find yourself with an entire new workforce of contributors!

By selling this type of collaboration, GitHub has developed robust ties with the open supply group, which is a method of software program improvement the place a undertaking’s supply code is freely obtainable.

When you can view a venture’s supply code, you can even repair bugs, add new options, and use the code as the basis in your own tasks – and GitHub is ideally suited to every of these tasks!

Depending on how the unique open supply challenge is licensed, you might even have the ability to use it as the foundation for business merchandise, for example there’s countless business Linux distributions obtainable (though whether that features Android continues to be up for debate!)

What’s the difference between Git and GitHub?

GitHub and Git are often used alongside each other, and typically the terms are even used interchangeably, but they’re two distinct tools.

Git is a distributed version control software that runs regionally in your pc, and that you can use to handle your venture’s source history. GitHub is a cloud-based platform constructed round the Git software. The next screenshot exhibits an example of a GitHub repository.

Google host multiple repositories on GitHub

Sometimes, you’ll use Git to connect to GitHub, after which use Git to carry out duties comparable to pushing your code to GitHub, and pulling code from GitHub.

Whereas cloud-based internet hosting providers akin to GitHub are steadily used with Git, Git doesn’t require GitHub to perform. You possibly can probably use Git to carry out version control and work collaboratively, with out ever creating a GitHub account.

Getting began: Git, GitHub.com or GitHub Desktop?

There’s several ways that you can work together with GitHub, together with some strategies that don’t require you to concern any Git instructions.

To provide you the absolute best overview, I’ll be masking three major strategies:

  • Installing Git and issuing Git instructions out of your Mac’s Terminal, or the Command Prompt if you’re a Home windows consumer.
  • Heading over to GitHub.com, and navigating its numerous menus. as proven in the following screenshot.
  • Utilizing the well-liked GitHub Desktop app, as proven in the following screenshot.

You can interact with GitHub using a client app

By the finish of this text, you’ll have performed some important GitHub tasks using every of the above methods, so you’ll be able to select which strategy works the greatest for you.

Establishing Git and GitHub

To start out, you’ll need to create a GitHub account and install the Git model management device.

Open your net browser and head over to the GitHub website, select “Sign Up” and then comply with the onscreen instructions to create your GitHub account.

Assuming you’re not a scholar, you can select between a Free or a Pro account. If you go for the free account, then you’ll be restricted to three collaborators for any personal repositories you create. If you spend money on a Professional account ($7 per thirty days at the time of writing) then you’ll have limitless collaborators plus entry to some further instruments and insights.

If you’re a scholar, then it’s value wanting into the free GitHub Scholar Developer Pack, which supplies access to some further instruments, together with Amazon Net Providers, Heroku, Unreal Engine, and Microsoft Azure.

Subsequent, you need to set up and configure the Git version control system:

  • Head over to the Git website and obtain the newest model on your working system.
  • As soon as Git has downloaded, launch the file and comply with the onscreen directions to install.
  • You now need to configure Git, so launch a Terminal (macOS) or Command Immediate, if you’re a Windows consumer.
  • Copy/paste the following command into the Terminal/Command Prompt window, ensuring to substitute “Name” together with your GitHub username:

git config — international consumer.identify “Name”

  • Press the “Enter” key on your keyboard.
  • Copy/paste the subsequent command into the Terminal or Command Prompt – don’t overlook to substitute [email protected] with your personal e mail handle!

git config –international consumer.e-mail [email protected]

  • Press the “Enter” key.

Understanding GitHub tasks

Every GitHub undertaking is stored in its personal repository, which is usually divided into a number of information and folders.

Although GitHub users can technically construction their tasks nevertheless they need, there’s a number of information that you ought to incorporate into each GitHub challenge.

If you navigate to pretty much any repository on GitHub.com, then you’ll virtually all the time find one or each of the following information:

  • README.md. This could include important info about your challenge, together with how to construct it in your local machine. Since a README file is often just plain text, throughout this tutorial we’ll be creating dummy README information and then committing them to totally different distant GitHub repositories.

Most GitHub projects feature a README.md file

  • LICENSE.md. Just because a undertaking is open source, doesn’t mechanically mean you can do whatever you need with it! The term open supply covers a wide range of different licenses, and a few of these licenses have very strict guidelines about how you can use, modify and redistribute the challenge’s code. Earlier than doing anything with a challenge, you ought to learn its accompanying LICENSE.md rigorously, to ensure you’re not going towards the developer’s wishes. If a GitHub venture doesn’t include a LICENSE.md file, then you might give you the option to find some licensing info in its README file as an alternative. If unsure, then you can all the time reach out to the venture’s owner for clarification.

Creating your first GitHub repository

GitHub supplies a means to share your work without any of the time, effort or value sometimes related to sustaining your personal web site or code-hosting platform: simply add your undertaking to GitHub, and anyone might be in a position to download and contribute to it.

To host a undertaking on GitHub, you’ll need to create two repositories:

  • An area repository, which is actually only a common folder on your local machine. This should include all the information and folders that you need to push to GitHub.
  • A remote repository on the GitHub.com web site.

Your native and distant repositories will communicate with one another by way of Git.

Once you’ve related these two repositories, you can proceed to work on your undertaking as regular on your local machine, while periodically pushing your modifications to GitHub, as and when required.

Let’s begin by making a distant repository. We will complete this process without issuing any Git commands, through the use of the GitHub.com website:

  • In your net browser, head over to GitHub.com and log into your GitHub account, if you haven’t already.
  • In GitHub’s toolbar, select the “+” icon, adopted by “New Repository.”
  • Give your repository a name and supply a description.
  • Determine whether or not your repository ought to be public, or personal. Until you have a selected cause not to, you ought to make your repository public so that other individuals can obtain it, and maybe even contribute to your challenge sooner or later.
  • You now have the choice to mechanically generate an empty README file, by choosing the “Initialize this repository” checkbox. Since we’ll be creating this file manually, make certain you depart “Initialize this repository” deselected.
  • When you’re proud of the info you’ve entered, click “Create Repository.”

GitHub will now create a distant repository, prepared and waiting on your first commit.

Creating an area repository with “git init”

Subsequent, you’ll need to create an area repository and connect it to your remote repository. For this step, we need to delve into Git instructions:

  • On your local machine, create a folder in any location. I’m going to create a “TestRepo” folder on my Desktop.
  • Launch your Mac’s Terminal, or Command Prompt if you’re a Windows consumer.
  • We now need to change listing (cd) so that the Terminal or Command Immediate is pointing at the local repository you simply created, which for me is “/Desktop/TestRepo.” In the Terminal or Command Prompt, sort “cd” followed by the full file path of your native repository. For instance, right here’s my command:

cd /Users/jessicathornsby/Desktop/TestRepo

  • Run this command by urgent the “Enter” key on your keyboard.
  • To rework “TestRepo” into an area GitHub repository, you’ll need to create a .git subdirectory containing all your repository’s metadata. To create this subdirectory, sort the following command into your Terminal or Command Prompt, and then press the “Enter” key:

git init

  • At this point, your “TestRepo” folder is an initialized repository that can talk together with your distant GitHub repository. You simply need to let Git know which distant repository it ought to be speaking with! Copy/paste the following command into the Terminal or Command Immediate, however don’t press the “Enter” key simply but:

git remote add origin

  • You need to specify the URL of your distant repository, adopted by the .git suffix. For example, I’m connecting my native repo to https://github.com/JessicaThornsby/TestRepo, so here’s my command:

git distant add origin https://github.com/JessicaThornsby/TestRepo.git

  • Press the “Enter” key on your keyboard.

From this level onwards, your native repository will keep in mind which remote repository it wants to send its modifications to.

Importing a file to your GitHub repo

Now we’ve related our local and distant repositories, let’s take a look at how we will use this connection to ship a file from our native machine, to the GitHub servers.

I’ll be utilizing an empty README text file, however you can use any file you need. Just remember that by the end of this part, your file might be publicly obtainable on GitHub.com, so ensure that it doesn’t include any personal info.

  • Create or discover the file that you want to push to GitHub.com, after which drag and drop this file into your local repository i.e the folder on your native machine.
  • Now, we need to put together our commit, by choosing and choosing which gadgets we would like to “add” to Git’s staging space. Each item placed in Git’s staging area, shall be bundled into your next commit, and ultimately pushed to GitHub. In the Terminal or Command Immediate window, sort “git add” adopted by the identify and extension of each item that you want to add to Git’s staging space, for example:

git add ReadMe.txt

  • Press the “Enter” key on your keyboard.
  • Now you can prepare your commit, utilizing the “git commit” command. At this point you may also add an optionally available commit message describing all the modifications included on this commit. By providing a message for each commit, you’ll create an entire historical past of your challenge, which may be invaluable for different members of your staff, but can be helpful if you ever need to pinpoint when a specific change occurred. You provide a commit message using an “-m” flag, which is strictly what I’m doing with the following command:

git commit -m “creating a README file”

  • Press the “Enter” key in your keyboard.
  • Now you’re prepared to push this commit to your distant GitHub repository. We’ll be exploring multiple branches in the next section, so for now just remember that we’re pushing this commit to our repository’s master branch. Copy/paste the following command, and then press the “Enter” key:

git push -u origin master

  • When prompted, enter your GitHub username and password, and then press “Enter.” Git will now push your commit to GitHub’s servers.
  • In your net browser, head over to GitHub; the README file ought to now be appearing in your distant repository.

All files you push to GitHub, will appear in your remote repository

Branching and merging

Branching is a core idea of Github, as it allows you to keep a number of variations of the similar venture concurrently.

Branching is usually used to experiment with new features and code earlier than committing this work to the undertaking’s grasp branch, which is usually thought-about its secure branch. For example, if you check out the repository for Google’s cross-platform Flutter SDK, then you’ll discover branches corresponding to “dev” and “beta” which include code that isn’t presently thought-about secure, however might sooner or later be pulled into the secure master branch.

By publishing experimental code to GitHub, you can get feedback out of your customers, collaborate with different developers, or just have the added security of figuring out that even when your local machine crashes, you gained’t lose that experimental code you’ve been working on.

Branches can be used to develop variations of your venture which are tailored for a specific shopper, consumer demographic, or working system.

Since branching is such a huge part of GitHub, let’s add a department to our repository:

  • In your net browser, navigate to your remote GitHub.com repository.
  • Discover the “Branch: Master” button (where the cursor is positioned in the following screenshot) and provides it a click on.

Select GitHub's

  • In the subsequent window, sort the identify of the branch that you need to create. I’m naming mine “beta.”
  • Select “Create branch.”

You now have two branches, and may navigate between them by choosing your repository’s “branches” tab.

Select the

Working with multiple branches

Presently, our two branches include exactly the similar README file.

To get an summary of how you’d sometimes use branching in your real-world tasks, let’s make some modifications to the “beta” model of README, as if this is the experimental model of this file. We’ll then assume these modifications have been accredited, and merge the beta README with the model in our secure department.

To make issues simpler, I’m going to edit the README immediately in GitHub’s textual content editor:

  • Change to your “beta” branch by choosing your distant repository’s “branches” tab, adopted by “beta.”

GitHub's

  • Find the little pencil icon that appears alongside the README file, and provides it a click on.

You can edit text files inside GitHub, by clicking their accompanying pencil icon

  • You need to now be viewing README in GitHub’s textual content editor. Make some modifications so this model of the file is noticeably totally different to the model in your grasp department.
  • As soon as you’re comfortable together with your modifications, scroll to the bottom of the web page and ensure the following checkbox is selected: “Commit directly to the beta branch.”
  • Click the inexperienced “Commit changes” button.

At this point, you’ll have totally different versions of README in your master and beta department.

Merging your modifications: Making a pull request

You merge modifications from one branch into another department by opening a pull request.

When you open a pull request for a third celebration challenge, you’re primarily asking the venture’s owner to evaluation your department and (hopefully) pull your work into their department. Nevertheless, you also need to submit a pull request if you’re the proprietor of each branches, which is strictly what we’re doing in this part.

When you create a pull request, GitHub will highlight all the differences (referred to as “diffs”) between these branches, so you can preview the finished end result before going ahead with the merge.

Let’s submit a pull request, to merge the beta README into the secure README:

  • In your net browser, choose GitHub’s “Pull requests” tab.
  • Click on the inexperienced “New pull request” button.
  • In the “Example comparisons” field, select the department that you simply created, which in my occasion is “beta.”
  • GitHub will now spotlight all the “diffs” between this department and the grasp department. Evaluate these variations, and if you’re glad to proceed then click on the “Create pull request” button.
  • Give your pull request a title and supply some text describing your modifications. If you’re submitting this pull request to a 3rd get together then it’s notably essential to provide as a lot info as attainable. The place applicable, you also can connect information corresponding to screenshots and movies, to help illustrate your proposed modifications.
  • When you’re proud of the info you’ve entered, click on “Create pull request.”

Reviewing GitHub merge requests

Since we’re working inside the similar undertaking, we’ve primarily sent a pull request to ourselves.

In this section, we’ll assessment and accept the pull request, which can merge the beta README into our secure department:

  • Choose the “Pull requests” tab. This display displays all the pull requests you’ve acquired over the lifetime of your undertaking.
  • Find the pull request you just submitted, and provides it a click.
  • Assessment the info about this pull request, together with any potential conflicts that GitHub has recognized.
  • If you’re pleased to proceed, then discover the “Merge pull request” button and click on its accompanying arrow. At this point, you can choose to “Squash and merge,” “Rebase and merge,” or “Create a merge commit.” To merge all the commits from the beta branch into the master branch, choose “Create a merge commit.”
  • Select “Confirm merge,” and all the modifications from your beta README file can be merged into the grasp README file.

GitHub Desktop: Utilizing an app

All through this tutorial, we’ve used a mixture of Git commands and the GitHub website, however you may also work together with GitHub using a devoted app. Purposes may be notably helpful when you’re first getting to grips with GitHub, as they allow you to carry out complicated tasks without having to know a tonne of Git commands.

In this last section, I’ll show how to setup the common GitHub Desktop app, and then use it to carry out some important GitHub actions.

  • Head over to the GitHub Desktop website and obtain the latest model.
  • Launch the ensuing ZIP file.
  • Launch GitHub Desktop, and when prompted choose “Sign into GitHub.com”
  • Enter your GitHub username and password. You need to now be taken to the primary GitHub Desktop consumer interface.

Creating local and distant repositories, with out Git instructions

You need to use GitHub Desktop to join to an present repository, but this software makes it notably straightforward to create a pair of related native and remote repositories.

On this part, I’ll show you how to create two new repositories, and then push a file from your native machine to the distant GitHub servers, utilizing the GitHub Desktop app.

  • Launch GitHub Desktop, if you haven’t already.
  • Inside the app, select “File > New Repository” from the menu bar.
  • Give your repository a name and provide an outline.
  • Specify the place this local repository must be created in your pc, both by typing the full file path or by choosing “Choose…” after which navigating to the desired location.
  • When you’re proud of the info you’ve entered, click “Create repository.”
  • To create a corresponding distant repository, choose the “Publish repository” button.

SelectGitHub Desktop's

  • Head over to GitHub, and you ought to notice that a new, empty repository has been created in your account.

Push to origin: Building your commit

Now you can work on a venture inside your native repository, as regular, and commit your work as and when required. As before, let’s attempt pushing a dummy README to our distant repository:

  • Navigate to the location the place you created your native repository. If you’ve forgotten where this is, then GitHub Desktop has a helpful “Show in Finder” button, or you can select “Repository > Show in Finder” from the GitHub Desktop menu bar.
  • Create or find the file that you want to commit to GitHub. Keep in mind that this file shall be publicly out there, so be sure that it doesn’t include any private info! I’ll be using a README text file.
  • Drag and drop your chosen file into your native repository. The GitHub Desktop app ought to now replace to display all the modifications you’ve made to the native repository.

The GitHub Desktop app displays all the changes made to your local repo

  • In the direction of the bottom-left of GitHub Desktop, enter a summary and a description explaining the work that’s included on this commit.
  • To organize your commit, click on the “Commit to master” button.
  • When you’re prepared to push your modifications to GitHub, select “Push origin” from the GitHub Desktop toolbar.
  • Head again over to GitHub.com – your file should now be obtainable in your distant repository.

GitHub Desktop can carry out a wide range of further duties, so if you favor interacting with GitHub utilizing an software, then you ought to take a look at GitHub Desktop’s docs for more info.

Wrapping up

This article coated everything you need to know, so as to start utilizing GitHub. We looked at how you can full all the essential GitHub tasks, together with creating native and remote repositories, submitting pull requests, and merging multiple branches.

To help present an summary of all the totally different ways in which you can work together with GitHub, we moved between using Git commands, the GitHub.com web site, and the GitHub Desktop software. Which technique do you choose? Let us know in the comments!