Demystifying Confusing Terminologies for Open Source Newbies

First off, let's all agree that Github can be a little confusing for newbies!!! Yes or Yes?

Have you ever felt overwhelmed by the sea of terminologies that engulf newcomers in the world of open source? As a budding contributor, you embark on a journey filled with excitement and curiosity 💃, only to find yourself surrounded by a confusing maze of words and acronyms that seem to be speaking an entirely different language. The enthusiasm that initially sparked your desire to contribute can quickly fade as you encounter terms like repository, fork, pull request, and issue tracker, leaving you feeling lost and unsure of where to begin🤯.

But fear not! You are not alone in this pursuit of open-source greatness. Many before you (like yours faithfully) have trodden the same path, grappling with the same confusing terminologies that can make even the most determined newcomers question their ability to contribute effectively. It was precisely this struggle & of course, Outreachy's blog prompt that moved me to write this blog post, to shed light on these perplexing terms and provide clear explanations that will empower you to navigate the open source landscape with confidence.

As you already know, I am contributing to Oppia.org as an intern with Outreachy and it's been an amazing time so far. Open source is a vibrant and collaborative world, bursting with opportunities for growth, learning, and making a meaningful impact. However, understanding the open-source "lingua" is crucial to unlocking its vast potential. By demystifying the terminologies that often leave newcomers bewildered, I aim to arm you with the knowledge needed to embrace your role as a contributor and make a genuine difference in the projects (like Oppia 😍💃) you care about.

As I embarked on my journey during my first Outreachy contribution phase in 2022, I quickly realized that the world of open source came with its own unique set of vocabulary. While I was excited to dive into new communities and make contributions, I encountered various terms that left me scratching my head (literally). However, rather than staying silent and letting this confusion persist, I chose to embrace the unknown and search for answers.

What Are These Terms?

One of the terms that had me stumped was "forking" amongst others! The Nigerian in me couldn't grasp it at first glance because why 🤯???

Oh well, I'm going to share 15 of these terms with you & try to embed the Oppia link to serve as an example of each term.

So let's go 🚀🚀...

Here's Oppia's github - https://github.com/oppia 💃

1. Repository:

https://github.com/orgs/oppia/repositories

A repository, often referred to as "repo," is a central location where all the project's files, version history, and related information are stored. It acts as a storage space for the project's source code and allows for collaboration among contributors. Repositories are typically hosted on platforms like GitHub, GitLab & others.

2. Fork:

(Is it for rice, abi is it for Garri?🙈)

Forking a repository means creating a personal copy of the original repository. It allows you to make changes to the codebase without directly affecting the original project. Forking is a common practice that enables collaboration, experimentation, and proposing changes through pull requests.

https://github.com/oppia/oppia-web-developer-docs . To get to this link, I simply clicked (randomly) on one of Oppia's repositories in the previous image (oppia-web-developer-docs). Now I'm here, all Yiga needs to do is look at the top right and i'll see the word "fork". Clicking on the drop-down arrow shows me the option of "forking" the "oppia-web-developer-docs" repo. Make sense? Okay let me share a screenshot!

Now clicking on that should take you to a similar page like the one below which you can use to "create fork" of any projects repo.

3. Pull Request (PR):

A pull request is simply a formal proposal to merge changes made in a forked repository back into the original project. So lets imagine I made a modification to Oppia's web-developer-docs when I "forked" it. This simply allows me to submit these code modifications or additions for review by the project maintainers. Pull requests facilitate discussion, feedback, and collaboration, ultimately leading to the integration of changes into the main project. Enough talk here's a screenshot of what this looks like...

4. Branch:

A branch is a parallel version of a repository's codebase that allows you to work on different features or bug fixes independently. It provides a segregated workspace, ensuring that changes made in one branch do not affect others. Branches are commonly used to isolate changes, experiment with new features, and collaborate with others without interfering with the main codebase. Here's where to find a branch on github pages: you click on the "<>code" tab and below that you will see "branches"...

I shared screenshots from two repos for this example: Oppia's & Facebook's.

5. Issue:

Here’s a link to Oppia’s web-developer-docs “issue” tab (github.com/oppia/oppia-web-developer-docs/i..).

An issue refers to a problem, bug, or enhancement request identified within a project. Issues can be opened by anyone, including you (yes you), to report bugs, suggest improvements, or discuss project-related topics. It serves as a means of communication between contributors and provide a structured way to track and prioritize tasks. To create a new issue on github just click in the green "new issue" button seen in the screenshot below.

6. Issue Tracker:

An issue tracker is a tool or system used to manage and track project-related issues. It allows contributors to create, assign, prioritize, and track the progress of issues. Issue trackers provide a centralized location to organize and document bug reports, feature requests, and other project-related tasks.

7. Git:

Git is a widely used distributed version control system. It helps track changes in files and facilitates collaboration among multiple contributors working on a project. Git enables efficient branching, merging, and versioning of code, ensuring that changes are well-managed and conflicts are resolved effectively.

This one my dears is long- you can read more here.

8. Merge:

Merging refers to combining changes made in one branch or repository with another. In the context of open source, it typically involves integrating approved pull requests into the main project. Merging ensures that the changes are incorporated into the project's codebase, enabling all contributors to benefit from the improvements. It is important to know that contributors who have "push access" can merge a pull request. You can also merge a pull request automatically if all requirements are met, you just need to configure it.

9. Code Review:

Code review is the process of examining code changes to ensure they meet quality standards, conform to project guidelines, and align with the project's goals. It involves reviewing code for readability, functionality, and adherence to best practices. Code reviews are conducted by project maintainers or experienced contributors to provide feedback, suggest improvements, and maintain code quality.

You might be feeling like "Shey we should not rest like this 🤯"?

*inserts pawpaw meme*

We are all still learning so don't sweat it! You can always bookmark this page and come back to it later, drop your questions as comments or ask me directly. Either way, you're not alone.

10. Continuous Integration (CI):

Continuous Integration is a development practice where changes to the codebase are regularly and automatically integrated into a shared repository. CI systems automatically build, test, and validate code changes, ensuring that they do not break the project's existing functionality. CI helps maintain code quality, detect issues early, and promote collaboration among contributors.

11. Continuous Deployment (CD):

Continuous Deployment is an extension of continuous integration that automates the process of deploying code changes to production environments. CD systems take verified code from the CI pipeline and deploy it to servers or platforms for end-users to access. This practice streamlines the release process, reduces manual errors, and ensures frequent and reliable software updates.

JSYK, 10 & 11 are also referred to in short form as "CI/CD"...

12. Documentation:

/github.com/oppia/oppia-web-developer-docs - The repo we have been using as our example is infact Oppia's documentation repository.

In simple words, documentation is the written information that accompanies a project, providing guidance, instructions, and explanations. Good documentation is crucial for open source projects as it helps new & existing contributors understand the codebase, contribute effectively, and maintain the project over time. Documentation may include installation guides, API references, code examples, usage instructions & lots more.

13. License:

A license is a legal agreement that defines the permissions, restrictions, and conditions under which a project's codebase can be used, modified, and distributed. Open source projects often use licenses that allow users to view, modify, and distribute the code freely. Popular open source licenses include the MIT License, Apache License, and GNU General Public License (GPL).

14. Community:

The community refers to the collective group of contributors, users, and stakeholders involved in an open source project. Open source communities are diverse and inclusive, fostering collaboration, knowledge sharing, and support. Engaging with the community through forums, mailing lists, chat channels, or attending events can provide valuable networking opportunities and help newcomers grow as contributors.

15. Maintainer:

A maintainer, also known as a project maintainer or a core contributor, is an individual or a group responsible for overseeing and maintaining an open source project. Maintainers review contributions, manage the project's roadmap, resolve conflicts, and ensure the project's overall health and development. They play a crucial role in guiding and supporting new contributors in their journey.

Final Words For Open Source Noobs:

Open source communities are rich with terminologies that can confuse newcomers. By familiarizing yourself with these terminologies, you can confidently navigate the open source landscape and contribute effectively.

Embrace the learning process, ask questions, and leverage the very supportive nature of open source communities to grow and excel in your open source journey.

Remember that it's perfectly acceptable not to know everything, especially when diving into a new field or community.

I hope the read was worth it. Till we e-meet again stay safe & good luck in your tech journey, I can't wait to hear or read your stories.

If you found this helpful, feel free to share it with your friends & leave a comment here.

Don't forget to keep in touch & follow Me, Outreachy & Oppia on social media!

Till next time...

XOXO

Yiga