There is a wikipedia entry for "Free and open-source software" (often times abbreviated as FLOSS) another one for Free Software (not to be confused with "freeware") and yet another for open-source software. So it's worth taking a moment to explain what all these terms mean and their relationships. In the beginning, when there only existed a handful of computers which were giant machines that took up entire rooms, there really was no "market" for commercial software. Software (aka programs, applications or apps) was developed in research contexts like universities and thus generally accessible to anyone in those spaces. By the mid 70s and early 80s computers got small enough and cheap enough for a middle class person to own their own "personal computer" in their home. It was around this time that developers saw a new potential market for commercial software, and when we start to see software patents and End-User License Agreements begin to appear. This is what came to be known as proprietary software, software you pay to license and use.
Some developers at this time were very adamant about proprietary software (see Bill Gate's open letter to the Home Brew Computer Club) arguing that if users didn't pay to use software, developers would have no incentive to make it. Others felt proprietary software was unethical (see Richard Stallman's GNU Manifesto) which argued it was unethical to distribute proprietary software, because this type of software hid the source code from the users.
Before we go any further, it's important to understand what "source code" is. In the earliest days programs were written in "machine code" like binary (or Assembly languages, which to be honest was pretty much the same thing). It was incredibly difficult to write programs this way, it also meant that the code you wrote was always very specific to the "machine" you wrote it on. Later, thanks to the work of computer pioneers like Grace Hopper and others, we created "higher level programming languages" (languages like C, C++, Java, Python, JavaScript, etc.) which were much easier to write because they were designed for people (not machines). However, this meant that computers didn't understand this code, the code would have to be run through a "compiler" or "interpreter" first, which would turn this higher level language into machine code that the computer could actually run. This is how most programming works today, the developer writes the "source code" in a programming language, that code is then run through a compiler/interpreter to generate the actual application (the machine code) which the user can then run on their computer.
Now, lets return to the issue of proprietary software, or software that hides the source code from the user and only makes the compiled machine code (the app you can run/use) available to the end user for a fee. To many developers in the 1980s this was unethical, because if you hid the source code from the user the app could potentially be malicious and the user would have no way of knowing (because they can't review the source code to understand how it works behind the scenes, the app is essentially a black box). Furthermore, the user no longer had the ability to change/edit or share the software (which was the norm at that time, this is because most computer users then were also programmers, one needed to know how to program in order to use early home computers).
For this reason, these developers started the "Free Software" movement in opposition to the growing popularity of commercial "proprietary software." It's important to note that, the word "free" here does not mean "monetarily free", but rather free as in freedom, specifically the freedom to access the source code so that one could inspect it, change it and share their changes with others. Though Free Software is most often also monetarily free, it doesn't necessarily have to be. The term for software distributed at no monetary cost (regardless of whether the source code is available or not) is "freeware" (though that's a bit of antiquated term). Consider the Instagram app, it's monetarily free but it's not "Free Software" because you don't have access to the source code (if we could read Instagram's source code we'd be able to see all the different ways they track, record and analyze our behavior, which might make us feel very uneasy and think twice about using it).
Though Free Software began as an ideological movement, developers quickly realized that there were other practical benefits to sharing the source code to their applications openly and freely with the public. For one, it was more likely that your software would be adopted by more people quicker, which means you could grow a big user base and make money other ways, by charging for support for example or by selling user data. Another advantage was that while you might have a small team of core developers working on an app, the fact that it's source code is available means that anyone else could contribute to improvements even if they don't work for you. This would often happen because free software can be remixed into other apps and so there was incentive for other developers to contribute improvements or bug fixes.
Despite these advantages, it was hard for developers to convince their funders or corporate sponsors to release their source code for "free", the word "free" isn't very appealing in commercial contexts. So these developers, more concerned with the practical benefits of making source code available rather then the ideological reasons for doing so, decided to "rebrand" the movement as "Open Source Software". The word "open" has more of a commercial ring to it (like "open" for business). So, the movement split in two, this is where we see the term FLOSS (or Free/Libre Open Source Software) appear as an umbrella term which includes both the ideological camp of the "Free Software movement" and the more business oriented mindset of the "Open Source movement."
Which brings us to git and GitHub. If a software project was "free and open" and welcomed contributions from any developer around the world, it became necessary to create tools and workflows for organizing this distributed activity. It became the convention to use "version control" software to keep track of who was contributed what to a distributed project. Arguably the most popular version control tool out there today is git. Git handles the technical side of collaboration, but it's just a tool for tracking changes in the development process. GitHub, is a website that addresses some of the social sides of collaboration. Developers make profiles where they can share their FLOSS projects and meet other developers. You can easily remix other peoples projects and contribute back to the original, you can keep track of bugs and have discussions around the direction the software project can take. It's important to note that git isn't the only tool for version control and GitHub isn't the only site for handling the social stuff (there is also Bitbucket and GitLab), but git and GitHub are arguably the most popular.
I've put together a playlist of videos for you to watch at your own pace. The first explains (at a high level) what the open source development process looks like. The idea that a software project is open to contributions from anyone around the world might sound like chaos, but the reality is that version control provides a very structured framework for open collaboration. The videos that follow that one are a collection of GitHub case studies that will give you a sense of what open source projects look like today (from a cultural/social perspective). The last video in the playlist is a longer documentary that covers the history of the FLOSS movements for those of you more curious to hear about the details behind how all of this developed.