DEV Community: EricMWaimiri

A Quick Look at Unsupervised Learning

EricMWaimiri — Fri, 21 Aug 2026 08:01:26 +0000

If supervised learning is like studying with an answer key, unsupervised learning is like being handed a pile of unlabeled data and told: "find something interesting in here." No correct answers, no guidance — just patterns waiting to be discovered.

What Makes It "Unsupervised"

In supervised learning, every training example comes with a label — this email is "spam," this house sold for "$250,000." Unsupervised learning drops the labels entirely. You feed the algorithm raw data, and it has to find structure on its own: groupings, relationships, or a simpler way to represent the data.

Data (no labels) → Algorithm → Hidden Structure

This matters because in the real world, labeled data is expensive and rare. Someone has to manually tag thousands of examples before supervised learning even becomes possible. Unsupervised learning skips that requirement, which is exactly why it's so widely used for exploration and preprocessing.

The Two Main Problems It Solves

1. Clustering

Clustering groups similar data points together without knowing in advance what the groups should be. The algorithm looks at the data's features and decides which points "belong together."

Common algorithms:

K-Means — partitions data into a fixed number of clusters based on distance from a central point.
Hierarchical Clustering — builds a tree of nested clusters, useful when you don't know how many groups exist.
DBSCAN — groups points based on density, good for irregularly shaped clusters and detecting outliers.

Example use case: A telecom company clusters customers by usage patterns (call frequency, data usage, time of day) to design targeted retention offers, without ever having predefined customer "types."

2. Dimensionality Reduction

Real-world datasets often have dozens or hundreds of features, many of which are redundant or noisy. Dimensionality reduction compresses that into fewer, more meaningful dimensions while preserving as much information as possible.

Common algorithms:

PCA (Principal Component Analysis) — finds the directions of maximum variance in the data and projects it onto fewer dimensions.
t-SNE — good for visualizing high-dimensional data in 2D or 3D.
Autoencoders — neural networks that learn a compressed representation of the input.

Example use case: Compressing a dataset with 500 gene-expression features down to 10 principal components so a downstream model can train faster without losing predictive power.

How It's Different from Supervised Learning

	Supervised	Unsupervised
Labels	Required	Not required
Goal	Predict a known outcome	Discover hidden structure
Evaluation	Accuracy, precision, recall	Harder — often subjective (cluster quality, variance explained)
Example	Spam detection	Customer segmentation

One of the trickiest parts of unsupervised learning is evaluation — there's no ground truth to check against, so you often rely on domain judgment and metrics like silhouette score or explained variance rather than a clean accuracy number.

Real-World Applications

Customer segmentation — Marketing teams cluster users by behavior to personalize campaigns without manually defining every segment.

Anomaly detection — Fraud detection and network security systems flag transactions or traffic that don't fit normal clusters, which is often more effective than trying to label every possible fraud pattern in advance.

Recommendation systems — Many recommendation engines use clustering or matrix factorization (a form of unsupervised learning) to group similar users or items.

Image compression and organization — Photo apps cluster similar images together (e.g., grouping photos by scene or face) without needing labeled training data.

Genomics — Researchers cluster gene expression data to discover previously unknown subtypes of diseases like cancer.

Getting Hands-On

A good first project: take a public dataset (retail transactions, iris dataset, or a Kaggle customer dataset), run K-Means with scikit-learn, and visualize the clusters with matplotlib or seaborn. Then try PCA on a high-dimensional dataset and see how much variance you can preserve in just 2 components.

from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler

X_scaled = StandardScaler().fit_transform(X)
kmeans = KMeans(n_clusters=4, random_state=42)
clusters = kmeans.fit_predict(X_scaled)

Small, hands-on experiments like this teach you more about how clustering behaves than reading the theory alone.

Final Thoughts

Unsupervised learning is less about prediction and more about discovery — it's the tool you reach for when you don't yet know what questions to ask of your data. It's foundational for exploratory analysis, and often the first step before building more targeted supervised models.

Have you used clustering or dimensionality reduction in a real project? Share what you built in the comments.

My Understanding of Machine Learning and Its Real-World Applications

EricMWaimiri — Fri, 21 Aug 2026 07:56:34 +0000

Machine learning (ML) shows up everywhere now — the recommendations under a YouTube video, the fraud alert your bank sends you, the autocomplete in your email. But for a lot of developers just getting into the field, "machine learning" still feels like a vague buzzword. This article breaks down what ML actually is, how it works at a conceptual level, and where it's genuinely making an impact today.

What Machine Learning Actually Is

At its core, machine learning is a way of teaching computers to find patterns in data and make decisions or predictions without being explicitly programmed for every scenario.

Traditional programming looks like this:

Rules + Data → Output

You write the logic, feed in data, and get a result. Machine learning flips that:

Data + Output → Rules (Model)

Instead of writing rules by hand, you give the algorithm a bunch of examples (data) along with the correct answers (outputs), and it figures out the underlying rules itself. Those learned rules are stored in what's called a model, which can then make predictions on new, unseen data.

The Three Main Types of Machine Learning

1. Supervised Learning

You train a model on labeled data — meaning every training example has a known correct answer. Think of predicting house prices based on square footage, location, and number of bedrooms, where you already have historical sales data to learn from.

Common algorithms: Linear Regression, Decision Trees, Random Forests, Support Vector Machines.

2. Unsupervised Learning

Here, the data has no labels. The model's job is to find hidden structure or groupings on its own — like clustering customers into segments based on purchasing behavior, without being told in advance what those segments should be.

Common algorithms: K-Means Clustering, Hierarchical Clustering, PCA.

3. Reinforcement Learning

The model (called an "agent") learns by interacting with an environment and receiving rewards or penalties based on its actions. This is how systems learn to play games or control robots — through trial, error, and feedback.

A Simple Way to Think About the ML Workflow

Collect data — the raw material everything else depends on.
Clean and prepare it — handle missing values, remove noise, format consistently.
Choose a model — pick an algorithm suited to the problem type.
Train the model — let it learn patterns from the data.
Evaluate performance — test it on data it hasn't seen before.
Deploy — put it into a real application where it can make live predictions.
Monitor and retrain — real-world data changes, so models need updates over time.

Real-World Applications

Healthcare

ML models help detect diseases earlier by analyzing medical images (X-rays, MRIs) for patterns too subtle for the human eye to catch consistently. They're also used to predict patient readmission risk and personalize treatment plans.

Finance

Banks use ML for fraud detection by spotting unusual transaction patterns in real time. Credit scoring models assess loan risk, and algorithmic trading systems use ML to react to market signals faster than any human could.

E-commerce and Retail

Recommendation engines (like the ones on Amazon or Netflix) use collaborative filtering and other ML techniques to suggest products or content based on your behavior and the behavior of similar users.

Transportation

Self-driving car systems rely heavily on ML for object detection, lane recognition, and decision-making. Ride-sharing apps use it to predict demand and optimize pricing and routing.

Natural Language Processing (NLP)

Chatbots, translation tools, sentiment analysis, and voice assistants like Siri or Alexa are all powered by ML models trained on massive amounts of text and speech data.

Agriculture

ML is used to predict crop yields, detect plant diseases from images, and optimize irrigation schedules using sensor and satellite data — genuinely useful in regions where farming is a major part of the economy.

Getting Started as a Developer

If you're a developer looking to get into ML, here's a practical path:

Learn Python — it's the dominant language in the ML ecosystem.
Get comfortable with data manipulation — libraries like Pandas and NumPy.
Understand the math intuitively — you don't need to derive every equation, but grasp what concepts like gradient descent and loss functions are doing conceptually.
Use scikit-learn for classical ML algorithms before jumping into deep learning frameworks like TensorFlow or PyTorch.
Work on real datasets — Kaggle is a great place to practice with actual messy data instead of toy examples.
Build small projects — predicting something simple end-to-end teaches you more than reading ten tutorials.

Final Thoughts

Machine learning isn't magic — it's pattern recognition at scale, powered by data and statistics. The real value comes from applying it to real problems: catching fraud before it happens, diagnosing illness earlier, or helping farmers get better yields. If you're a developer, you don't need a PhD to start — you need curiosity, some Python, and a dataset to experiment with.

What ML application are you most interested in building? Let me know in the comments.

I Built My First Machine Learning API — Here's Everything I Learned

EricMWaimiri — Thu, 13 Aug 2026 22:49:39 +0000

EricMWaimiri / Telco-Customer-Churn-Prediction

Customer Churn Prediction

Predicts whether a telecom customer will churn using the Telco Customer Churn dataset. The project covers data cleaning and EDA, comparison of three classifiers, and a FastAPI service that serves the final model.

Project Structure

.
├── API/
│   └── main.py                                 # FastAPI app serving the model
├── Data/
│   └── WA_Fn-UseC_-Telco-Customer-Churn.csv    # raw dataset (7,043 customers)
├── Models/
│   ├── ml_pipeline.joblib                      # fitted preprocessing + classifier pipeline
│   └── target_labels.joblib                    # LabelEncoder for the churn target
├── Notebooks/
│   └── customer_churn_prediction.ipynb         # data cleaning, EDA, model training
├── cpp/                                        # (Python virtual environment)
├── .env                                        # environment variables (not committed)
├── .gitignore
├── requirements.txt
└── README.md

main.py loads ../models/ml_pipeline.joblib and ../models/target_labels.joblib, so it must be run from inside API/ for those relative paths to resolve.

Dataset

The raw data is the Telco Customer Churn dataset 7,043 rows and 21 columns covering customer demographics, account…

View on GitHub

If you've ever trained a model in a Jupyter notebook and then wondered "okay... now what?" — this post is for you. I recently built a Customer Churn Prediction API, and I want to walk you through it the way I wish someone had walked me through my first one: no jargon dump, just what each piece does and why it's there.

Think of it like a Safaricom customer care team trying to figure out which subscribers are about to switch to Airtel — before they actually leave. That's churn prediction. And instead of leaving that insight trapped inside a notebook, I turned it into an API anyone (or any app) can call.

The Problem: A Notebook Is Not a Product

I started, like most people do, in a Jupyter notebook. I had a dataset of telecom customers — their contract type, monthly charges, whether they had streaming services, and so on — with a label saying whether they churned (left) or not.

I cleaned the data, explored it, trained a few models, and picked a winner. Cool. But here's the thing: a trained model sitting in a notebook is useless to anyone else. A frontend developer can't "import your notebook" into an app. A business analyst can't click a button in your .ipynb file to get a prediction.

That's the gap an API fills.

Step 1: From Raw Data to a Trained Model

Before any API talk, the notebook had to do its job. Here's the flow, in plain English:

Load the data — a CSV of ~7,000 customers with columns like gender, tenure, Contract, MonthlyCharges, and the target column, Churn (Yes/No).
Clean it up — column names get lowercased and stripped of spaces (TotalCharges becomes totalcharges), and a numeric column that was secretly stored as text gets converted properly. A handful of broken rows get dropped.
Explore it (EDA) — check the churn rate, look at unique values in each category, plot the class balance. This is where you catch surprises before they wreck your model.
Split the data — into training and testing sets, so you can honestly check how well the model generalizes instead of just memorizing.
Preprocess — numeric columns (like tenure and MonthlyCharges) get scaled, and categorical columns (like Contract or PaymentMethod) get one-hot encoded, because models only understand numbers.
Train and compare models — I tried Logistic Regression, K-Nearest Neighbors, and a Random Forest, then compared their classification reports.
Save the winner — using joblib, I saved the entire fitted pipeline (preprocessing + model, bundled together) plus the label encoder, so predictions later come back as "Yes"/"No" instead of 1/0.

That last step is the bridge to everything that follows. Once your pipeline is saved to disk, it stops being "notebook code" and becomes a reusable artifact — a file any Python program can load and use.

Step 2: What Even Is an API, in Plain Terms?

An API is just a way for two programs to talk to each other over the web, using a set of agreed-upon rules. You send it something, it sends something back.

For this project, the deal is simple:

"Send me a customer's details, and I'll tell you whether they're likely to churn."

That's it. No magic. Just a structured request in, a structured response out.

Step 3: Enter FastAPI

I used FastAPI, a Python framework built specifically for creating APIs quickly, with automatic validation and interactive documentation baked in.

Here's the skeleton of what's happening in main.py:

import joblib
from fastapi import FastAPI
from pydantic import BaseModel
import pandas as pd

# Load the model and target labels
labels = joblib.load('../models/target_labels.joblib')
model = joblib.load('../models/ml_pipeline.joblib')

app = FastAPI(
    title="Customer Churn Prediction API",
    description="An API for predicting customer churn using a pre-trained machine learning model."
)

Two things happen right at the top, before the API even starts handling requests:

The trained pipeline (ml_pipeline.joblib) is loaded into memory. This is the exact same preprocessing + model combo we saved from the notebook.
The label encoder (target_labels.joblib) is loaded too, so we can turn a 0/1 prediction back into a human-readable "No"/"Yes".

This only happens once, when the server starts — not on every request. That's important for speed.

Step 4: Defining What "Valid Input" Looks Like

This is the part that impressed me most as a beginner. FastAPI uses something called Pydantic to define exactly what shape your input data must be:

class InputData(BaseModel):
    gender: str
    seniorcitizen: int
    partner: str
    dependents: str
    tenure: int
    phoneservice: str
    multiplelines: str
    internetservice: str
    onlinesecurity: str
    onlinebackup: str
    deviceprotection: str
    techsupport: str
    streamingtv: str
    streamingmovies: str
    contract: str
    paperlessbilling: str
    paymentmethod: str
    monthlycharges: float
    totalcharges: float

Every field here mirrors a column the model was trained on. If someone sends tenure as "twelve" instead of 12, FastAPI rejects the request automatically — before it ever reaches your model. You don't write a single line of manual validation code. That alone saved me from a bunch of silent bugs.

Step 5: The Actual Endpoints

An API exposes "endpoints" — specific URLs that do specific things. This project has two.

A health check, so you (or a monitoring tool) can confirm the API is alive:

@app.get("/health", tags=["Health Check"])
def health_check():
    return {"status": "API is running"}

The actual prediction endpoint:

@app.post("/predict", tags=["Prediction"])
def predict_churn(payload: InputData):
    # Convert input data to DataFrame
    input_df = pd.DataFrame([payload.model_dump()])

    # Make prediction
    prediction = model.predict(input_df)

    # Decode the prediction
    decoded_prediction = labels.inverse_transform(prediction)

    return {"prediction": decoded_prediction[0]}

Walking through it:

FastAPI already validated and parsed the incoming JSON into payload.
payload.model_dump() turns it into a plain dictionary, which gets wrapped into a one-row pandas DataFrame — because that's the format the trained pipeline expects.
model.predict(...) runs that row through the exact same preprocessing steps used during training (scaling, one-hot encoding), then through the classifier.
The result comes back as a number (0 or 1), so labels.inverse_transform(...) converts it back into "No" or "Yes".
We return it as JSON.

That's the whole loop: JSON in → DataFrame → pipeline → prediction → JSON out.

Step 6: Trying It Out

Once you run:

uvicorn main:app --reload

FastAPI gives you a free interactive docs page at http://127.0.0.1:8000/docs, where you can literally fill in a form and hit "Execute" to test /predict without writing a single line of client code. As a beginner, this is where it finally clicked for me — seeing my model respond to a request in real time made it feel like a real product, not just a school notebook exercise.

Send it something like:

{
  "gender": "Female",
  "seniorcitizen": 0,
  "partner": "Yes",
  "dependents": "No",
  "tenure": 1,
  "phoneservice": "No",
  "multiplelines": "No phone service",
  "internetservice": "DSL",
  "onlinesecurity": "No",
  "onlinebackup": "Yes",
  "deviceprotection": "No",
  "techsupport": "No",
  "streamingtv": "No",
  "streamingmovies": "No",
  "contract": "Month-to-month",
  "paperlessbilling": "Yes",
  "paymentmethod": "Electronic check",
  "monthlycharges": 29.85,
  "totalcharges": 29.85
}

And you get back:

{"prediction": "No"}

The Lesson That Stuck With Me

Training a model answers the question "does this work?" Building an API answers a completely different question: "can anyone else use this?"

Those are two separate skills, and honestly, the second one felt more like real software engineering — dependency management, input validation, documentation, deployment thinking — than the modeling part did. If you've been putting off learning how to serve your models, don't. It's a smaller leap than it looks, and FastAPI in particular makes it a genuinely beginner-friendly one.

If you're working through something similar — maybe predicting M-Pesa transaction fraud, or matatu route demand — the pattern is identical: train, save the pipeline, load it in an API, validate input, predict, respond. Once you've done it once, you'll do it in your sleep.

Have you built your first ML API yet? What tripped you up the most — validation, deployment, or something else entirely? Let me know in the comments.

A Beginner’s Guide to Regression and Regularization

EricMWaimiri — Tue, 21 Jul 2026 14:57:54 +0000

Machine learning often starts with a simple question: Can we predict a number from data?

That’s where regression comes in. It’s one of the most fundamental techniques in data science, and understanding it opens the door to more advanced models.

What is Regression?

Regression is about predicting a continuous target variable (like salary, house price, or temperature) based on one or more input features.

Simple Linear Regression: Predicts using one feature.

Example: Predicting house price from square footage.
Multiple Linear Regression: Uses several features.

Example: Predicting salary from years of experience, education level, and certifications.
The general form looks like this:

General form of a multiple linear regression model:

y = β0 + β1*x1 + β2*x2 + ... + βn*xn + ε
Where:
y      - target (the value we want to predict)
x1..xn - features (input variables)
β      - coefficients (weights learned by the model)
ε      - error term (the part the model cannot explain)

Why Regularization?

Regression models can sometimes overfit — they learn the training data too well, including noise, and fail to generalize to new data.

This happens especially when you have many features or multicollinearity (features highly correlated with each other).

Regularization is a technique to prevent overfitting by adding a penalty to the size of the coefficients.

Types of Regularization

1. Ridge Regression

Adds a penalty proportional to the square of coefficients.
Encourages smaller, more stable coefficients.
Formula:

Ridge Regression Loss Function:

Loss = RSS + λ * Σ(β_j^2)
Where:
RSS   - Residual Sum of Squares (error between predictions and actual values)
λ     - Regularization parameter (controls penalty strength)
β_j   - Coefficients of the regression model

2. Lasso Regression

Adds a penalty proportional to the absolute value of coefficients.
Can shrink some coefficients to zero, effectively performing feature selection.
Formula:

Lasso Regression Loss Function:

Loss = RSS + λ * Σ|β_j|
Where:
RSS   - Residual Sum of Squares (error between predictions and actual values)
λ     - Regularization parameter (controls penalty strength)
β_j   - Coefficients of the regression model

Note:
The absolute value penalty (|β_j|) can shrink some coefficients exactly to zero.

This makes Lasso useful for feature selection as well as preventing overfitting.

3. Elastic Net

Combines Ridge and Lasso penalties.
Useful when you want both stability and feature selection.

Choosing Between Them

Use Ridge when you have many correlated features.
Use Lasso when you suspect only a few features are truly important.
Use Elastic Net when you want a balance of both.

Practical Example in Python


python
from sklearn.linear_model import LinearRegression, Ridge, Lasso

# Simple regression
lin_reg = LinearRegression().fit(X_train, y_train)

# Ridge regression
ridge_reg = Ridge(alpha=1.0).fit(X_train, y_train)

# Lasso regression
lasso_reg = Lasso(alpha=0.1).fit(X_train, y_train)

Power BI DAX Essential Functions — Explained with Examples

EricMWaimiri — Sun, 12 Jul 2026 18:20:08 +0000

If you’ve ever struggled with CALCULATE() or wondered why SUMX() behaves differently from SUM(), this guide is for you.

DAX (Data Analysis Expressions) is the language that powers Power BI, Analysis Services, and Power Pivot — enabling dynamic calculations, filtering, and time intelligence.

Below is a categorized cheat sheet of essential DAX functions, plus examples showing how to use each in real-world Power BI scenarios.

Filtering & Context

These functions control how filters are applied and evaluated in your calculations.

Function	Example	Description
`CALCULATE()`	`CALCULATE(SUM(Sales[Amount]), Region[Name] = "Nairobi")`	Changes filter context to calculate total sales for Nairobi.
`FILTER()`	`FILTER(Sales, Sales[Amount] > 10000)`	Returns a table filtered by condition.
`ALL()`	`CALCULATE(SUM(Sales[Amount]), ALL(Region))`	Ignores filters on Region.
`REMOVEFILTERS()`	`CALCULATE(SUM(Sales[Amount]), REMOVEFILTERS(Region))`	Removes filters from Region.
`VALUES()`	`VALUES(Customer[City])`	Returns unique list of cities.
`SELECTEDVALUE()`	`SELECTEDVALUE(Product[Category], "All")`	Returns selected category or “All” if none.
`TREATAS()`	`TREATAS(VALUES(Temp[City]), Customer[City])`	Applies one table’s values as filters on another.
`KEEPFILTERS()`	`CALCULATE(SUM(Sales[Amount]), KEEPFILTERS(Product[Category] = "Electronics"))`	Keeps existing filters and adds new ones.
`ALLSELECTED()`	`CALCULATE(SUM(Sales[Amount]), ALLSELECTED(Region))`	Respects user selections in visuals.
`ALLEXCEPT()`	`CALCULATE(SUM(Sales[Amount]), ALLEXCEPT(Sales, Sales[Year]))`	Removes all filters except Year.

Aggregation

Summarize or aggregate data across rows or columns.

Function	Example	Description
`SUM()`	`SUM(Sales[Amount])`	Adds all sales amounts.
`AVERAGE()`	`AVERAGE(Sales[Amount])`	Calculates mean value.
`COUNT()`	`COUNT(Customer[ID])`	Counts non-blank entries.
`COUNTROWS()`	`COUNTROWS(Sales)`	Counts rows in a table.
`DISTINCTCOUNT()`	`DISTINCTCOUNT(Customer[ID])`	Counts unique customers.
`MIN()`	`MIN(Sales[Amount])`	Finds smallest sale.
`MAX()`	`MAX(Sales[Amount])`	Finds largest sale.

Iterator (X) Functions

Perform row-by-row calculations before aggregation.

Function	Example	Description
`SUMX()`	`SUMX(Sales, Sales[Quantity] * Sales[Price])`	Calculates total revenue per row, then sums.
`AVERAGEX()`	`AVERAGEX(Products, Products[ProfitMargin])`	Averages profit margins across products.
`MINX()`	`MINX(Orders, Orders[DeliveryDays])`	Finds minimum delivery days.
`MAXX()`	`MAXX(Orders, Orders[DeliveryDays])`	Finds maximum delivery days.

Logical Functions

Control flow and conditional logic.

Function	Example	Description
`IF()`	`IF(Sales[Amount] > 10000, "High", "Low")`	Returns “High” or “Low” based on condition.
`SWITCH()`	`SWITCH(TRUE(), Sales[Amount] > 10000, "High", Sales[Amount] > 5000, "Medium", "Low")`	Multi-condition logic.
`COALESCE()`	`COALESCE(Sales[Discount], 0)`	Replaces blanks with default value.

Relationship Functions

Work across related tables.

Function	Example	Description
`RELATED()`	`RELATED(Customer[Name])`	Fetches related customer name.
`LOOKUPVALUE()`	`LOOKUPVALUE(Customer[Email], Customer[ID], Sales[CustomerID])`	Finds email based on ID.
`USERELATIONSHIP()`	`CALCULATE(SUM(Sales[Amount]), USERELATIONSHIP(Sales[Date], Calendar[Date]))`	Activates inactive relationship.

Ranking Functions

Rank or sort data dynamically.

Function	Example	Description
`RANKX()`	`RANKX(ALL(Customer), SUM(Sales[Amount]), , DESC)`	Ranks customers by total sales.
`TOPN()`	`TOPN(5, Sales, Sales[Amount], DESC)`	Returns top 5 sales records.

Mathematical Functions

Function	Example	Description
`DIVIDE()`	`DIVIDE(SUM(Sales[Profit]), SUM(Sales[Revenue]), 0)`	Safe division avoiding errors.
`ROUND()`	`ROUND(Sales[Amount], 2)`	Rounds to two decimals.

Date & Time Functions

Function	Example	Description
`TODAY()`	`TODAY()`	Returns current date.
`NOW()`	`NOW()`	Returns current date and time.
`DATEDIFF()`	`DATEDIFF(Orders[OrderDate], Orders[ShipDate], DAY)`	Calculates days between two dates.

Time Intelligence

Function	Example	Description
`DATEADD()`	`DATEADD(Calendar[Date], -1, YEAR)`	Shifts date context by one year.
`SAMEPERIODLASTYEAR()`	`SAMEPERIODLASTYEAR(Calendar[Date])`	Compares same period last year.
`TOTALYTD()`	`TOTALYTD(SUM(Sales[Amount]), Calendar[Date])`	Year-to-date total.
`DATESBETWEEN()`	`DATESBETWEEN(Calendar[Date], DATE(2026,1,1), DATE(2026,6,30))`	Filters dates between range.
`DATESINPERIOD()`	`DATESINPERIOD(Calendar[Date], MAX(Calendar[Date]), -30, DAY)`	Last 30 days.

Table Functions

Function	Example	Description
`ADDCOLUMNS()`	`ADDCOLUMNS(Sales, "Profit", Sales[Revenue] - Sales[Cost])`	Adds calculated column.
`SUMMARIZE()`	`SUMMARIZE(Sales, Region[Name], "TotalSales", SUM(Sales[Amount]))`	Groups and summarizes data.
`SUMMARIZECOLUMNS()`	`SUMMARIZECOLUMNS(Region[Name], "TotalSales", SUM(Sales[Amount]))`	Similar to SUMMARIZE but optimized.
`UNION()`	`UNION(TableA, TableB)`	Combines two tables.
`INTERSECT()`	`INTERSECT(TableA, TableB)`	Returns common rows.
`EXCEPT()`	`EXCEPT(TableA, TableB)`	Returns rows in A not in B.

Text Functions

Function	Example	Description
`LEFT()`	`LEFT(Customer[Name], 3)`	First three letters.
`RIGHT()`	`RIGHT(Customer[Name], 3)`	Last three letters.
`SEARCH()`	`SEARCH("Ltd", Company[Name], 1, -1)`	Finds position of substring.
`CONCATENATEX()`	`CONCATENATEX(Customer, Customer[Name], ", ")`	Joins names with commas.

Information Functions

Function	Example	Description
`ISBLANK()`	`IF(ISBLANK(Sales[Amount]), 0, Sales[Amount])`	Checks for blank values.
`HASONEVALUE()`	`IF(HASONEVALUE(Product[Category]), VALUES(Product[Category]), "Multiple")`	Detects single selection.

These functions form the foundation of every Power BI model.

Mastering them means you can build dynamic dashboards, automate KPIs, and handle complex business logic with ease.

Tip: Start with CALCULATE(), FILTER(), and SUMX() — they’re the most powerful trio in DAX.

Source

Microsoft DAX Documentation

Essential DAX functions for building powerful Power BI reports and models.

Parametric vs Non-Parametric Statistical Tests

EricMWaimiri — Mon, 06 Jul 2026 05:28:28 +0000

What Are They?

Statistical tests fall into two broad categories: parametric and non-parametric. The choice between them affects the validity of your conclusions — picking the wrong one can lead to misleading results.

Parametric Tests

Parametric tests make assumptions about the underlying population distribution, most commonly that the data is normally distributed. They work with the actual values in your data (means, variances) and tend to be more powerful when their assumptions are met.

Common parametric tests:

t-test (compare means between two groups)
ANOVA (compare means across three or more groups)
Pearson correlation (measure linear relationship between two variables)
Linear regression

When to use them:

Your data is continuous
Sample size is large enough for the Central Limit Theorem to apply (typically n > 30)
Data is approximately normally distributed
Variances across groups are roughly equal (homoscedasticity)

Non-Parametric Tests

Non-parametric tests make no assumptions about the population distribution. They work with ranks or categories rather than raw values, making them more flexible — but generally less powerful than parametric tests when parametric assumptions hold.

Common non-parametric tests:

Mann-Whitney U test (equivalent of independent t-test)
Wilcoxon signed-rank test (equivalent of paired t-test)
Kruskal-Wallis test (equivalent of one-way ANOVA)
Spearman correlation (rank-based correlation)
Chi-square test (categorical data)

When to use them:

Data is ordinal (e.g. satisfaction scores, rankings)
Data is heavily skewed or contains outliers
Sample size is small (n < 30)
Data violates normality assumptions
You are working with categorical or nominal data

Key Differences

	Parametric	Non-Parametric
Distribution assumption	Yes (usually normal)	No
Data type	Continuous	Ordinal, categorical, or non-normal continuous
Statistical power	Higher (when assumptions met)	Lower
Sensitivity to outliers	High	Low
Sample size requirement	Larger	Smaller

Role in Data Science

In data science, both approaches appear regularly across the analytics workflow.

Parametric tests are common in A/B testing (t-tests for comparing conversion rates at scale), regression modelling, and feature correlation analysis where datasets are large and roughly normal.

Non-parametric tests are essential when working with customer satisfaction scores, survey data, small samples, or any dataset where normality cannot be assumed, which is more often the case in real-world business data than textbooks suggest.

A practical rule: always check your data's distribution before choosing a test. Use a histogram, Q-Q plot, or the Shapiro-Wilk test to assess normality. If in doubt, non-parametric tests are the safer default, they sacrifice a little power in exchange for broader applicability.

Parametric tests are more powerful but demand more from your data. Non-parametric tests are more flexible and robust. In data science, knowing when to apply each and being able to justify your choice is as important as running the test itself.

How I Explored a US Health Dataset with Python — EDA + Hypothesis Testing

EricMWaimiri — Sun, 28 Jun 2026 18:11:25 +0000

I recently completed an exploratory data analysis project on the NHANES (National Health and Nutrition Examination Survey) dataset from Kaggle. It's a real-world health survey collected by the CDC covering body measurements, lifestyle habits, and demographic data from thousands of US adults.

In this article I'll walk you through exactly what I did — from loading and cleaning the data all the way to running statistical tests — and share what I found along the way.

The Dataset

The dataset has 5,735 rows and 28 columns, but for this project I focused on 8 columns that were relevant to the questions I wanted to answer:

Column	Description
`smoking`	Has the person smoked at least 100 cigarettes?
`gender`	Male or Female
`age`	Age in years
`education`	Highest level of education
`weight`	Weight in kg
`height`	Height in cm
`bmi`	Body Mass Index

Step 1 — Loading and Selecting Columns

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

db = pd.read_csv('NHANES.csv')

data = db.loc[:, ('SEQN', 'SMQ020', 'RIAGENDR', 'RIDAGEYR',
                   'DMDEDUC2', 'BMXWT', 'BMXHT', 'BMXBMI')]

data = data.rename(columns={
    'SEQN': 'id', 'SMQ020': 'smoking', 'RIAGENDR': 'gender',
    'RIDAGEYR': 'age', 'DMDEDUC2': 'education',
    'BMXWT': 'weight', 'BMXHT': 'height', 'BMXBMI': 'bmi'
})

One thing worth knowing about NHANES: all the columns come in as numeric codes. 1 means Male, 2 means Female. 1 means the person smoked, 2 means they didn't. You have to map these to readable labels before doing any analysis, otherwise your charts are meaningless.

Step 2 — Cleaning the Data

Drop the ID column and remove nulls

data.drop('id', axis=1, inplace=True)
data.dropna(inplace=True)

This brought us from 5,735 rows down to 5,406 — about 6% lost, which is acceptable.

Remove outliers using the IQR method

The IQR (Interquartile Range) method flags values that fall too far outside the middle 50% of the data:

Lower bound = Q1 − 1.5 × IQR
Upper bound = Q3 + 1.5 × IQR

# Height outlier removal
hq25, hq50, hq75 = data['height'].quantile([0.25, 0.5, 0.75])
hiqr = hq75 - hq25
hlower = hq25 - 1.5 * hiqr
hupper = hq75 + 1.5 * hiqr
data = data[(data['height'] >= hlower) & (data['height'] <= hupper)]

I applied this to height, weight, and bmi. After removing outliers the final dataset had 5,171 clean rows.

Map coded values to labels

data['smoking'] = data['smoking'].replace({1: 'Yes', 2: 'No', 7: np.nan, 9: np.nan})
data['gender']  = data['gender'].replace({1: 'Male', 2: 'Female'})
data['education'] = data['education'].replace({
    1: 'Less than 9th grade', 2: '9th to 12th grade',
    3: 'High school graduate',  4: 'Some college',
    5: 'College graduate',      9: 'Others'
})

Note: codes 7 and 9 in the smoking column mean "Refused" and "Don't know" — I converted these to NaN rather than treating them as valid answers.

Step 3 — Distribution Analysis

Before looking at relationships between variables, I first looked at each variable individually using histograms and boxplots.

fig, axes = plt.subplots(2, 2, figsize=(12, 8))
sns.histplot(data=data, x='age',    kde=True, bins=30, ax=axes[0,0], color='skyblue')
sns.histplot(data=data, x='weight', kde=True, bins=30, ax=axes[0,1], color='lime')
sns.histplot(data=data, x='height', kde=True, bins=30, ax=axes[1,0], color='red')
sns.histplot(data=data, x='bmi',    kde=True, bins=30, ax=axes[1,1], color='orange')
plt.tight_layout()
plt.show()

What I found:

age is fairly uniform — the survey was designed to cover all adult age groups
bmi and weight are right-skewed — a few very high values pull the mean above the median
height is roughly normally distributed

The boxplots before and after outlier removal made it easy to confirm the cleaning worked — the extreme dots beyond the whiskers were gone after applying IQR.

Step 4 — Correlation Analysis

numerical = data.select_dtypes(include='number')
corr = numerical.corr()

plt.figure(figsize=(8, 6))
sns.heatmap(corr, annot=True, cmap='coolwarm', fmt='.2f', linewidths=0.5)
plt.title('Correlation Matrix of Numerical Variables')
plt.show()

Key findings from the heatmap:

weight and bmi have a very strong positive correlation — expected, since BMI is calculated from weight
age and bmi have a weak positive correlation — BMI tends to increase slightly with age
height and weight show a moderate positive correlation

I also ran pairplots split by gender and by smoking status to see if patterns differed across groups.

Step 5 — Group Comparisons

I binned the continuous age column into decade bands for group analysis:

data['age'] = pd.cut(data['age'], [18, 30, 40, 50, 60, 70, 80])

Then looked at smoking proportions and BMI by age band and gender:

data.groupby(['age', 'gender']).agg({'smoking': lambda x: np.mean(x == 'Yes')})

Some patterns that emerged:

Smoking rates are highest in the 30–40 age band
Males smoke at a much higher rate than females across all age groups
BMI peaks in the 50–60 age band for both genders

Step 6 — Hypothesis Testing

This is where the analysis gets interesting. I defined three hypotheses and ran statistical tests on each one.

H01 — Are females aged 40–50 predominantly obese?

from statsmodels.stats.proportion import proportions_ztest

females_40_50 = data[
    (data['gender'] == 'Female') & (data['age'].astype(str) == '(40, 50]')
]
obese = (females_40_50['bmi'] > 30).sum()
n = len(females_40_50)

stat, p = proportions_ztest(obese, n, value=0.5, alternative='larger')
print(f'Obese: {obese}/{n} ({obese/n*100:.1f}%)')
print(f'Z-stat: {stat:.3f}, p-value: {p:.4f}')

Result: 224 out of 469 females aged 40–50 had BMI > 30 which is the cutoff according to WHO — that's 47.8%. The p-value was greater than 0.05, so we fail to reject H₀. Just under half are obese — close, but not a statistically significant majority.

H02 — Do males and females smoke at different rates?

from scipy.stats import chi2_contingency

smokers_only = data[data['smoking'].isin(['Yes', 'No'])]
ct = pd.crosstab(smokers_only['gender'], smokers_only['smoking'])
chi2, p, dof, expected = chi2_contingency(ct)
print(f'Chi-square: {chi2:.3f}, p-value: {p:.4f}')

Result: Male smoking rate was 53.3%, female was 31.2%. The p-value was well below 0.05 — we reject H₀. The difference in smoking rates between males and females is statistically significant.

H03 — Is BMI significantly different between males and females?

from scipy.stats import ttest_ind

male_bmi   = data[data['gender'] == 'Male']['bmi'].dropna()
female_bmi = data[data['gender'] == 'Female']['bmi'].dropna()

stat, p = ttest_ind(male_bmi, female_bmi)
print(f'Male BMI mean: {male_bmi.mean():.2f}')
print(f'Female BMI mean: {female_bmi.mean():.2f}')
print(f'T-stat: {stat:.3f}, p-value: {p:.4f}')

Result: Male mean BMI was 28.21, female was 29.09. The p-value was below 0.05 — we reject H₀. The difference, while small, is statistically significant.

Summary of findings

Hypothesis	Test used	Result
Females 40–50 are predominantly obese	Proportion z-test	Fail to reject H₀ (47.8%, not a majority)
Smoking rates differ by gender	Chi-square	Reject H₀ (53.3% male vs 31.2% female)
BMI differs by gender	Independent t-test	Reject H₀ (28.21 male vs 29.09 female)

What I learned

A few things that stood out doing this project:

Numeric codes will catch you off guard. NHANES stores everything as numbers. If you forget to map them, your heatmap will show a correlation between "gender" and "BMI" that is actually just the correlation between the numbers 1 and 2 and BMI values — meaningless.

Mean vs median gap is your quickest signal. BMI mean was 29.1 but median was 27.8. That 1.3 gap immediately told me there were high-end outliers pulling the average up before I even plotted anything.

Statistical significance ≠ practical significance. H03 rejected the null — male and female BMI are statistically different. But the actual difference is less than 1 BMI point. Significant in the mathematical sense, but probably not meaningful in a clinical one.

Tools used

Python 3
pandas, numpy
matplotlib, seaborn
scipy, statsmodels

Why Data People Are Moving Beyond Excel

EricMWaimiri — Thu, 18 Jun 2026 18:05:00 +0000

You've probably used Microsoft Excel at some point — maybe to track a budget, keep a list, or add up some numbers. It's familiar, it's visual, and it gets the job done. But behind the scenes in banks, hospitals, retail companies, and tech startups, a quiet shift is happening. Data analysts are increasingly reaching for something called pandas — not the animal, but a tool for working with data in Python, one of the world's most popular programming languages.
So, what's the difference, and why does it matter?

Think of Excel as a giant digital table — rows and columns you can see and click on. Want to add up a column? Click a cell, type a formula, done. It's intuitive because everything is right in front of you.
Excel is brilliant for everyday tasks: personal budgets, small business records, simple reports. Millions of people use it every day, and for good reason.
But Excel has limits. Try opening a file with a million rows and your computer might groan. Share it with three colleagues and you end up with three different versions. Repeat the same cleanup task every week and you're doing it by hand, every single time.

Pandas (which stands for "Panel Data Analysis") is a tool that lets you work with data by writing instructions rather than clicking buttons. Instead of highlighting a column and pressing delete, you write a simple line like: "remove this column." It sounds intimidating, but the payoff is enormous.
Here's what makes pandas stand out:
It can handle massive amounts of data. Where Excel starts to struggle around a million rows, pandas can work with tens of millions without breaking a sweat. For a business analyzing years of transaction records or a hospital tracking patient data, this is a gamechanger.
You can automate repetitive work. Imagine you clean up a sales report every Monday morning — removing blank rows, fixing date formats, calculating totals. In Excel, you do that manually each time. In pandas, you write those steps once, save them, and run them in seconds next Monday. And the Monday after that.
It reduces human error. Every time a human clicks, drags, or types in Excel, there's a chance of a mistake. With pandas, the instructions are written down and run the same way every time. Auditors love this. Managers love this. Analysts sleep better at night.
It plays well with other tools. Need to pull data from a database, clean it, analyze it, and send a summary to Power BI or a web dashboard? Pandas sits comfortably in the middle of that pipeline. Excel tends to be a destination; pandas is more of a workhorse in a larger system.

A Simple Example. Say you run a small chain of shops and want to know which branch had the highest sales last quarter, after removing any days the store was closed.
In Excel: you'd filter the data manually, maybe use a SUMIF formula, perhaps copy-paste results into another sheet.
In pandas: you write something like "load the data, remove closed days, group by branch, sum the sales, show me the top result." It runs instantly, and you can reuse the same instructions next quarter.

So Should Everyone Switch?
Not necessarily. Excel is still the right tool for many jobs — quick calculations, simple reports, sharing a file with someone who doesn't use Python. If you're doing something small and one-off, Excel wins on speed and familiarity.
But if you're dealing with large datasets, repeating the same tasks regularly, or building something that other systems need to plug into — pandas starts to look very attractive.
The good news is they're not enemies. Many professionals use both: Excel for quick checks and sharing with non-technical colleagues, pandas for the heavy lifting behind the scenes.

The Bottom Line
Excel is a window. Pandas is a factory. Both have their place — but if your data work is growing in size, complexity, or frequency, it might be time to look beyond the spreadsheet.

Data Analytics with Python as a Beginner

EricMWaimiri — Wed, 13 May 2026 18:55:39 +0000

In today’s digital world, data is everywhere. Every time people shop online, scroll through social media, book a hotel, or use a banking app, they generate data. Companies collect this information to understand customer behavior, improve services, and make smarter business decisions. However, raw data alone is not useful unless it can be analyzed effectively. This is where Python becomes important.

Python is a high-level programming language created by Guido van Rossum in 1991. It is known for its simple syntax, readability, and flexibility. Unlike some programming languages that require complicated commands, Python reads almost like normal English. Because of this, beginners often find it easier to learn compared to languages such as Java or C++.

Over the years, Python has become one of the most popular programming languages in the world. It is used in many fields, including web development, artificial intelligence, cybersecurity, automation, and especially data analytics. Many organizations today depend on data analytics to make informed decisions, predict trends, and improve efficiency. Python provides the tools needed to collect, clean, analyze, and visualize data effectively.

Python is often described as a “Swiss army knife” for data analytics because it can handle many different tasks in one environment. Analysts can use Python to organize messy datasets, calculate statistics, create visual charts, and even build machine learning models that predict future outcomes. Instead of switching between multiple tools, Python allows users to perform all these tasks in one programming language.

Another reason for Python’s popularity is its large ecosystem of libraries. These libraries are collections of prewritten code that make complex tasks easier. For example, instead of writing hundreds of lines of code to analyze data, a user can simply import a library like Pandas or NumPy and perform advanced operations in just a few commands.

Personally, one of the most interesting things about Python is how beginner-friendly it feels. When I first encountered Python code, it looked much simpler and cleaner than I expected programming to be. Even basic commands such as:

print("Hello, Data Analytics!")

show how readable the language is. This simplicity is one reason why Python has become a gateway into the world of data science and analytics for many beginners.

Why Python is Popular in Data Analytics

Python has become the preferred language for data analytics because it combines simplicity, power, and flexibility. Both beginners and professionals use it because it makes working with data easier and faster.

One major reason for Python’s popularity is its beginner-friendly syntax. Many programming languages use complex structures that can confuse new learners. Python, however, focuses on readability. Commands are written in a clean and straightforward way, making it easier to understand what the code is doing. This allows beginners to focus more on solving problems instead of struggling with syntax errors.

For example:

x = 10
y = 20
print(x + y)

Even someone with little programming knowledge can understand what the code is doing. This simplicity makes Python ideal for students and people transitioning into analytics from non-technical backgrounds.

Another reason for Python’s success is its huge ecosystem of libraries. Libraries are prebuilt collections of code designed to perform specific tasks. In data analytics, Python libraries save analysts a lot of time because they provide ready-made tools for calculations, visualization, and machine learning. Instead of building everything from scratch, users can rely on tested and optimized libraries.

Python also has strong community support. Millions of developers around the world contribute tutorials, online forums, videos, and open-source projects. If a beginner encounters a problem, there is a high chance someone else has already solved it online. Websites like Stack Overflow and Kaggle provide useful resources for learners.

Another advantage is integration. Python works well with databases, cloud platforms, Excel files, APIs, and visualization tools. This flexibility allows analysts to connect Python with real-world business systems. For example, a company can use Python to extract sales data from a database, clean it, visualize trends, and generate reports automatically.

Python is also widely used in industries such as finance, healthcare, retail, and hospitality. This broad adoption means that learning Python opens many career opportunities. Companies are constantly looking for employees who can analyze data and turn it into useful insights.

When I first explored Python for data analytics, I noticed how quickly tasks could be automated. Something that would take hours in Excel could often be completed in minutes using Python scripts. That efficiency is one of the reasons why Python continues to dominate the analytics field.

Key Python Libraries for Data Analytics

Python’s true power in data analytics comes from its libraries. These libraries provide specialized tools that simplify data-related tasks. Without them, analysts would have to write complex code from scratch. Some libraries focus on calculations, others on visualization, and others on machine learning.

One of the most important libraries is NumPy. NumPy stands for Numerical Python and is mainly used for numerical computing. It provides support for arrays and matrices, allowing calculations to be performed efficiently. Arrays in NumPy are faster and more memory-efficient than standard Python lists.

Example:

import numpy as np

numbers = np.array([1, 2, 3, 4, 5])
print(numbers.mean())

This code calculates the average of the numbers in the array.

Another essential library is Pandas. Pandas is widely used for data cleaning and manipulation. It introduces the concept of DataFrames, which are tables similar to Excel spreadsheets. Analysts use Pandas to load datasets, remove duplicates, handle missing values, and organize information.

Example:

import pandas as pd

df = pd.read_csv("sales.csv")
print(df.head())

When I first used Pandas, I realized how much easier it was to clean messy Excel sheets. Tasks that normally required many manual steps could be completed with a few lines of code.

For visualization, analysts often use Matplotlib and Seaborn. These libraries help create graphs and charts that make data easier to understand. Visualization is important because people often understand trends better through visuals than raw numbers.

Example:

import seaborn as sns

sns.barplot(x="Department", y="Revenue", data=df)

This creates a bar chart showing revenue by department.

Another popular library is Scikit-learn. This library is mainly used for machine learning and predictive analytics. It provides tools for regression, classification, clustering, and model evaluation. Beginners often use Scikit-learn to build simple predictive models.

Example:

from sklearn.linear_model import LinearRegression

Finally, there is Statsmodels, which focuses more on statistical analysis. It is useful for hypothesis testing, regression analysis, and advanced statistical modeling.

Together, these libraries form a powerful toolkit for data analytics. They allow analysts to move from raw data to meaningful insights efficiently.

How Python is Used in Data Analytics

Python is used throughout the entire data analytics process. From cleaning raw data to building predictive models, it provides tools that make each stage easier and more efficient.

The first stage is data cleaning. Real-world data is often incomplete, inconsistent, or messy. Datasets may contain missing values, duplicates, or incorrect formatting. Before analysis can begin, the data must be cleaned.

Example:

import pandas as pd

df = pd.read_csv("sales.csv")

# Remove missing values
df.dropna(inplace=True)

# Standardize date format
df["Date"] = pd.to_datetime(df["Date"])

This code removes missing data and converts dates into a consistent format.

The next stage is data analysis. Analysts use Python to calculate statistics, identify patterns, and summarize datasets.

Example:

print(df.describe())
print(df.corr())

The describe() function generates summary statistics, while corr() shows relationships between variables.

Another important area is data visualization. Visualization transforms raw data into graphs and charts that are easier to interpret. Businesses use dashboards and reports to communicate insights clearly.

Example:

import matplotlib.pyplot as plt

df["Revenue"].plot()
plt.show()

Visualization helps decision-makers quickly identify trends and anomalies.

Python is also heavily used in predictive analytics. Predictive analytics involves using historical data to forecast future outcomes. Companies use predictive models to estimate sales, detect fraud, and predict customer behavior.

Example:

from sklearn.linear_model import LinearRegression

model = LinearRegression()
model.fit(df[["Advertising"]], df["Sales"])

This creates a simple regression model that predicts sales based on advertising spending.

One thing I appreciate about Python is how all these tasks can be done within one environment. Instead of switching between Excel, SQL, and visualization software, Python combines everything into one workflow.

Real-World Examples

Python is widely used in many industries because data analytics has become essential for decision-making.

- Finance
Python is used for fraud detection and risk modeling. Banks analyze transaction data to identify suspicious activities. Machine learning models can detect unusual spending patterns that may indicate fraud.

- Healthcare
Python helps analyze patient data and predict diseases. Hospitals use analytics to improve treatment plans and forecast patient admissions. During disease outbreaks, data analytics can help track infection trends and allocate resources effectively.

- Retail
Retail companies use Python for customer segmentation and sales forecasting. Businesses analyze shopping patterns to understand customer preferences and improve marketing strategies. Online stores also use recommendation systems powered by Python to suggest products.

- Hospitality
Python is used for occupancy forecasting and guest sentiment analysis. Hotels analyze booking trends and customer reviews to improve services and optimize pricing strategies.

These examples show that Python is not limited to one industry. Its flexibility makes it valuable in almost every field that relies on data.

Why Beginners Should Learn Python

Python is one of the best programming languages for beginners. Its syntax is simple, readable, and less intimidating compared to many other languages.

Another reason beginners should learn Python is career demand. Data analytics, data science, and artificial intelligence are among the fastest-growing fields globally. Companies are constantly searching for employees with Python skills.

Python also teaches transferable skills. Someone who learns Python for analytics can later branch into web development, automation, cybersecurity, or AI. This flexibility makes Python a long-term investment.

In addition, Python is free and open source. Anyone can download it and start learning without paying for expensive software licenses. The official Python website provides downloads, tutorials, and documentation for beginners.

For beginners, practicing with small projects is important. Platforms like Kaggle provide free datasets and beginner-friendly projects that help learners apply their skills.

Learning Python may feel challenging at first, but consistency makes a huge difference. Even small projects, such as analyzing sales data or creating charts, help build confidence over time.

Conclusion

Python has transformed the field of data analytics by making it easier to collect, clean, analyze, and visualize data. Its simplicity, versatility, and powerful libraries have made it the preferred programming language for beginners and professionals alike.

From finance and healthcare to retail and hospitality, Python is used across industries to uncover insights and support decision-making. Libraries such as Pandas, NumPy, Seaborn, and Scikit-learn provide tools that simplify complex tasks and improve efficiency.

For beginners, Python offers an excellent starting point because it is easy to learn and supported by a massive global community. Beyond analytics, Python also opens pathways into artificial intelligence, automation, and software development.

The best way to learn Python is to start small. Working with simple datasets, experimenting with visualizations, and completing beginner projects on platforms like Kaggle can gradually build confidence and skills. Over time, these small steps can lead to deeper knowledge in data science and analytics.

In a world increasingly driven by data, Python is more than just a programming language — it is a gateway to understanding and solving real-world problems.

Subqueries vs. CTEs and When to Use Each

EricMWaimiri — Mon, 20 Apr 2026 08:00:01 +0000

SQL offers multiple ways to break down complex problems into manageable steps. Two of the most powerful tools for this are subqueries and Common Table Expressions (CTEs). While they often overlap in functionality, understanding their differences is key to writing efficient, maintainable queries.

A subquery is a query nested inside another query. It executes first, and its result feeds into the outer query. Subqueries can appear in SELECT, FROM, or WHERE clauses.

Example:

SELECT first_name
FROM employees
WHERE employee_id IN (
  SELECT employee_id
  FROM salaries
  WHERE salary > 50000
);

Here, the inner query finds employees with salaries above 50,000, and the outer query retrieves their names.

Types of Subqueries

Scalar subquery → returns a single value.

  SELECT (SELECT AVG(salary) FROM salaries);

Row subquery → returns one row with multiple columns.
Table subquery → returns multiple rows/columns, used in FROM.
Correlated subquery → references columns from the outer query and runs repeatedly.

  SELECT e.first_name
  FROM employees e
  WHERE e.salary > (
    SELECT AVG(salary)
    FROM salaries s
    WHERE s.department_id = e.department_id
  );

When to Use Subqueries

Filtering with complex conditions (WHERE IN, EXISTS).
Returning computed values inline.
Quick one‑off queries where readability isn’t critical.
Situations where you don’t want to define intermediate steps.

What Is a CTE?

A CTE is a temporary named result set defined with WITH. It improves readability by breaking queries into logical blocks.

Example:

WITH high_salary AS (
  SELECT employee_id, salary
  FROM salaries
  WHERE salary > 50000
)
SELECT e.first_name, h.salary
FROM employees e
JOIN high_salary h ON e.employee_id = h.employee_id;

Types and Use Cases of CTEs

Non‑recursive CTEs → simplify complex queries, improve readability.
Recursive CTEs → handle hierarchical data (e.g., org charts, tree structures).
Multiple CTEs → chain transformations step by step.

Use cases:

Reporting pipelines.
Breaking down multi‑stage logic.
Recursive problems like traversing parent‑child relationships.

Subqueries vs CTEs

Aspect	Subqueries	CTEs
Performance	Often optimized well, but correlated subqueries can be slow.	Similar performance; recursive CTEs can be powerful but heavy.
Readability	Harder to read if deeply nested.	Much clearer — logic broken into named blocks.
Use Cases	Quick filters, inline calculations.	Complex queries, multi‑step transformations, recursive problems.
Portability	Supported everywhere.	Supported in most modern RDBMS (PostgreSQL, SQL Server, Oracle, MySQL 8+).

For better and more readable queries;

Use subqueries for simple, inline logic.
Use CTEs when queries get complex, recursive, or need to be broken into readable steps.
Performance is usually similar, but CTEs win on readability and maintainability.

First Week Reflections on SQL

EricMWaimiri — Mon, 13 Apr 2026 14:06:35 +0000

DDL vs DML
In SQL, two families of commands shape how we interact with data: Data Definition Language (DDL) and Data Manipulation Language (DML).

DDL commands (CREATE, ALTER, DROP) are like the architect’s blueprint, they define the structure of the database.
DML commands (INSERT, UPDATE, DELETE, SELECT) are the everyday tools. They let us add, change, or remove the actual records inside those structures. Here is how I tackled the first assignment:
CREATE built the schema nairobi_academy and three tables (students, subjects, exam_results).

INSERT populated each table with 10 rows of realistic data.

UPDATE corrected mistakes: Esther Akinyi’s city changed from Nakuru to Nairobi, and marks for result_id 5 were fixed from 49 to 59.

DELETE removed the cancelled exam result with result_id 9.

Filtering with WHERE
The WHERE clause is the gatekeeper of SQL. Without it, every row would be affected — a dangerous mistake!

I used it to:
_- Find students in Form 4 (WHERE class = 'Form 4').

Retrieve exam results with marks >= 70.
Combine conditions (WHERE class = 'Form 3' AND city = 'Nairobi').
Explore operators like:
- BETWEEN for ranges (marks between 50 and 80).
- IN for multiple matches (cities in Nairobi, Mombasa, Kisumu).
- LIKE for patterns (names starting with A or E). _

It’s the precision tool that makes queries powerful and safe.

CASE WHEN: Transforming Data
Raw numbers are useful, but categories tell stories. With CASE WHEN, I transformed exam marks into performance labels: Distinction, Merit, Pass, or Fail.

I also classified students as Senior (Form 3 or 4) or Junior (Form 1 or 2).

The most challenging part was remembering to always pair UPDATE and DELETE with WHERE. Forgetting it could wipe out entire tables in seconds. The most interesting part was experimenting with CASE WHEN. It was like giving the database a voice: instead of just numbers, it could tell me who excelled, who struggled, and who was senior or junior. This week, I realized that the beauty of SQL lies in precision and creativity.

Publish a Power BI Report and Embed It into a Website.

EricMWaimiri — Tue, 07 Apr 2026 09:20:49 +0000

Power BI transforms raw numbers into interactive dashboards that are full of insights. The real magic, however, happens when you share those dashboards with the world. Publishing and embedding a Power BI report lets your audience explore the data directly on your website, turning a static page into a dynamic story.

- Create a Workspace
Workspaces organize your reports and control who can access them.

Go to Power BI Service; Workspaces; Create Workspace
Log in to the Power BI Service app.powerbi.com
Click Workspaces in the left navigation
Select Create a Workspace and give it a name

- Upload and Publish Your Report
Publishing moves your report from Power BI Desktop to the cloud.

In Power BI Desktop; Home; Publish
Open your report in Power BI Desktop
Click Publish on the ribbon

Choose the workspace you created

Confirm upload; the report will appear in the Power BI Service

- Generate the Embed Code
The embed code allows you to integrate the report into a website.

Go to Power BI Service; Report (In Workspace); File; Embed Report
Open your report in the Power BI Service Click File → Embed Report → Website or Portal
Copy the iframe embed code provided

- Embed the Report on Your Website

Open a text editor
Write or generate a code to embed a power BI report on your website
Paste the iframe embed code where you want the report to appear

Save and publish your website
Open the embedded report on your browser to ensure it loads and is interactive

To understand all the technicality, think of it like this:

Workspaces are the foundation for organizing and securing reports.
Publishing moves reports from desktop to the cloud.
Embed codes are the bridge between Power BI and your website.
Embedded reports remain fully interactive, giving your audience a dynamic data experience.