DEV Community: Javi Palacios

Getting started with Git

Javi Palacios — Mon, 01 Jun 2026 08:00:59 +0000

We already know What is Git and we learned How to Install Git on our Operating System. Now is about time that we learn how to do our first commit with this amazing Version Control Software. :)

From now on, all the commands are valid for UNIX environments, if you are following this course from Windows, then you have three options: Ignore all the commands in this article, except Git commands and doing all other operations graphically; Convert manually the commands we use to the correct ones for Windows cmd.exe or PowerShell, or the very last option but the most recommended: Install Cygwin, it's a UNIX Terminal Emulator and thanks to Cygwin, you can use UNIX commands like if you were using a Linux Terminal without having to worry about wrong commands or special syntax.

$ mkdir git-tutorial
$ cd git-tutorial
$ git init

With mkdir we are creating a new folder for our project (in this case for this course), with cd we get into the project's folder and with git init we tell Git to start the Version Control on this folder. When we type these commands on UNIX environments we can check everything went OK with a simple command ls -a and we will see there's a hidden folder named .git (On Windows is hidden but Windows-way) and is in this folder where all our files are going to be stored with all the changes we make to them. Let's see what git status says:

On branch master
No commits yet
nothing to commit (create/copy files and use "git add" to track)

We will explain what a branch is in future articles. Checking with git status is a good way to check that everything is created and working. We are going to create an HTML file with very basic HTML5 structure/code, if you are not familiar with HTML, don't worry about it now as the content of the file doesn't matter.

$ touch index.html
$ vim index.html

With touch we create the file and with vim we edit the same. The next code goes into the file.

<!DOCTYPE html>
<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>Our wonderful Git tutorial</title>
  </head>
  <body>
    <h1>Getting started with Git</h1>
  </body>
</html>

And now again, let's see what git status has to say.

On branch master
No commits yet
Untracked files:
  (use "git add <file>..." to include in what will be committed)
        index.html
nothing added to commit but untracked files present (use "git add" to track)

If your screen looks similar to this, then everything went normal and if you have a look on the output you will read that Git found new file(s) (The HTML file we created before) but we didn't told Git that we wanted to add this file to the queue for the next commit. We need to add manually the files we want to add to the next commit, easy, just with git add index.html but in case you have more files and let's say you want to add to the queue all the files in the current folder, a simple git add . will add all the files from this folder to the queue. Now let's try again with git status:

On branch master
No commits yet
Changes to be committed:
  (use "git rm --cached <file>..." to unstage)
        new file:   index.html

This is the exciting part, the mega famous commit. A commit for Git means, we are happy with all the changes and files in this folder and they are ready for putting them in the release. *Commit*ting is a must, every change, every bug fix (hope you don't need to commit many of those :P) and every new implementation you do must be reflected with a commit. Why? Basically, because the best feature of a Version Control Software like Git, is the ability to revert to any of these changes in the time line or in other words going back thru all the commits you did, let's say you committed a bug fix that doesn't work as you expected it to work then, with Git, you can just revert everything back as it was before the bug fix commit. For our first commit, all we need to type is git commit -m "Initial commit"

[master (root-commit) 2fdbe1d] Initial commit
 1 file changed, 12 insertions(+)
 create mode 100644 index.html

And now our huge project is safe. Okay, okay, maybe is not a biiiig project and you just think 'Why I should use a Version Control??' but believe me, even for this small HTML page, we need to think bigger, look at the future and just imagine this small project becoming a 20 file project with around 800 lines per file. You would be thankful to have a way to go back in case your new Payment Gateway Code gets frozen just in the middle of a transaction and the old code was working just perfect.

If you want to understand in depth what we have done so far is necessary to understand the three States of Git, I encourage you to read the article.

Just quick reminder, all the files we create or modify for this course are available in our Git Tutorial Repo and in our Main GitHub.

And Remember… never stop programming!

How to install Git on Linux, macOS and Windows

Javi Palacios — Sat, 30 May 2026 17:12:48 +0000

Now that we already explained What the Heck is Git, probably you're thinking; how can I get it on my PC? Well, then look no more, in this course we're going to show you how to Install Git on Linux, macOS or Windows.

During this How To, we won't use any GUI (Graphical User Interface), instead, we will use CUI (Character User Interface) or globally known as Command Line Interface. Why? Simple, with the Graphical Front-end we loss many features that are not implemented on the available GUI's for Git. Anyways, if you would like to try a beautiful designed App for Git, which personally, I like, is GitHub Desktop. As you can notice, this App is developed by GitHub (hence the name), works perfect for managing local and remote repositories, as the only exception is the remote repo must be on GitHub. There are many alternatives for managing repos from the comfort of your PC but in this course we will focus on installing Git rather than showing all the alternatives (maybe in a next article?).

Installing Git in Linux

On a Linux environment, the easiest way to get any software is thru the Package Manager included in your distribution (aptitude/apt, pacman and portage to name a few), Why? because all you need to do is type in a console a simple command and the Package Manager does all the job: dependencies, conflicts with other packages/software and lately, updating the software for bug fixes and new features are effortless which makes the job of maintaining everything up to date easier. Let's see how to install Git thru the main Package Managers.

Debian

# apt install git

Ubuntu

# apt install git

If you want to use a more recent version you can install the same package from the unstable repository

# add-apt-repository ppa:git-core/ppa
# apt update
# apt install git

OpenSUSE

# zypper install git

ArchLinux

# pacman -S git

Gentoo

# emerge --ask --verbose dev-vcs/git

If you don't see your Distribution (Linux Flavour) in this list, we presume that you are familiar with compiling and working with the console, you will find your way around ;)

Installing Git on macOS

Since a few releases, you can install Apple Developer Tools on macOS which includes Git but not the latest version. If you want to know what Git version you have installed just go into a terminal and type the next command:

$ git --version

If you have the Apple Developer Tools installed, that command will output the version of your currently installed Git, if not, probably will ask you to install the Developer Tools.

Don't worry, there's another option available for all of us who don't like to have outdated software. Homebrew is a Package Manager for macOS and help us install new software hassle-free. Would you like to try?

$ /usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

And after the installation is completed, let's use it:

$ brew install git

You're all set!

Installing Git on Windows

Git is designed and developed for Unix environments, as you know, Windows has nothing to do with Unix, the installation on Windows is a bit more fuzzy. In this How To we are not installing Git on Windows, what we are doing is, install a Linux CUI Emulator and get Git working this way.
In recent versions, Git gives the option to be run directly from Windows Command Line (cmd.exe), equaling Windows version to the Linux (or macOS), this way, the user doesn't feel much difference working with Git.

We need to visit the Git for Windows and download our copy according to our computer's specifications. There's no instructions for this part of the installation... because there are no steps.. just Next, Next, Next, Next, Finish! If everything went Okay, we should be able to run Git from cmd (cmd.exe)

$ git --version

If the output we get is the version currently installed, then, everything is ready to go.

Setting up Git

This part is universal as it works independently from the Operating System you use.

The first step is setting up our username and email, this way, whenever we submit a change to the repository, we can be able to track who did what changes to the code/repo. Change the commands with your own before executing these.

$ git config --global user.name "Your Name"
$ git config --global user.email your.email@example.com

We can set the default text editor when we do a commit

$ git config --global core.editor vim

And we can test the configuration for any errors:

$ git config --list

This is the end of this part of the course, we installed Git in different Operating Systems and we set it up for initial running! Keep an eye for more courses coming for this excellent Version Control Software. For now, you can learn how to do your first commit in Git. :)

Remember… Never stop programming!

What is Git?

Javi Palacios — Fri, 29 May 2026 13:16:31 +0000

Git is one of the Version Control Systems that have appeared over the time to make developers life easier. It's the last to arrive, although its youth in this case is a pro rather than a con. It has had the opportunity to meet deficiencies and defects of his predecessors (Subversion mainly) and it has come just to make the tasks that were once complex now ridiculously easy. By the way, this is another great project of a guy known as Linus Torvalds, maybe you've heard of him. :-P

Git is a free project, you can find the source code at GitHub to consult or to learn; most used programming language is C, so if you are interested in how people who most dominates this language write his code is a good idea to keep an eye on the repository.

What is a Version Control System?

We mentioned at the beginning of this article version control system but we don't have to give for known things maybe someone doesn't know, so what is a version control system? For us, as developers, mainly a way to keep track of the changes that we have been doing and be able to go back easily when something that we coded doesn't work as expected. We have to forget to remember how it was some part of the code when everything worked properly, and also forget to be commenting portions of code which then never removed and left there to remember in a sort of Horror Museum with code that no one knows what was doing or why it's there.

But that is not the only one of its virtues: a VCS also allows us to work in parallel (in Git thanks to the use of branches) in different versions of our application; on the one hand, because we don't know how to deal with a change, and we want to try different ways to finally see what is more efficient and discard others; on the other hand, because we are working at the same time (one or more than one person) in different parts of the project and that some portions of code modifications do not have why affect nor interrupt the rest of development… Basically, be able to auto-merge in many cases those changes and get everything under control.

Why Git rocks?

The main difference between Git and Subversion is that Git works at local. Subversion sent information of each change in the code to a server, which is who was keeping the timeline of your modifications. Git does this process on our own computer, whenever you use Git the answer is immediate because it doesn't depend on an internet connection… It's also the concept of the remotes (to add servers such as GitHub or GitLab… but also some less known as a coworker server or the server of our company) that we will see in depth later, but they're not needed in any case, just give us a window of our code and in some cases, through some configurations, extra services like Travis CI at GitHub, that is used to run our test battery every time we send a change so that we know if that change has passed the test or has broken something, this is a simple way to automate the test that everyone should have on each of the projects we do.

The non-dependence of an internet connection is something that is greatly appreciated, especially if at some point you've used a version control system that practically can do nothing if you don't have access to the server that houses all your information with all of your saved changes. If we are working as a team, we can work anywhere and simply require an internet connection when we want all the changes to be sent to a remote server to let others know what we've changed, or if you work on a personal project does not require internet connection for nothing… Oh, how wonderful is this!

We hope that you've been wanting to learn more about Git and that you are aware of upcoming publications, because in next chapters of this series we will learn how to install Git and we will discover major Git commands, how to use Git in a proper way, and if you want to go a step further to master Git we will review some of the most widely used conventions to make our experience with this version control system a success.

Never stop coding!