It's only been two weeks since I enrolled in the LuxDev Data Science, Analytics and AI program yet I've already learnt so much!
One of the first things I've been able to learn is how to take a project from a local folder in my PC and publish it to GitHub using Git and SSH.
For someone who is still building their skills in data and tech,terms like repositories,commits,staging,remotes and SSH keys were new to me at first. Working on my first project helped me understand these commands and also what happens behind the scenes.
So for a start,I decided to document my experience of taking my first GitHub project from a local folder to GitHub using Git and SSH.
Interestingly, I learnt that Git and GitHub are not the same thing. This is why understanding what each of them means became a very important step in my project.
Git is a version control system which runs in my PC and helps me keep track of changes made to files in a project.
As I work,I might change my code,update my analysis,add new files or fix mistakes. Git lets me keep track of the changes I make over time instead of having multiple edited copies of the same file. Each saved version is called a commit.
GitHub is an online platform where repositories from Git can be stored and shared.
Git does not need to work with GitHub as I can use it in my PC without up my project elsewhere.
However, GitHub becomes useful when I want to:
In a nutshell, this is the journey the local folder in my PC took to reach Github:
Project folder in my PC
`
Track changes with Git
`
Commit changes
`
Push to GitHub
I first created my project folder in my PC's file explorer and named it Kenya_Health_Records_Analysis.
Then I opened Git Bash and navigated to it using these commands:
cd Desktop
cd Kenya_Health_Records_Analysis
cd
(change directory) is a command that tells Git to enter a file or folder in simple terms.
I then proceeded to add a data and README.md file in the project folder:
mkdir data
touch README.md
mkdir
(make directory) is used to create a new file or folder from the Git Bash terminal but notice I did not use it to create the README.md file because touch
is used to create files with extensions like .md, .py or .ipynb .
I then copied my Kenya_Health_Records.csv dataset and pasted it into the newly created data file in my file explorer.
To confirm this in Git Bash I ran the ls
command which lists the contents of a file or folder.
This is what I could see:
ls data
Kenya_Health_Records.csv
Then I went ahead to briefly describe the project in the README.me using the echo
command:
echo "# Kenya_Health_Records_Analysis" >README.md
echo " Using Excel to analyze Kenya health records to uncover,trends,patterns and insights in healthcare data." >>README.md
echo
prints text while >
directs the text into the README.md file however >
can replace what is already in the README.md file that is why in the next line I used >>
which adds content below what is already there.
To view the full README.md I used the cat
command (which displays the contents of a file in the terminal) and ran cat README.md
which retrieved:
Using Excel to analyze Kenya health records to uncover,trends,patterns and insights in healthcare data.
I then ran:
git init
This command initializes a new Git repository and Git begins to manage the project. It also added a new hidden .git
file in the project folder.
One of the most useful Git commands is:
git status
This tells me what Git can see or what is happening inside my repo. At first it told me that both the data and README.md
were untracked files meaning that Git had not been told to include them in the project history or to commit.
To stage both files I used:
git add .
The dot tells git to add everything in the current directory.
I then checked the status again using:
git status
The files appeared under the changes to be committed.
I then created my first commit:
git commit -m "Add Kenya Health Record Analysis"
The -m
allows me to provide a message that explains what I changed.
Hence a commit message can explain what happened at different points in time in the project's history if written clearly.
I then ran:
git log --oneline
This retrieved my unique commit ID and my commit message.
After creating the project locally, I went to GitHub and created a new repository and named it the same way I had in my File Explorer:
Kenya_Health_Records_Analysis
This would become an online version of my local Git repository. I also learnt that even though I created the repo and named it the same way,it does not automatically upload my local files.
I still needed to connect my local repo to the GitHub repo and push the changes and this where an SSH Key comes in.
To me, it sounded like such a complex tech term but it was actually just a simple concept.
SSH(Secure Shell) provides a secure way for my PC to connect with my GitHub account.
So after creating the repo on GitHub I was given two link options to connect to it;HTTPS
and SSH
.
Since I then had both my local Git and GitHub respositories, I needed to connect them using a remote.
A remote is a reference to another repository hosted online.
I then copied the SSH key for my GitHub repository and ran this in Git:
git remote add origin git@github.com:SMumbi5144/Kenya_Health_Analysis.git
origin
is the name given to the remote repository.
The SSH address:
git@github.com:SMumbi5144/Kenya_Health_Records_Analysis.git
tells Git where the remote repo is.
To check if the two repos had connected I ran:
git remote -v
Once I had confirmed the two had connected, I pushed my local repo to GitHub by running:
git push -u origin main
git push
- tells Git to upload my commits to a remote repository.
origin
- refers to the GitHub repository I had added as my remote.
-u
- sets an upstream relationship between my local
main
branch and the remote main
branch.
This was the most exciting part of the process. For a beginner like me, it was quite the journey.
I refreshed my GitHub and I could then see my local project files online.
I could therefore view the project online,share it with others and continue working on it.
We all make mistakes as we learn and this project was no exception.
Therefore, in order to successfully upload my local files to my GitHub repository I learnt that I should:
git init
.git add .
else any changes I make will not be part of my next commit.git push
.My first project taught me more than just a few commands. It taught me patience and the importance of paying attention to detail and being systematic since a command will only work efficiently if the correct command is used. These are very important qualities for a data professional to develop so as to enhance the quality of their work.
I also learnt some cool concepts such as how a version control system works, how an SSH Key can connect my PC to GitHub and how I can manage and share my projects.
As I continue developing my skills at and outside LuxDev Academy, GitHub will help me document my projects and build a portfolio that shows what I can do.
This first project was the beginning of my journey towards becoming a better data professional.