DEV Community: Justine Kimeli

Understanding Pandas Library

Justine Kimeli — Mon, 19 Oct 2026 04:55:00 +0000

Introduction

Pandas is an open source python library for fast, flexible data analysis and manipulation.

Pandas allows users to import data from various file formats (comma-separated values, JSON, SQL, fits, etc.) and perform data manipulation operations, including cleaning and reshaping the data, summarizing observations, grouping data, and merging multiple datasets

With hundreds of functions and methods for data manipulation and analysis, it has become one of the most widely used tools in the world primarily for data analysis.
This article explores the most commonly used functions and methods for understanding, formatting, and visualizing data with the pandas package.

Reading data into Pandas

Pandas is capable of reading data from various file formats. In this case, we are reading our dataset in the file format csv.
The data is stored in a data structure called DataFrame which will defined by the variable name df.

import pandas as pd

file_name= "world_population.csv"
df=pd.read_csv(file_name)

Understanding the data format
In these step we are going to understand how these functions are of useful in data inspection.

df.head()
df.tail()
df.info()
df.describe()
df.shape

1. df.head()
This function will show the first 5 rows in the DataFrame:

2. df.tail()
This function shows the last 5 rows of the DataFrame

3. df.info()
This function displays the coincise summarry of the DataFrame

4. df.describe()
This is used to display descriptive statistical information about the numerical columns in a DataFrame including descriptive statistics of the central tendacy and dispersion.

5. df.shape()
This displays the number of rows and columns in the DataFrame

Data Format
Choosing which data format is relevant and makes sure the DataFrame is in a format that can be easily understood.
df.info() shows each column's data type, so it is the first place to look for columns stored as the wrong type, such as numbers read as text.

Cleaning the data

Before analyzing, it is worth checking for three common problems: missing values, duplicates and inconsistent text.

Handling missing values
Use df.isnull().sum() to see where values are missing. If any are, you can drop the affected rows or fill the gaps with a sensible value:

Removing duplicates

Duplicate rows can distort totals. Check how many there are, then remove them:

df.duplicated().sum()

If there is no duplicated values, the dataset is ready to work with otherwise the duplicated values should be dropped

df= df.drop_duplicates(

Sorting, selecting and filtering data

To find the most populous countries, sort by population:

To select columns, pass their names in a list:

To filter rows, use a condition inside square brackets:

Visualization
Pandas works with Matplotlib, so you can create charts directly from a DataFrame or Series.

# Visualization
import matplotlib.pyplot as plt

top10 = df.nlargest(10, "2022 Population").set_index("Country")["2022 Population"]

top10.sort_values(ascending=False).plot(
    kind="bar",
    title="Top 10 Most Populous Countries (2022)"
)

plt.ylabel("Population")
plt.xlabel("Country")
plt.xticks(rotation=45, ha="right")
plt.tight_layout()
plt.show()

Conclusion

This article demonstrated a complete introductory data analysis workflow using Python and Pandas, with a world population dataset as a practical example. The analysis covered how to load and inspect data, understand its structure, clean column names, handle missing values and duplicates, examine data types, sort and filter records, and visualize population using Matplotlib.

A Journey into Object Oriented Programming

Justine Kimeli — Fri, 02 Oct 2026 20:34:08 +0000

Introduction

Learning programming has introduced me how to write variables, conditions, loops, and functions. These are the concepts that helped me create simple programs, but as programs became larger, I realized that organizing the code could become difficult.
This is where OOP comes in. OOP is simply a way of organizing a program so that it is easier to understand and manage.
This article will entail what OOP is, class and objects and its four main pillars.

What is OOP?

Object-Oriented Programming(OOP) is a programming approach that organizes software around objects and classes rather than only functions and procedures.

Classes and Objects

A class is a blueprint or plan for creating objects. For example, a Student is a class that decribe what information and actions a should have.

An object is an actual thing created from class. Basically, it is an instance of a class. For example, a student called James from Student class.
An example:

class Student:
    def __init__(self, name,age):
        self.name = name
        self.age = age

    def display_info(self):
        print(f"My name is {self.name} and I am {self.age} years old")

s1 = Student("James", 28)
s1.display_info()

In the above program Student is the class, while s1 is an object. The display_info() function is a method that describes information about the student

Four Pillars of OOP

Object Oriented Programming has four main pillars: encapsulation,inheritance, ** polymorphism** and abstraction.

1.Encapsulation

Encapsulation means keeping related data and methods together inside a class. It protects data from direct access.
An example is a class bank account, it contains account balance and methods of depositing or withdrawing money. Instead of changing tha balance directly, it can be accessed through the methods provided by the class.
__Example

class BankAccount:
    def __init__(self, balance):
        self.__balance = balance

    def deposit(self, amount):
        self.__balance += amount

    def get_balance(self):
        return self.__balance


account = BankAccount(1000)

account.deposit(500)

print(account.get_balance())

The balance is kept inside the BankAccount class. The __balance is not meant to be accessed directly. We use methods such as deposit() and get_balance() to work with it.

2. Inheritance

In basic terms, inheritance allows a new class to (child/ sub/ derived class) re-use the attributes and methods of an existing class(parent/ super/base class).
Example:

# Parent CLass
class FarmAnimal:
    def __init__(self, name, age, weight):
        self.name = name
        self.age = age
        self.weight = weight

    def eat(self):
        print(f"{self.name} is eating")

    def display_detail(self):
        print(f"Name: {self.name} \nAge: {self.age} \nWeight: {self.weight}")

class Cow(FarmAnimal):
    def __init__(self, name, age, weight, milk_per_day):
        super().__init__(name,age, weight)

    def produce_milk(self):
        print(f"{self.name} produces {self.milk_per_day} litres per day")

    def milk_monthly(self):
        return self.milk_per_day * 30



# Child class 2 
class Chicken(FarmAnimal):
    def __init__(self, name, age, weight, eggs_per_week):
        super().__init__(name, age, weight)
        self.eggs_per_week = eggs_per_week


    def produce_eggs(self):
        print(f"{self.name} produces {self.eggs_per_week} per week.")

    def monthly_eggs(self):
        return self.eggs_per_week * 4

ingokho = Chicken("Ingokho", 2, 2 , 10)
ingokho.monthly_eggs()
ingokho.display_detail()

Both class Cow and Chicken inherit attributes from class FarmAnimal

3. Polymorphism

It allows same method to behave differently. For example Cow and Chicken demonstrate polymorphism by using same method name but diffrent behavior.

class Cow(FarmAnimal):
    def make_sound(self):
        print("The cow says Moo!")


class Chicken(FarmAnimal):
    def make_sound(self):
        print("The chicken says Cluck!")
cow = Cow("Bessie", 4, 400, 15)
chicken = Chicken("Ingokho", 2, 2, 10)

cow.make_sound()
chicken.make_sound()

The method has same name, make_sound(), but behaves differently depending on the object is what we call polymorphism.

4. Abstraction

This is hiding complicated details and showing only what is necessary to the user.
An example is here:


class Car:
    def start(self):
        self.__start_engine()
        print("Car is ready to move")

    def __start_engine(self):
        print("Engine started")


car = Car()

car.start()

We call car.start(), we do not need to know how the engine starts internally. The complicated process is hidden inside __start_engine() and we only use the simple start() method.

Conclusion

Learning OOP has helped me understand that programming is not only about writing lines of code but also about organizing those lines of code in a way that makes sense.
Discovering how all the concepts work together yields a better understanding that classes, objects, methods, inheritance, encapsulation, polymorphism, and abstraction are important tools for creating organized and reusable programs.

A Dive into SQL Functions

Justine Kimeli — Tue, 08 Sep 2026 21:04:05 +0000

Introduction

A month into learning SQL, I hit a point where every query i wrote was SELECT * FROM table WHERE. It worked perfectly but it had become obvious to retrieve data from a table and not actually work with it.
Getting into functions is where the real work is, aggregating data, transforming values and handling dates.
This article walks through what are SQL functions, common functions, practical examples and when to use them.

What are SQL Functions?

SQL functions are predefined or user-defined operations in SQL that take inputs, perform a specific operation, and return a single value. They are used to simplify queries, calculations, and data manipulations.

Common Functions

1.Aggregate functions
This takes in many rows and collapse them into a single value. COUNT,SUM, AVG,MIN,MAX are the examples. If used withoutGROUP BY, you get one row back for the whole table but when you use GROUP BY, you get one row per group.

i)- SUM(column) – total of column values

----- Find the total transaction amount by Transaction Type.  
select "Transaction_Type",sum("Amount") as transaction_Type_Amount
from money.moniepoint_transactions
group by "Transaction_Type";

ii)- AVG(column) – average

---- get the average
select avg("Amount")
from money.moniepoint_transactions;

iii)- COUNT(column) – number of rows

MIN(column) / MAX(column) – minimum or maximum value

Example

---Count how many orders each customer_id has placed (GROUP BY customer_id).
select  customer_id, count(*) as order_count
from supermarket.order_supermarket 
group by customer_id;

This returns the order count each customer placed.

2.** Scalar functions**
Scalar functions operate on a single value and return one result per row, without changing the row count. String functions (UPPER, CONCAT, SUBSTRING), numeric functions (ROUND, ABS), and most date functions (YEAR, DATEDIFF) fall into this category.

Examples and Categories
a) String functions — operate on text values.

LEN() – returns length of a string
UPPER() / LOWER() – converts to upper/lower case
SUBSTRING() – extracts part of a string

b) Numeric functions — operate on numbers.

ABS()– absolute value
ROUND() – rounds a number

c) Date/Time functions — operate on date or time.

GETDATE() – current date and time
DATEADD(day, 5, GETDATE()) – adds 5 days to a date
DATEDIFF(day, startDate, endDate) – difference between dates

When to Use Them

a)Aggregate fuctions
Used when the question is about a group, like how many, what's the average, what's the total. It answers the questions that has COUNT,SUM, AVG, MIN or MAX.

b) Scalar functions
Used when there is need to reshape or clean a value without changing how many rows come back. This involves formatting names, rounding numbers and building labels.

Summary

SQL functions help you move beyond simply retrieving data.
Aggregate functions summarize data using COUNT, SUM, AVG, MIN, and MAX.
Scalar functions transform individual values without changing the number of rows.
String functions help manipulate text.
Numeric functions help perform calculations and rounding.
Date/time functions make it easier to work with dates and time differences.
Using functions makes SQL queries more powerful, efficient, and meaningful.
Mastering SQL functions is an important step toward real-world data analysis.

Subqueries & CTEs in SQL: What They Are and When to Use Each

Justine Kimeli — Mon, 07 Sep 2026 19:07:43 +0000

Introduction

Understanding how Subqueries & CTEs work and when to use in a query become powerful tools for breaking down complex problems and writing cleaner SQL.
At some point, every SQL query outgrows a single SELECT ... FROM ... WHERE. You need to filter based on the result of another query, or break it step by step. That's where subqueries and CTEs (Common Table Expressions) come in.
They usually solve the same problem but in different approach. In this article, I will walk through what each is, how they differ, and where each one actually fits its place in a query.

What are Subqueries?

A subquery is a query nested inside another query. It is embedded inside another sql statement. It first runs the inner query and its result is used by the outer query as a filter value, a calaculated column.
Subqueries show up in one of three places:

In a WHERE clause, filters rows based on a computed value:

---subquerry
select score_id,member_id,score
from study_group.quiz_scores
where score >(select avg(score)
from study_group.quiz_scores);

This finds students with scores above average mark. The inner query runs once, produces a single number and the outer query compares each row score against the average mark.

In a FROM clause, acting as a temporary, unnamed table:

SELECT *
FROM (
    SELECT member_id, AVG(score) AS avg_score
    FROM study_group.quiz_scores
    GROUP BY member_id
) AS member_scores;

This query calculates the average score for each member, creating a temporary result set that the outer query can treat like a table.

In a SELECT clause, computing a value per row:

SELECT
    member_id,
    score,
    score * 2 AS doubled_score
FROM study_group.quiz_scores;

What are CTEs?

A CTE(Common Table Expression) is a temporary named result set defined at the top of your query using WITH, and referenced later as a table for the rest of your query.
It is temporary ---> it does not get saved anywhere. It exists only while that one query runs.
An example of a CTE:
----CTE----

with group_avg as (
    select avg(score) as avg_score
    from study_group.quiz_scores
)
select score_id, member_id,score 
from study_group.quiz_scores
cross join group_avg
where score > avg_score;

This defines the logic once, give it a name, and reference it below.
This query uses a CTE to calculate the overall average score once, then uses CROSS JOIN to make that value available to every row. TheWHERE clause then filters the results to show only scores that are above the overall average.

Conclusion

Learning how to use subqueries and CTEs has made it easier for me to break down complex SQL queries into smaller, more manageable pieces.
CTEs and subqueries are powerful SQL tools for breaking down complex queries and making data analysis easier to understand. Subqueries are useful when you need to perform a calculation or filtering operation within another query, while CTEs provides a cleaner and more readable way to organize multi-step logic

A Step-by-Step Guide: Connecting Power BI to SQL Databases

Justine Kimeli — Sun, 05 Jul 2026 20:54:47 +0000

Introduction

Many companies and organizations interact with large amount of data from collection to creating insights from it. Transforming these data will bring meaningful insights and there making informed decions for the end users. Power BI is a powerful tool that enables one to create interactive dashboards and reports that communicates what the data is all about. Connecting Power Bi to SQL databases now allows onre to analyze data in real time or through a scheduled time.
In this article demonstrates a step-by-step guide on how to connect Power BI to SQL databases both on local network and cloud-based, and start transforming your data into meaning visualizations.

Part 1: Connecting to a local PostgreSQL Database

Ensure that your PostgreSQL is downloaded and installed in your local machine. Launch Power BI desktop and select get data from the home tab.

Choose SQL Server From get data,select more,search for database then PostgreSQL database and connect which will require sever connection details.
Connection Details Enter the servername and database name. In this case I will user postgres as username and the server is *localhost:5432 *
Choose import data querry mode and enter your login credentials.
The window will then lists tables and you will select the one to work on with.For data cleaning click Transform data and the load for creating creating new measure and data models.

The navigator window will now show the tables available in the local PostgreSQL database.

Part 2: Connecting to a Cloud Based PostgreSQL on Aiven

Log in to your Aiven account, create a new service or the one existing and ensure it is running. The dashboard has Host Port Database name (usually defaultdb) Username (usually avnadmin) Password, for connection details

Download CA certificate, navigate to manage certificate manage,Trusted Root Certificate, right click certificates and import the certificate from your downloads.

Open Power BI Desktop, navigate to home tab, Get Data, More, select PostgreSQL, enter login credentials

After selecting what you want to transform like the local connection, performing data cleaning and load for modelling and all DAX irregardless of where the data is in whether local database or cloud.

Conclusion

Connecting Power BI to SQL databases whether hosted on local or cloud enables organizations to transform raw data into meaningful and interactive insights.
The steps of connecting Power BI to SQL databases are similar in that the cloud connection require SSL certificate for security access to be grated , otherwise every operation works the same.

Understanding Relationship, Schemas and Joins In Power BI

Justine Kimeli — Mon, 29 Jun 2026 22:59:24 +0000

Introduction

Power BI is a powerful business analytics and visualisation platform used to connect, transform and analyze raw data from various sources. This platform helps organizations to generate reports and dashboards that helps them make better and reliable decisions.
In this article, we are going to learn what are relationship,schemas and joins and how they play a role in performing power querry in Power BI.

Relationship in Power BI

In basic terms, relationships means a link between two things. In Power BI, relationship shows how rows in one table are connected to other rows in another table based on a unique key.

Types of Relationship

There are 4 types of relationship which includes; one-to-one, one-to-many, many-to-one and many-to-many. This relationship helps in combining information in multiple columns without duplicating it.

One-to-One Relationship

This relationship means each row in one table corresponds to exactly one row in another table. A perfect example is a student having one id to access a student portal account.

One-to-Many Relationship

This type of relationship that is commonly used in relational databases and in Power BI.It means that one record in a parent table can be associated with many records in a child table, but each record in the child table can be associated with only one record in the parent table.
An example is one student can register for many courses.

Many-to-One Relationship

This is basically the reverse of one-to-many type of relationship. An example is that many patients seeks medication from one doctor.

Many-to-Many Relationship

This type of relationship means multiple records in both tables share the same values.For example students enroll in multiple courses and each course has may students.

Schemas

A schema is basically how data is defined or structered in a database. It defines how data is organized including tables, columns, keys,data types and relationship between the tables.

Star Schema

A star schema is data modelling technique that is used to warehouse data. It organizes data into a central fact tables with different dimension tables forming a shape that is like a star.
In start schema, fact table stores numerical values and foreign keys that directly links the dimension table while dimension table provides descreptive context behind the numerical values in the fact table.

Snowflake Schema

This is a database design where dimension tables are normalized into multiple related sub-tables to reduce duplicate data.

Joins In Power BI

A join is a connection between two tables using a common column so that related data can be combined together. Joins are done in power querry editor.

Power BI jons

Inner join: It returns matchinhg rows only.
Left outer join: It returns all rows fro the first table and matching rows from the second table.
Right outer join: It returns all rows from the second table and matching rows from the first table.
Full outer join: It returns all rows from both tables.
Left anti join:It returns rows from the table with no match in the second table.
Right anti join: It returns rows from the second table with no match in the first table.

Conclusion

Finally, understanding relationships, schemas, and joins is important for building effective data models in Power BI. Relationships enable tables to work together, while schemas provide a structured framework for organizing data. Joins make it possible to combine data from different sources into a single, meaningful dataset. Mastering relationships, schemas, and joins is therefore a key skill for developing efficient Power BI reports, dashboards and making better insightful decisions.

Linux Fundamentals for Data Engineering

Justine Kimeli — Sun, 07 Jun 2026 20:11:38 +0000

Introduction

Data engineering is the process of collecting, moving, cleaning, storing, and preparing data such that it is easily accessed by data analysts, data scientists, AI systems, and businesses.
Basically data engineering is building systems that make data available, usable and reliable.

When learning data engineering, there is much focus tools such python, SQL and cloud platforms. While these technologies are of importance, there is one data system called linux which is the background in this field of data engineering.

In this article, I am going to share how linux commands is playing a vital role in data engineering and how it is used in a linux environment.

Why Linux is important in Data Engineering

Linux is widely used in real-world data engineering because it provides a stable, efficient, and flexible environment for handling large amounts of data.

Most companies stores data in a database, processes large datasets, schedules automated workflows, and deploys applications to the cloud.

Linux is used by data engineers to connect to remote servers,install and configure databases,transfer files between systems,monitor server performance, manage permissions and troubleshoot production issues in a linux environmemt. Therefore, without a basic understanding of Linux, working with most of the projects become challenging.

Basic Linux commands

ssh (secure shell) ->This commands allows one to access a remote server which has a host name and authenticate with a password.

pwd -> This command is used to show current working directory

ls -> Lists all files and directories

cd -> This command is used to change a directory

mkdir -> Create a new directory

ls -a -> Displays all files including hidden files

ls -l -> Displays long-list of files

ls -lh -> Displays file size in human- readable format

mv -> Moving files and directories
cp-> Copying files and directories
scp -> secure copying of files from a local machine to a remote server.
rm -> Removing files
touch -> Create an empty file
echo -> Print text or variables
exit -> Clears the terminal

Installing postgres
sudo apt install postgresql postgresql contrib -y
Starting postgres ->sudo systemctl start postgresql
Checking the status of postgres -> sudo systemctl status postgresql

Checking the psql version -> psql --version

Connecting from Linux server to Postgress
sudo -u postgres psql

Conclusion

Linux is a fundamental skill in data engineering that helps data engineers access, manage databases, transfer data, automating tasks. Through the practice that I have been doing, I have learned how to access a remote server perform various basic linux commands. I also learnt how to install postgres in linux environment and be able create database, schema, and perform basic SQL querries in linux environment.Finally, linux skills is essential for building, managing, and maintaining reliable data engineering solutions.