Initialize Git and NPM

Git helps us track code changes, and NPM lets us leverage code resources.


In the last tutorial, we worked with Homebrew to install Node.js and NPM. This time around, we'll look at initializing version control with Git and package management with NPM. These tools help manage complexity as projects grow.

Version control

Version control is a way of tracking changes to source code.

Git is a tool that will track changes for us over time. Changes include folders, files, and code that is created, updated, or deleted.

When you initialize a project, Git creates a master or main branch. If you make a new branch, it contains all the code of the main branch. Thus, you can experiment with new features while keeping a separate foundation of code. In addition, you and other developers can commit changes to a branch over time, which creates a history of saved work.

There are different development models for using Git and source control. One model uses a master or main branch for production, a second branch for development, and others for new features or fixes.

After completing a new feature or fixing a software bug, you merge changes back into the main or development branch.

"Software versioning is the process of assigning either unique version names or unique version numbers to unique states of computer software."

Semantic versioning uses numbers with specific meaning to help manage software dependencies and track changes.

Git is essential for collaborating on teams.

There's a good chance you'll share the code you track locally on your computer using Git with other people. GitHub is a web interface for public or private projects. "It offers the distributed version control and source code management functionality of Git, plus its own features."

"In software development, distributed version control... is a form of version control in which the complete codebase, including its full history, is mirrored on every developer's computer."

Installing Git

Likely, you have Git installed on your computer.

For macOS, type the following into Terminal.

git --version

The result may look something like this.

git version 2.30.1 (Apple Git-130)

If you don't have Git installed already, you can use brew or an installer.

With Apple Git installed, I'm skipping the following command.

brew install git

Configuring Git

"The first thing you should do when you install Git is to set your user name and email address." To accomplish this step, let's look at using a private email address. Then we'll update the Git user name and email using commands shown in the guides below.

Optional email privacy

When you commit code to GitHub, your email may be publicly visible. To enable email privacy, visit settings in your GitHub account.

  1. User icon > Settings
  2. Click emails
  3. Activate the checkbox: Keep my email addresses private
  4. Copy your GitHub email

You can now paste your GitHub email address into your Git configuration (below). The format looks like this: [username]

Setting your commit email address

After making a commit to GitHub with your GitHub email you can try activating the setting, "Block command line pushes that expose my email."

Blocking command line pushes that expose your personal email address

Git configuration

Configure user information for all local repositories
git config --global "[name]"

Sets the name you want attached to your commit transactions
git config --global "[email address]"

Change the default branch

When you initialize a Git repository in the root or top-level of your project folder, it creates an invisible directory called .git with the default branch as master. Since GitHub uses the default branch of main, let's update this before initializing.

git config --global init.defaultBranch main

Verify Git settings

These configuration settings are stored in your home folder. To verify, go through the following commands in Terminal.

cd ~

ls -la

You can see a (previously hidden) folder called .gitconfig, which contains settings.

nano .gitconfig

The opened file shows your name, email, and default branch.

name = First Last
email =

defaultBranch = main

Hit ⌃X (control + x) to exit.

Configure default Git editor

We're using VS Code as our editor, so we want to configure our default editor for Git.

git config --global core.editor "code —-wait"

git config --global -e

Note: the instructions provided by Microsoft to, "run git config --global -e and use VS Code as editor for configuring Git" may not work properly. If this occurs, try appending the following details into the existing .gitconfig file.

    tool = default-difftool
[difftool "default-difftool"]
    cmd = code --wait --diff $LOCAL $REMOTE
  tool = code
[mergetool "code"]
  cmd = code --wait --merge $REMOTE $LOCAL $BASE $MERGED

"This leverages the --diff option you can pass to VS Code to compare two files side by side." More info.

Now VS Code will be used when Git needs you to type a message.

Initializing Git

First, we need to create a directory for our project, and then we can initialize Git in that folder. Continuing in Terminal, enter the following.

cd Desktop

mkdir backend

cd backend

git status


git status
fatal: not a git repository (or any of the parent directories): .git

The git command provides an overview of "common Git commands used in various situations."


git init

ls -la

You can now see a hidden file named .git in the project directory.

git status


On branch main

No commits yet

nothing to commit (create/copy files and use "git add" to track)

If we skipped the default branch setup step, git status would say, "On branch master" instead.

Git is now tracking our files.

Initializing NPM

"The public npm registry is a database of JavaScript packages, each comprised of software and metadata. Open source developers and developers at companies use the npm registry to contribute packages to the entire community or members of their organizations, and download packages to use in their own projects."

NPM adds the name and version to a local package.json file in your project when you install a package.

It's not unusual to utilize many third-party packages to build your software. However, the package.json file configuration also allows you to publish your packages. You can either go through a series of questions or use default settings to determine the values. Some of the questions or initial values may only make sense from the perspective of publishing a package. Either way, these are default settings that change over time, or you'll edit anyways.

To initialize with default settings, use the command line to enter the following.

npm init -y or npm init --yes

In your project directory, you should see that NPM created a package.json file. Inside the file, you can look at how the information is structured using JSON. "JavaScript Object Notation (JSON) is a standard text-based format for representing structured data based on JavaScript object syntax."

For now, there is nothing more to do. The important thing is that we now have a place to install JavaScript packages in the future. However, if you'd like to experiment, you can look at the other automated method of creating a package.json file.

To initialize step-by-step with a questionnaire, enter the following.

npm init

The result provides some further guidance.

This utility will walk you through creating a package.json file.
It only covers the most common items, and tries to guess sensible defaults.

See `npm help init` for definitive documentation on these fields
and exactly what they do.

Use `npm install <pkg>` afterwards to install a package and
save it as a dependency in the package.json file.

At each step, you can hit return (enter) to accept default values.

Updating NPM

Even though we've installed NPM via brew, you will periodically need to update. Occasionally, NPM will prompt you with details and update instructions. Here is the primary command to know.

npm install -g npm

Uninstall NPM

We looked at installing and uninstalling Node (and npm) in the previous tutorial. To uninstall NPM directly, use the instructions on the following page.


The main lesson in this tutorial is to use the commands git init and npm init -y.

Git tracks code changes, which becomes especially relevant as our project becomes more complex.

NPM gives access to more than a million packages that can save us oodles of time and provide ongoing convenience.

Of course, there is much more to learn about both of these tools. We'll cover more about each as it becomes relevant. Until then, you can always reference the documentation and explore if you're interested. The following article will look at a standard software design solution for full-stack web application development.