DEV Community: Joel Raphael Ogwai Odira

Getting Started with Excel for Data Analytics: From Basics to Data Cleaning.

Joel Raphael Ogwai Odira — Thu, 03 Sep 2026 10:06:24 +0000

Introduction

The pursuit of social, economic or even spiritual endeavours involve a continuous cycle of decision making. We rely on data to make these decisions, however negligible the data may seem.

We are usually presented with raw data, take for example a local government authority collecting population data to help determine appropriate development programmes. They will likely be presented with a general count of people, raw data, which isn't useful unless processed, presented meaningfully and used to advise. This brings us the concept of excel and data analytics.

We will sequentially look at three core concepts.

Excel
Data Cleaning
Data Analytics

Excel

Excel is a spreadsheet application that automates data processing. It's the most basic tool and allows storage and manipulation of data.

Structure

A grid based interface of columns labelled alphabetically and rows labelled numerically.
Cells are individual rectangular boxes containing data and are cross-referenced with the rows and columns e.g cell B2 being at the intersection of column B and row 2.
The ribbon, at the top of an excel window. It contains tabs such as Home, Data and formulas with nested and grouped tools and commands.
Formula bar, the long horizontal bar above the grid. It displays the currently selected cell and it's contents including formulas. You can directly input formulas in this bar.
Name box adjacent and left of the formular bar displays your current cell.
Worksheets which are displayed at the bottom of the grid and are basically pages within an excel document.
Quick access toolbar at the top left of the window provides shortcuts to save, undo and redo actions.

Core functions.

Data cleaning
Formulas and functions
Pivot tables
Data visualisation
What if analysis

Data cleaning

Presented with raw data, users need to ensure the integrity and accuracy of data to make it meaningful.

One important step in cleaning is to ensure your data set has headers. This sets parameters for you when you start inspecting the data set.
In a large data set, you can use freeze panes. Excel freezes columns and panes on top and to the left of your active cell.

It keeps the frozen columns and rows constant regardless of where you're scrolling in the dataset.

Data validation
This ensures only certain type of data is allowed in columns. You could set this to text only or numbers only for example.

Data validation works best when set before data collection, else it only restricts further data types if data exists already.

Where data exists already, you use sort and filter tab to view the data items in each column and clean. In a dataset with gender columns for example, You'd need to ensure you don't have Female and F representing the same thing, or Male and M.

The numbers tab under home tab allows you to format data in each column and standardise. Take a date column for example. In uncleaned data, you'd have dates entered in various formats like DD/MM/YY, YY/MM/DD, DD/MONTH/YEAR etc.

The numbers tab gives you freedom to set columns into text only, standardised date format, specific currency etc.

Duplicates
Duplicates can be removed from the Data tab. You can select columns and ensure only unique data exists.

Exercise with caution to avoid unnecessarily removing valid data. Two items may have a duplicate in one column while everything else varies in other columns making each a unique item.

TRIM
The =TRIM() removes unwanted spaces in a text string, whether leading, trailing or in between text.

Case sensitivity
You can ensure all uppercase, first letter uppercase or all lowercase using =UPPER() =PROPER() and =LOWER() respectively.

=CLEAN()
This removes unwanted characters especially where data was imported. Should also be used cautiously to avoid unintentionally excluding valid data.

Extracting and splitting

Text to columns found in the data tab and splits text strings in a column into different columns e.g. when you need First and second names separately.
=LEFT() =RIGHT() =MID() allows you to extract characters in a cell depending on position, for example, =RIGHT(B4, 3) gives us ent as in the example below.

CONCAT allows us to combine text strings. See example below.

FIND AND REPLACE
Allows quick location of specific items and replacement with a standardized value.

Data analytics

Cleaned data ensures any analysis done gives reliable insights.

Data cleaning is part of the analytics process. It's the first step when presented with a set of raw data.

Data analytics can be described as the elaborate process of inspecting, cleaning, transforming and modelling raw date to express usable insights. You are basically turning raw data into actionable information.

In data analytics, you will do 4 types of analysis.

Descriptive analysis simply tells us what happened. For example 30 students in a dataset of 100 students scored grade A in stream X in 2026.
Diagnostic analysis examines why only 30 students scored Grade A, by looking at historic trends maybe, or even variables that could have limited perfomance in that class. -Predictive analysis uses the diagnostic data to predict what could happen in future. -Prescriptive analysis offers insights into what action can be taken to get better performance of the students for example or to limit the inhibiting factors.

Conclusion

Data sets vary vastly and each will require uniquely different tools and approach to clean. The strict rule is to ensure validity, uniformity and highest level of accuracy. Data sets can be processed but integrity of the original data must always be upheld.

Understanding the Git Workflow: Working Directory, Staging, Commit and Push

Joel Raphael Ogwai Odira — Sun, 23 Aug 2026 14:35:07 +0000

Introduction

The Ecosysytem

To understand the git workflow, we have to understand the ecosystem within which it exists. The tools that facilitate this workflow.

This is a local version control system that tracks changes to files and code. It runs on every users local computer hence also known as an open source distributed version control system.
Whenever you create files or code, git is the software system that tracks these actions and ensures their integrity.

Gitbash

Simply a command line interface. Like Git itself, it runs on your local computer and allows users to execute git commands.

Github

Github is the web based platform. Its an endpoint and host for all work done by users and various collaborative tools.
It is an interactive platform where creators and other users can view and even contribute to your work while giving you the benefit to control such interaction and contribution through access control tools.

For the git workflow to be complete, every aspect of this ecosystem has to work in harmony.

The Workflow

The workflow follows an ordered sequence with various actions being perfomed in each sequence.

Working directory
Staging changes
Creating a commit
Pushing to a working repository

Working directory

A github repository stores all files, folders and documentation related to a specific project. In git workflow, the repository is stored locally on your computer.
We established that git and gitbash run on your local computer, therefore for the software system, git, to manage and track changes, the repository has to be cloned to a path on your local computer.

Git can't manage data or code in the entire repository concurrently. The user has to define specific files on which to work on. This brings the concept of working directory. It simply means the specific path the code or file where you are currently using git to make and track changes.

Establishing Your Working Directory

The crucial first step is to ascertain you are in the right directory. You use a set of command lines to do this.

As opposed to windows C:\Users , in gitbash paths are mapped using unix style /c/Users

pwd shows you the current path you are in the directory. ls shows you the contents of your current directory. If you are in the wrong path you have a set of options to;

navigate and access the right directory
create a new directory or file
list your current directory contents

Navigate and access the right directory

Command line	Function	Sample
`pwd`	Show current directory	`pwd`
`cd`	Change Directory	`cd Photos`
`cd ..`	Up one level	`cd ../`
`cd ../..`	Up two levels	`cd ../..`
`cd ~`	Home Directory	`cd ~`
`cd -`	Previous Directory	`cd -`
`cd /`	Root	`cd /`

Creating new directory or file

mkdir folder_name                  # Create one directory
mkdir folder1 folder2 folder3      # Create multiple
mkdir -p path/to/nested/folders    # Create nested folders
touch filename.txt                 # Create an empty file
touch file1.txt file2.md file3.py  # Create multiple empty files

Listing contents of your current directory

Command line	Function
`ls`	All files
`ls -l`	All files in detailed format
`ls -a`	All files, detailed including hidden files `.`
`ls la`	Detailed plus hidden files

The above processes show how to get to the right directory, you can then make changes and manage content using a variety of tools available.

Staging in Git

You have done your changes in the working directory. What next? We learnt Git is a software and gitbash is the command line interface. Data, files and code in this format is unusable except by or through your local computer only. To collaborate, display and have these stored in a retrievable format; we need Github, the web interface.
Between your working directory and github, we go through 2 steps, first which is staging.

Staging in github is therefore self explanatory. Getting your changes prepared to be included in the next commit. This part of the sequence allows you to select what changes are commited.

Check status in your working directory

git status

This command shows the status of changes in the directory. They could either be :

Untracked files/changes not staged for commit
changes to be commited (These are ready and prepared for commit)

Stage unprepared files and folders

After ascertaining the unstaged files, use the command

git add

but in different versions to give you control of what to stage.

Command line	Function
`git add filename.txt`	Stage specific file
`git add folder/`	Stage folder and all it's contents
`git add .`	Stage all new and modified files in parent directory and all subdirectories
`git add -A` or `git add --all`	Stage all new, modified and deleted files across the repository
`git add -u`	Stage only modified and deleted files, excludes untracked or new files
`git add -p` or `git add --patch`	Stage individual parts of a file

Run git status again, at which point files should appear under changes to be commited. In case of any errors you have the following command prompts at your disposal.

git restore --staged filename.txt to unstage a file
git restore --staged .to unstage everything
git diff --staged to see differences of staged files
git diff to see unstaged files

Commit

The standard and most commonly used commit command simply is;

git commit -m Clear description of what this commit does

This command records the staged changes. Note that at this point we are still in our local computer. Unstaged changes therefore remain in our working directory.

Another command git commit -a bypasses the git -add stage and stages all modified and deleted files in your working directory. See table below for variance between different commit command prompts.

Feature	`git commit -a`	`git commit`	`git commit -am "msg"`
Stages modified files	Yes	No	Yes
Stages deleted files	Yes	No	Yes
Stages untracked (new) files	No	No	No
Opens text editor for message	Yes	Yes	Passes message inline

A commit acts to move changes permanently from our staging area and makes them a permanent record. Git calls this a snapshot and is done in the .git folder. To see this folder you use the command we discussed earlier ls -a or ls -la.

Other actions that happen during this stage, git creates a commit object known as a Hash. It records the unique code changes, author name, timestamp, commit message, and the hash of the parent commit.

At this point, you can run git status again and if all is good you should see the message “nothing to commit, working tree clean”.

For any ammendments, you also have these at your disposal.

git commit --ammend Modifies most recent commit e.g add a file or edit commit m
git commit --ammend -m new message Changes message in last commit
git commit --ammend --no -edit Ammends last commit but keeps message

Commit message

Should be short and precise, preferably less than 50 characters. It summarily explains what was changed, why it was changes and any caution users should take. It should be done in present tense.

Git Push

This is the last stage in the workflow. This uploads commits from your local repository to a web based platform, Github. This happens within the corresponding branch in your local and remote repository. At this point others can create edits, push and pull requests.

*Push and pull requests work when collaborators or even the main user suggest changes, new features etc to an existing project. This allows stable code since the creators have access control tools to preview changes before they are merged on to the main branch.

It's imperative that users carefully determine what branch they are doing a push to. Several options are available.

git status will show current branch at the top.
git branchLists all local branches and the current one is marked with an asterisk.
git rev-parse --abbrev-ref HEAD and git branch --show-current simply show the branch. See below image for an actual sample.

See table below for a summary of push commands.

Command line	Function
`git push`	Pushes current local branch to corresponding remote branch
`git push origin main`	Specifies for git to push main branch in local repository to branch named origin in remote repository
`git push -u origin main`	Pushes and reminds git to use this upstream relationship in subsequent push
`git push origin feature -branch`	Pushes a feature branch
`git push --all`	Pushes all local branches
`git push --tags`	Pushes Tags as well

Summary

The numerous commands can be confusing. However, the main concept of this workflow isn't the commands rather grasping the orderly sequence. This workflow can be summarised as a local to remote workflow.

Working Directory → Staging Area → Commit → Remote Repository