Community is a large part of open source. After all, Open Source projects can't thrive without a strong network of people (community) who contribute towards it, either through code contributions, design, documentation, financial contributions, advocacy, or adoption.

This article covers why community is important in Open Source, what a community manager role involves, and how to get started. I’ve also included additional resources, and some real life experiences from the Open Source Community to help you get started.

Table of Contents

1. Why Community?
2. Why are Open Source Community Managers Important?
3. Skills to have as an Open Source Community Manager
4. Roles of an Open Source Community Manager
5. How to Get Started as an Open Source Community Manager
6. How to Find Open Source Projects to Contribute To
7. Additional Resources

Before we head into the nitty-gritty of what an Open Source Community manager does, let’s take a look at the essence of community in open source.

Why Community?

The heart of a community is that it's a place where people gather, exchange thoughts, and collectively create something greater than the sum of its parts.

In the open source realm, this concept takes a digital form. Communities form around shared interests and the desire to build, refine, and improve software collaboratively. It's not just about the code – it's about the people behind it. A vibrant community enhances creativity, accelerates learning, and fosters an environment where innovation thrives.

Open source is a community project. It never happens in isolation, and it grows because of the communities that form around it. Whether you interact with open source as a user, contributor, or both, you're part of a community, and the community is better for it.

There are a variety of reasons why people join open source communities. A large number of people join because they are required to work on the software as part of their job. Maybe their organizations recruited them to develop it or maybe the project is essential to their jobs.

Some participate in communities in order to have a direct influence on the software development process that produces the essential functions for them and their businesses. Some join because communities provide them with chances to collaborate with and learn from others, which helps them hone their abilities.

Some people sign up because it enables them to work with others to solve a problem they're having. Some sign up because they think it's important to add to a shared resource that benefits everyone. And others sign up in order to socialize, or for a sense of identity and belonging.

So it's important to nurture the community, support its members, and find a way to reach a sustainable outcome.

Why Are Open Source Community Managers Important?

As community projects grow and become more complex with multiple product owners and contributors, they need to have a community manager.

Open source community managers act as the conductors, bringing together developers, users, and contributors to create a masterpiece. They are the bridge between the project and its community, ensuring that everyone's voice is heard, questions are answered, and collaboration flows seamlessly.

Skills to Have as an Open Source Community Manager

So, what makes a good community manager in the open source world? Here are some key qualities, encompassing both soft and hard skills:

• Communication Skills: A community manager must be an excellent communicator. Whether it's responding to GitHub issues, moderating discussions, or providing updates, clear and concise communication is key.
• Empathy: Understanding the needs and concerns of community members is crucial. OSCMs should have a high level genuine interest and concern for teaching others, engaging a range of stakeholders and balancing tensions as they arise.
• Adaptability and Inclusivity: Open source is dynamic, with contributors from diverse backgrounds. An effective community manager adapts to different communication styles and cultural nuances.
• Technical Understanding: While not mandatory, having a basic understanding of the technical aspects of the project can be immensely helpful. It facilitates better communication with developers and enhances problem-solving.
• Organizational Skills: Juggling multiple tasks, from handling forums to managing events, requires organizational finesse. Keeping things structured ensures that no message gets lost in the noise.
• A good command of English is a requirement for most jobs.

Recommended tools to learn as a community manager

Knowledge of all or some of these tools are 'nice-to-have'. You can check out job descriptions of OSCMs in job openings, and try to develop some or all of the skills that appear frequently.

Here are a few of the core skills you should learn:

• Git, GitHub, GitLab, and other version control systems for collaborative work.
• How to use Discord, slack, Discourse, and other communication tools.
• Markdown for documentation

Roles of an Open Source Community Manager

OSCMs work at the intersection of Developer Relations, Evangelism, Marketing, Engagement, and Advocacy. In fact, the majority of these responsibilities overlap so greatly that they are practically indistinguishable from one another.

Often times, the role of an open source community manager may be tricky to define, as there are many different aspects to it. Let's take a look at some of the responsibilities of OSCMs:

• Community Engagement—an open source community manager facilitates engagement by moderating, engaging, and supporting users in forums including Discourse, GitHub, and Reddit, Discord, Slack and Github discussions.
• Community recognition—when everyone feels like they have a home where they're appreciated, they’ll be encouraged to stay engaged. Impactful and meaningful recognitions such as celebrating community successes, sending swag, and recognizing top contributors is a great way to encourage a sense of belonging among contributors and build trust.
• Creating and managing new community and outreach programs—this could involve organizing meetups, events, hackathons, advocacy, and content (articles or newsletters, for example)
• Coordinating with other departments—such as product, engineering, and content marketing—to support community initiatives.
• Partner Management—keeping up to date with the various stakeholders and partners involved in the project
• Creating a good open source project—making the project discoverable, making the project easy to use, communicating feedback to project to maintainers, keeping documentation up to date and readable, spotting areas where the project could use more help.

How to Get Started as an Open Source Community Manager

Credit: John Cameron

Because of how vast and evolving the roles of OSCMs are, I sat down with three Open Source Community Managers to learn about how they started, and what their roles entailed. Each of these experiences differed in how the role was defined, the hiring process, and in their goals.

I spoke with Fiberesima Ibi, an Open Source Community Manager at Gnome Africa, whose journey started with an email and a desire to find the right open-source community where she could apply her skills.

“After exploring a few communities, I felt lost. Then, I stumbled upon GNOME Africa through Regina's tweet, and it clicked instantly.

What drew me in was GNOME's commitment to crafting an intuitive, accessible desktop environment. The African community was set up towards exposing Africans to contribute to GNOME projects and other open-source technologies.”

Fibi reached out to Gnome via mail, expressing her interest, which opened doors to becoming an Open Source Community Manager for GNOME Africa.

Speaking of her current role since joining the community, she has this to say:

“Reviving the community was a challenge I embraced. I've been focused on crafting strategies to boost engagement and contributions, and creating a welcoming space for everyone.

We recently started an X-series on “Recognizing your value as a contributor in the open source ecosystem” with the aim to empower contributors to leverage their open source journey to advance their career and personal growth.”

It's been an incredible journey of learning, empowering contributors, and advocating for GNOME's growth for Fibi. The main lesson she learned?

“Taking that first step, reaching out, and not underestimating the power of asking.”

Justin Dorfman (Open Source Community Manager at Sourcegraph) also shared his story:

“Starting in high school, I wanted to be a software engineer. The only problem was I wasn’t good at it. I would screw things up and sometimes create more work for senior engineers.

One of my mentors saw that I was very passionate and knowledgeable about open source and convinced me there were other ways to contribute.

At first, I was skeptical, but as the months and then years passed, I found I was making more impactful contributions to open source than I ever could have imagined. A non-code contributor as some say.”

“In my current role, I work with our community to get questions answered, I work with our engineering team to get content created, I recruit talented community members to join our company, and I make sure the open source dependencies we rely on are funded. From time to time, I update our docs or about the page, but the bulk of my time is spent out of an IDE.”

For Uriel Ofir, Community Manager at Ma'akaf, he recognized the challenges faced by Israeli programmers to connect with open source projects, and he built a community to address that.

As a community manager at Ma'akaf, my role is centered around creating an inclusive environment where Israeli programmers can seamlessly connect with open-source projects.

From overseeing our dynamic Discord server to facilitating knowledge-sharing through WhatsApp groups, every aspect of my work aims to foster collaboration within our community.

We provide valuable opportunities for members to network and learn by organizing physical and online meetups. Ultimately, my journey involves empowering individuals to engage, learn, and contribute effectively to the world of open source.

Many OSCMs perform their roles as volunteers, but sometimes communities hire for community managers. If you’re contributing on a voluntary basis, you’ll have a delicate balance to strike with regards to the community’s needs and your own commitments.

Open Source Community Manager Roadmap

Regardless of how you joined, it might still be intimidating to start as a new community manager, so it's better to approach the position similarly to any other development project. You'll need to identify your goals, define your idea of success, and then plan every step of your journey.

Here’s a simple getting started guide for new OSCMs:

• Choose an open source community that aligns with your goals.
• Join in—attend their events, join relevant groups, and connect with peers
• Contribute—read their documentation, check out the product features, make a contribution
• Volunteer—let the maintainers see your work, and approach to community management.

There are other ways to get started. In my case, I started my journey to Open Source Community Management through the Github Social Impact Digital Public Goods Open Source Community Manager, where I currently volunteer with Open Terms Archive as an Open Source Community Manager.

My role as a community manager involves various responsibilities. I help ensure that everyone collaborates in an effective way with less friction, I onboard users and contributors, I help improve our documentation, and I review and collaborate on pull requests.

How to Find Open Source Projects to Contribute to

I recommend starting with products, tools, and communities you already use or are a part of when looking for open source projects you want to contribute to. Since you are already familiar with the technology, there won't be much need for you to learn about it.

• Utilize your social media connections: Search for announcements on Twitter and LinkedIn.
• Use search engines to search with keywords such as "open source community manager"
• Send a pitch to maintainers of open source communities you're part of.

Additional Resources

Ready to dive deeper? Here are some resources to fuel your open source community management journey:

1. Building leadership in Open Source Communities by Linux Foundation
2. [Becoming]: Open Source Community Manager by Mary Blessing
3. The significance of a community manager in your Open Source project by Mary Blessing
4. How to Use Git and GitHub – Introduction for Beginners by Segun Ajibola
5. Community Management Resources by Amarachi Johnson-Ubah

Thank you for taking the time to read. I hope this article has been helpful, and if you have any questions, don't hesitate to reach out to me via Twitter.

Technical writing might also be for you if you love learning by teaching others, contributing to open source projects and teaching others how to do so, too, or basically enjoy explaining complex concepts in simple ways through your writing.

Let's dive into the fundamentals and learn about what you should know and consider when getting started with technical writing.

Table of Contents

In this article, we’ll be looking at:

• What Technical writing is
• Benefits of Technical Writing
• Necessary skills to have as a Technical Writer
• The Technical Writing Process
• Platforms for publishing your articles
• Technical Writing Courses
• Technical Writing forums and communities
• Some amazing technical writers to follow
• Final Words and references

What is Technical Writing?

Technical writing is the art of providing detail-oriented instruction to help users understand a specific skill or product.

And a technical writer is someone who writes these instructions, otherwise known as technical documentation or tutorials. This could include user manuals, online support articles, or internal docs for coders/API developers.

A technical writer communicates in a way that presents technical information so that the reader can use that information for an intended purpose.

Benefits of Technical Writing

Technical writers are lifelong learners. Since the job involves communicating complex concepts in simple and straightforward terms, you must be well-versed in the field you're writing about. Or be willing to learn about it.

This is great, because with each new technical document you research and write, you will become an expert on that subject.

Technical writing also gives you a better sense of user empathy. It helps you pay more attention to what the readers or users of a product feel rather than what you think.

You can also make money as a technical writer by contributing to organizations. Here are some organizations that pay you to write for them, like Smashing Magazine, AuthO, Twilio, and Stack Overflow.

In addition to all this, you can contribute to Open Source communities and participate in paid open source programs like Google Season of Docs and Outreachy.

You can also take up technical writing as a full time profession – lots of companies need someone with those skills.

Necessary Skills to Have as a Technical Writer

Understand the use of proper English

Before you consider writing, it is necessary to have a good grasp of English, its tenses, spellings and basic grammar. Your readers don't want to read an article riddled with incorrect grammar and poor word choices.

Know how to explain things clearly and simply

Knowing how to implement a feature doesn't necessarily mean you can clearly communicate the process to others.

In order to be a good teacher, you have to be empathetic, with the ability to teach or describe terms in ways suitable for your intended audience.

If you can't explain it to a six year old, you don't understand it yourself. Albert Einstein

Possess some writing skills‌‌

I believe that writers are made, not born. And you can only learn how to write by actually writing.

You might never know you have it in you to write until you put pen to paper. And there's only one way to know if you have some writing skills, and that's by writing.

So I encourage you to start writing today. You can choose to start with any of the platforms I listed in this section to stretch your writing muscles.

And of course, it is also a huge benefit to have some experience in a technical field.

The Technical Writing Process

Analyze and Understand who your Readers are

The biggest factor to consider when you're writing a technical article is your intended/expected audience. It should always be at the forefront of your mind.

A good technical writer writes based on the reader’s context. As an example, let's say you're writing an article targeted at beginners. It is important not to assume that they already know certain concepts.

You can start out your article by outlining any necessary prerequisites. This will make sure that your readers have (or can acquire) the knowledge they need before diving right into your article.

You can also include links to useful resources so your readers can get the information they need with just a click.

In order to know for whom you are writing, you have to gather as much information as possible about who will use the document.

It is important to know if your audience has expertise in the field, if the topic is totally new to them, or if they fall somewhere in between.

Your readers will also have their own expectations and needs. You must determine what the reader is looking for when they begin to read the document and what they'll get out of it.

To understand your reader, ask yourself the following questions before you start writing:

• Who are my readers?
• What do they need?
• Where will they be reading?
• When will they be reading?
• Why will they be reading?
• How will they be reading?

These questions also help you think about your reader's experience while reading your writing, which we'll talk about more now.

Think About User Experience

User experience is just as important in a technical document as it is anywhere on the web.

Now that you know your audience and their needs, keep in mind how the document itself services their needs. It’s so easy to ignore how the reader will actually use the document.

As you write, continuously step back and view the document as if you're the reader. Ask yourself: Is it accessible? How will your readers be using it? When will they be using it? Is it easy to navigate?

The goal is to write a document that is both useful to and useable by your readers.

Plan Your Document

Bearing in mind who your users are, you can then conceptualize and plan out your document.

This process includes a number of steps, which we'll go over now.

Conduct thorough research about the topic

While planning out your document, you have to research the topic you're writing about. There are tons of resources only a Google search away for you to consume and get deeper insights from.

Don't be tempted to lift off other people's works or articles and pass it off as your own, as this is plagiarism. Rather, use these resources as references and ideas for your work.

Google as much as possible, get facts and figures from research journals, books or news, and gather as much information as you can about your topic. Then you can start making an outline.

Make an outline

Outlining the content of your document before expanding on it helps you write in a more focused way. It also lets you organize your thoughts and achieving your goals for your writing.

An outline can also help you identify what you want your readers to get out of the document. And finally, it establishes a timeline for completing your writing.

Get relevant graphics/images

Having an outline is very helpful in identifying the various virtual aids (infographics, gifs, videos, tweets) you'll need to embed in different sections of your document.

And it'll make your writing process much easier if you keep these relevant graphics handy.

Write in the Correct Style

Finally, you can start to write! If you've completed all these steps, writing should become a lot easier. But you still need to make sure your writing style is suitable for a technical document.

The writing needs to be accessible, direct, and professional. Flowery or emotional text is not welcome in a technical document. To help you maintain this style, here are some key characteristics you should cultivate.

Use Active Voice

It's a good idea to use active voices in your articles, as it is easier to read and understand than the passive voice.

Active voice means that the subject of the sentence is the one actively performing the action of the verb. Passive voice means that a subject is the recipient of a verb's action.

Here's an example of passive voice: The documentation should be read six times a year by every web developer.

And here's an example of active voice: Every web developer should read this documentation 6 times a year.

Choose Your Words Carefully

Word choice is important. Make sure you use the best word for the context. Avoid overusing pronouns such as ‘it’ and ‘this’ as the reader may have difficulty identifying which nouns they refer to.

Also avoid slang and vulgar language – remember you're writing for a wider audience whose disposition and cultural inclinations could differ from yours.

Avoid Excessive Jargon

If you’re an expert in your field, it can be easy to use jargon you're familiar with without realizing that it may be confusing to other readers.

You should also avoid using acronyms you haven't previously explained.

Here's an Example:

Less clear: PWAs are truly considered the future of multi-platform development. Their availability on both Android and iOS makes them the app of the future.

Improved: Progressive Web Applications (PWAs) are truly the future of multi-platform development. Their availability on both Android and iOS makes PWAs the app of the future.

Use Plain Language

Use fewer words and write in a way so that any reader can understand the text.‌‌ Avoid big lengthy words. Always try to explain concepts and terms in the clearest way possible.

Visual Formatting

A wall of text is difficult to read. Even the clearest instructions can be lost in a document that has poor visual representation.

They say a picture is worth a thousand words. This rings true even in technical writing.

But not just any image is worthy of a technical document. Technical information can be difficult to convey in text alone. A well-placed image or diagram can clarify your explanation.

People also love visuals, so it helps to insert them at the right spots. Consider the images below:

First, here's a blog snippet without visuals:

Here's a snippet of same blog, but with visuals:

Adding images to your articles makes the content more relatable and easier to understand. In addition to images, you can also use gifs, emoji, embeds (social media, code) and code snippets where necessary.

Thoughtful formatting, templates, and images or diagrams will also make your text more helpful to your readers. You can check out the references below for a technical writing template from @Bolajiayodeji.

Do a Careful Review

Good writing of any type must be free from spelling and grammatical errors. These errors might seem obvious, but it's not always easy to spot them (especially in lengthy documents).

Always double-check your spelling (you know, dot your Is and cross your Ts) before hitting 'publish'.

There are a number of free tools like Grammarly and the Hemingway app that you can use to check for grammar and spelling errors. You can also share a draft of your article with someone to proofread before publishing.

Where to Publish Your Articles

Now that you've decided to take up technical writing, here are some good platforms where you can start putting up technical content for free. They can also help you build an appealing portfolio for future employers to check out.

Dev.to is a community of thousands of techies where both writers and readers get to meaningfully engage and share ideas and resources.

Hashnode is my go-to blogging platform with awesome perks such as custom domain mapping and an interactive community. Setting up a blog on this platform is also easy and fast.

freeCodeCamp has a very large community and audience reach and is a great place to publish your articles. However, you'll need to apply to write for their publication with some previous writing samples.

Your application could either be accepted or rejected, but don't be discouraged. You can always reapply later as you get better, and who knows? You could get accepted.

If you do write for them, they'll review and edit your articles before publishing, to make sure you publish the most polished article possible. They'll also share your articles on their social media platforms to help more people read them.

Hackernoon has over 7,000 writers and could be a great platform for you to start publishing your articles to the over 200,000 daily readers in the community.

Hacker Noon supports writers by proofreading their articles before publishing them on the platform, helping them avoid common mistakes.

Technical Writing Courses

Just like in every other field, there are various processes, rules, best practices, and so on in Technical Writing.

Taking a course on technical writing will help guide you through every thing you need to learn and can also give you a major confidence boost to kick start your writing journey.

Here are some technical writing courses you can check out:

• Google Technical Writing Course (Free)
• Udemy Technical Writing Course (Paid)
• Hashnode Technical Writing Bootcamp (Free)

Technical Writing Forums and Communities

Alone we can do so little, together, we can do so much ~ Helen Keller

Being part of a community or forum along with people who share same passion as you is beneficial. You can get feedback, corrections, tips and even learn some style tips from other writers in the community.

Here are some communities and forums for you to join:

• Hashnode
• Dev.to
• Technical Writing World
• Technical Writer Forum
• Write the Docs Forum

Some Amazing Technical Writers to follow

In my technical writing journey, I've come and followed some great technical writers whose writing journey, consistency, and style inspire me.

These are the writers whom I look up to and consider virtual mentors on technical writing. Sometimes, they drop technical writing tips that I find helpful and have learned a lot from.

Here are some of those writers (hyperlinked with their twitter handles):

• Quincy Larson
• Edidiong Asikpo
• Catalin Pit
• Victoria Lo
• Bolaji Ayodeji
• Amruta Ranade
• Chris Bongers
• Colby Fayock

Final words

You do not need a degree in technical writing to start putting out technical content. You can start writing on your personal blog and public GitHub repositories while building your portfolio and gaining practical experience.

Really – Just Start Writing.

Practice by creating new documents for existing programs or projects. There are a number of open source projects on GitHub that you can check out and add to their documentation.

Is there an app that you love to use, but its documentation is poorly written? Write your own and share it online for feedback. You can also quickly set up your blog on hashnode and start writing.

You learn to write by writing, and by reading and thinking about how writers have created their characters and invented their stories. If you are not a reader, don't even think about being a writer. - Jean M. Auel

Technical writers are always learning. By diving into new subject areas and receiving external feedback, a good writer never stops honing their craft.

Of course, good writers are also voracious readers. By reviewing highly-read or highly-used documents, your own writing will definitely improve.

Can't wait to see your technical articles!

References

Introduction to Technical Writing‌‌

How to structure a technical article‌‌

Understanding your audience, the why and how

‌‌Technical Writing template

I hope this was helpful. If so, follow me on Twitter and let me know!

This article will help you learn the basics of Git and versioning in order to effectively collaborate and manage your software projects.

Contents

• What are git and version control?
• Setting up your Gitbash
• Initializing your repository
• Making your first commit in Git
• Creating a branch in Git
• Reverting to a commit
• Creating a remote repository
• Syncing your remote repository to your local repository
• Updating your git repository (local and remote)
• What does "Origin" mean?

Pre-requisites

I assume you already have an account on GitHub. If you don't, just head over to GitHub to create one.

You'll also need to download and install git bash from git-scm.com or gitforwindows.org (if you're running a Windows PC).

Now let's go ahead and learn about version control.

What are Git and Version Control?

Git is a version control system that is used to track changes that are made to a file or project. It was made by Linus Trovalds (the creator of the Linux operating system).

GitHub, on the other hand, is an open-source cloud-based collaboration platform that allows developers to easily share software and collaborate on different projects.

Everyone from open source projects to private teams and individual projects can use GitHub. You can just upload your code and track changes made in a project for future use.

Recap: Version control is a system that records changes to a file or set of files over time so that you can recall specific versions later.

Setting Up your Git Bash

For the purpose of this tutorial, we'll be creating a new folder, which I've named babysteps2git. We'll be using it as our local repository throughout this article.

A new folder created just for this Git tutorial

Inside this babysteps2git folder, we have a file, index.html, which we'll be using for instances. I created it from my favorite command line Interface, Cmder.

You can create yours by typing touch index.html inside the babysteps2git folder (this should be done from your command prompt) or you can create one from your text editor.

Now, let's set up our Git globally by configuring our username and email (if this is your first time using Git).

Open up git bash, then use the command git config --global [user.name](http://user.name/) "Your name" to configure your username and git config --global [user.email](http://user.email/) "Your email" to configure your email.

In the instance below, my GitHub username is emmanuellar while my email address is emmanuellar805@gmail.com.

Configuring git on your device

To check if your configuration has been added, type in git config --global user.name to check your username and git config --global user.emailto check your email.

If your configuration was successful, you'll have your username and email address returned once you type in these commands and hit enter.

Checking your configuration

Initializing your Repository

Now you'll want to tell Git "Look, this is the folder/directory where I want Git to work in right now."

To initialize a repository, make sure you're in the directory that you're working on. In my case here, it's the babysteps2git folder.

Then type in git init and hit enter.

Making Your First Commit in Git

Committing in Git is the equivalent of saving when working on documents. It's a way of saving your changes to the repository and store them with a unique ID and a message.

The ID and message can be used to trace back to the version of the project you need to check on. This is one of the differences between git commit and save as.

Before you can make a commit, you have to stage your work. Staging is a way of telling the system, "Hey, I've made a whole lot of changes to my work, but this one, that one, and this other one are the ones I want to save."

So when you want to add changes, do this: git add name-of-files.

If you want to add all the files you've made changes to, type in git add . instead. Just make sure you're inside the project folder.

Staging and Committing files in Git

After adding/staging the files, you can now commit them.

You should commit your changes using short but detailed commit messages like the one shown above.

To view the status of your repository, and to know which branch you're on, which files were modified, which code is staged, not staged, or ready to be committed, just use the code:git status.

Creating Branches in Git

Let's say you're working on different versions of a project or you're collaborating on a project with some friends or colleagues. It is important to have a branch called "master", which is the default branch for every repository that stores the original and modified code from the various contributors.

To collaborate or work on various versions of a project, we have to work from different branches.

By developing in branches, it’s not only possible to work on multiple versions of your code in parallel, but it also keeps the main master branch free from questionable code.

So, for our babysteps2git project, we can decide to have several branches, each housing a different version of the code.

To create a new branch in git, use the command, git branch nameOfBranch.

To check out (switch) to the new branch, use git checkout nameOfBranch.

The above 2 commands can be done simultaneously using the command: git checkout -b nameOfBranch.

Reverting to a Commit

Here comes another very interesting thing about Git: the ability to revert changes you've made over time, something CTRL+Z cannot do.

While working with Git, you might want to go back to a particular state of your code, or even revert to an older version of your work. You can do this by reverting to the particular commit you want to get back to.

Each commit we make has a unique ID attached to it. To get this ID, you can type in git log.

Alternatively, the output above can be logged in one line using git log --oneline.

From the above, you can see the ID and commit messages for each of the commits.

To revert, type in **git revert commit-ID**.

This command reverts to the state of that code at the time of that commit.‌

Creating a Remote Repository

To create a remote repository, we'll open up our GitHub account and click on the New button (as a first time GitHub user you'll probably see a green Create Repository button on yours instead).

Whichever way you do it, it'll take you to the page where you enter the name of your repository and a description of your project.

It also gives you the option to make your repository private or public.‌‌ You could also initialize your repository with a read me by ticking the read me check box.

###

When you click on create, a new repository would be created with a unique URL.

Syncing your remote repository to your local repository

Now that we've created our remote repository, we have to sync it with our local repository so they both can seamlessly communicate.

‌‌Open up your git bash, navigate to the folder you're working on, and enter the following code: git remote add origin url.

Updating your git repository (remote and local)

Let's go ahead and add some code to our HTML file:

<html lang="en"> 
    <head>     
    <meta charset="UTF-8">     
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge>
    <title>Document</title> </head> 
        <body>         
            <label for="inputEmail" class="sr-only">Email Address</label>     
            <input type="email" class="form-control" id="inputEmail" placeholder="Password"> 
        </body> 
</html>

‌Let's repeat the process of staging and committing our changes:

git add index.html‌‌git commit -m "added a form"

‌‌As it is, our local repository is currently a commit ahead of the remote repository.

To update the remote repository, we'll have to push our work from the local repository to the remote repository using the code: git push origin master.‌‌ "master" is the default branch for every repository and most times houses the main project code.‌

You can also choose to create a new branch if, for example, you made a new feature but you are worried about making changes to the main project (master branch).‌‌

Just type in git branch branchName to create a new branch, and use git checkout branchName to switch to the new branch.

‌‌You can always use git branch to confirm the branches in this repository. The branch name with asterisks next to it indicates which branch you're pointed to at a given time.

You can also push changes from your new branch to your remote repository with git push origin branchName.

When you push to the remote repository, GitHub will automatically create the branch for you on your remote repository. This allows people to see the changes you've made.

‌‌You might also want to update the main project branch (master branch) with the contents of the remote new branch.

You can do this by switching to the master branch and running git pull origin newBranch.‌‌ This updates the master branch with all the changes implemented on the new branch.

What does "origin" mean?

‌‌Origin is a shorthand name for the remote repository that a project was originally cloned from. More precisely, it is used instead of that original repository's URL, and makes referencing it easier.‌‌

So to push your changes to the remote repository, you can use either of the following commands: git push origin nameOfBranch or git push https://github.com/username/reponame.git nameOfBranch‌‌.

Note that you could be prompted to enter your username and password. Your password won't show as you're entering it. Just type it in correctly and hit enter.

Conclusion

We've just looked at a step by step guide to using Git for the first time. Feel free to reference it whenever you get stuck.

You don't have to commit the commands to memory – you'll be able to remember them with time. :)

‌‌That's all for now!

I hope you enjoyed this article. You can follow me on Twitter.

‌‌