DEV Community: Okall Omondi

How Python Loops Actually Work: A Hands-On Guide with Real Projects

Okall Omondi — Fri, 18 Sep 2026 06:04:31 +0000

Like I said in my Python Operators and Conditionals article, loops are also fundamental and understanding and using them in your program elevates your code to Thanos status with his Infinity Stone.

At first, loops felt like a bit of a party trick. I knew I needed them whenever I wanted to repeat something, but my code often turned into messy trial and error. I would mix up when to use for instead of while, trigger infinite loops that froze my terminal, or manually track counter variables when Python already had a cleaner way built in.

Things clicked once I stopped treating loops as abstract syntax and started looking at them through practical problems.

In this guide, I will walk you through how Python loops work, the difference between for and while, how control keywords like break and continue alter execution, and why enumerate() is a cleaner alternative to manual counters. To make this practical, I'll share real snippets from small projects I built while wrapping my head around these concepts.

The Two Core Loops in Python

Python gives us two primary tools for repetition: for loops and while loops. The distinction comes down to one question: Do you know how many times you need to run, or are you waiting for a condition to change?

1. The `for` Loop: Definite Iteration

A for loop moves through an iterable: like a list, a string, a tuple, or a range of numbers, one item at a time. It executes the code block for each element and stops automatically when it reaches the end.

names = ["Alice", "Bob", "Charlie"]

for name in names:
    print(f"Hello, {name}!")

Here, Python handles the bookkeeping. It grabs "Alice", runs the block, grabs "Bob", and finishes after "Charlie". You don't have to check list lengths or manage indices manually.

2. The `while` Loop: Indefinite Iteration

A while loop runs as long as a specified condition evaluates to True. Because you often do not know in advance how many iterations you will need, it works well for event loops, game loops, or user input validation.

attempts = 3

while attempts > 0:
    print(f"You have {attempts} attempts left.")
    attempts -= 1

If the condition never becomes False, the loop runs forever. That is why every while loop needs either state changes within its body or an explicit exit strategy.

Steering Loop Execution: `break` and `continue`

Loops normally run on autopilot, but real-world logic often demands overrides. Python provides two primary keywords to alter loop flow: break and continue.

break: Immediately halts the loop and jumps straight to the code outside it.
continue: Skips the rest of the current iteration and jumps directly to the next cycle.

Let’s look at how both work in practice.

Project 1: User Validation Using a `while` Loop and `break`

A classic scenario for a while loop is taking input from a user. You cannot predict whether someone will provide a valid password on their first attempt or their tenth.

I built a mini password checker that runs continuously using while True, evaluates input rules, and calls break as soon as the criteria are met:

def check_password():
    while True:
        password = input("Enter password: ")

        length_ok = len(password) >= 8
        not_password = password.lower() != "password"
        with_digit = any(char.isnumeric() for char in password)

        if length_ok and not_password and with_digit:
            print("Password accepted.")
            break
        else:
            print("Password rejected. Try again.")
            if not length_ok:
                print("Password must be at least 8 characters long.")
            elif not not_password:
                print("Password cannot be 'password'.")
            elif not with_digit:
                print("Password must contain at least 1 digit.")

check_password()

Why this works

Setting while True creates an intentional infinite loop. The program repeatedly prompts the user until every boolean condition evaluates to True. Once the input satisfies length_ok, not_password, and with_digit, the break statement fires. That immediately terminates the loop without needing an external flag variable.

Project 2: Data Filtering Using a `for` Loop and `continue`

While break bails out entirely, continue acts like a skip button. It is particularly useful when processing records where certain items should be ignored without stopping the whole workflow.

Here is a transaction ledger script where I needed to calculate total net deposits and withdrawals while filtering out administrative service fees:

transactions = [
    ('Deposit', 5000),
    ('Withdrawal', -1200),
    ('Deposit', 3000),
    ('Fee', -50),
    ('Deposit', 2000)
]

total = 0

for transaction_type, amount in transactions:
    if transaction_type == 'Fee':
        continue  # Skip this iteration entirely

    total += amount
    print(f"{transaction_type}: {amount}")

print(f"The total transacted: {total}")

Why `continue` is useful here

When the loop encounters ('Fee', -50), the condition triggers continue. Python skips both total += amount and the print() statement below it, jumping immediately to the next tuple ('Deposit', 2000).

Without continue, you would need to wrap the calculation in nested if/else blocks. Using continue keeps your primary business logic unindented and easier to read.

Project 3: Clean Tracking with `enumerate()`

A common beginner habit when needing item positions is manually tracking an index counter:

# The cluttered way
items = ["Apples", "Bananas", "Cherries"]
index = 0
for item in items:
    print(f"{index}: {item}")
    index += 1

Or worse, looping over range(len(items)):

# The clunky way
for i in range(len(items)):
    print(f"{i}: {items[i]}")

Python provides enumerate() to solve this cleanly. It wraps any iterable and yields pairs containing the current count along with the item itself.

Here is a mini task checklist script demonstrating how clean this looks in a project context:

tasks = [
    "Review pull requests",
    "Fix database migration bug",
    "Update API documentation",
    "Send release notes"
]

print("Today's Priority Queue:")
for priority, task in enumerate(tasks, start=1):
    print(f"[{priority}] {task}")

Output:

Today's Priority Queue:
[1] Review pull requests
[2] Fix database migration bug
[3] Update API documentation
[4] Send release notes

Notice the start=1 argument. By default, enumerate() starts counting at 0, which matches Python's zero-based indexing. Passing start=1 instantly adapts the counter for human-facing output without needing clumsy math like priority + 1 inside your display strings.

Common Mistakes to Watch For

Forgetting to advance a counter in while loops: If you use a variable in your condition (like while count < 5:), make sure you update count inside the loop body. Forgetting this creates an infinite loop that pins your CPU.
Modifying a list while looping over it: Removing or adding elements to a list you are currently iterating through causes skipped items and unpredictable behavior. If you need to filter a list, iterate over a copy or build a new list instead.
Overusing range(len(...)): If you only need the items, use for item in collection:. If you need both the index and the item, use enumerate(collection). Reaching for range(len(...)) is rarely the most readable choice in Python.

Summary Checklist

Use a for loop when you have a sequence to traverse or know the number of iterations upfront.
Use a while loop when iterating based on a state or condition that changes dynamically during execution.
Use break to exit a loop immediately when a stopping condition is met.
Use continue to skip the rest of the current iteration and move to the next item.
Use enumerate() whenever you need item indices alongside their values.

Write small scripts to experiment with loop behavior. Once you can predict how data moves through each cycle, structuring your programs becomes straightforward.

How Python Operators and Conditionals Actually Work (With Real Project Code)

Okall Omondi — Thu, 17 Sep 2026 06:37:46 +0000

When I first started writing code, everything felt like a simple sequence: run line one, then run line two, then exit. But real software doesn't run in a straight line. It has to make decisions.

Did the user input a username and/or password? Is the username correct? Should a user be allowed to sign in? Does a phone number match the format you expect? And many more.

Answering these questions comes down to two foundational ideas in Python: operators and conditionals. Once you understand how they work together, your scripts stop being static lists of commands and start behaving like real applications.

Here is what I learned while wrapping my head around them, along with code from a command-line contact book project I built to put these concepts to work.

You can also check my previous articles on Python. Python will Save You Time. Here is Why and How and Python Basics: Where It All Starts

What Are Operators?

Think of operators as the verbs of Python. They take pieces of data (called operands) and do something with them, usually spitting out a brand new value.

Python has several categories of operators, but three show up constantly when you're controlling program flow: arithmetic, comparison, and logical operators.

1. Arithmetic Operators

You probably know these from math class: addition (+), subtraction (-), multiplication (*), and division (/).

In Python, though, arithmetic operators aren't just for math. They can also manipulate text. For example, multiplying a string repeats it:

print("=" * 40)
# Outputs: ========================================

This is a neat trick for printing clean visual borders in terminal menus without typing forty equals signs by hand.

2. Comparison Operators

These operators compare two values and always return a Boolean: either True or False.

== checks if two values are equal
!= checks if two values are not equal
<, >, <=, >= handle standard less-than and greater-than checks

A classic mistake here is confusing = with ==. A single equals sign assigns a value to a variable (age = 25). A double equals sign asks a question (age == 25). Python will throw a syntax error if you mix these up in an if statement, but it still trips up almost everyone in the beginning.

3. Logical Operators

Logical operators let you combine multiple conditions:

and returns True only if both conditions are true.
or returns True if at least one condition is true.
not reverses the Boolean value (turning True to False, and vice versa).

Python reads these almost like plain English, which makes long conditions much easier to decipher.

Directing Traffic with Conditionals

Conditionals are where operators get useful. They tell Python: "Only run this block of code if a specific condition evaluates to True."

The basic structure uses if, elif (short for else-if), and else:

score = 85

if score >= 90:
    print("Grade: A")
elif score >= 80:
    print("Grade: B")
else:
    print("Keep practicing!")

Python evaluates these from top to bottom. As soon as one condition evaluates to True, Python executes that indented block and skips the rest of the chain completely.

How I Used Them in a Project: The Contact Book

Theory is fine, but seeing these ideas handle messy real-world input is where things click.

Recently, I built a command-line contact book that stores names and Kenyan phone numbers in a dictionary. The entire program relies on operators and conditionals to route user choices and validate data.

Here is the core logic:

import re

contacts = {}

while True:
    print("=" * 40)
    print("1. Add Contact\n2. Search Contact\n3. Delete Contact\n4. Print All\n5. Quit")
    choice = str(input("Enter your choice (1-5): ")).strip()

    if choice == '1':
        name = input("Enter contact name: ").strip().lower()

        # Checking for empty strings using "not"
        if not name:
            print("Name cannot be empty. Please enter a valid name.")
            continue

        # Using the "in" membership operator
        if name in contacts:
            print(f"Contact {name} already exists. Do you want to update their number? (y/n): ")
            update = input().strip().lower()
            if update == 'n':
                continue

        phone = input("Enter phone number: ").strip()

        # Validation checks
        if not phone.isdigit():
            print("Invalid phone number. Please enter digits only.")
            continue
        else:
            if phone.startswith('+254'):
                phone = '0' + phone[4:]

            if re.match(r"^(07|01)\d{8}$", phone):
                contacts[name] = phone
                print(f"Added {name}: {phone} successfully.\n")
            else:
                print("Invalid phone number format. Must start with 07 or 01 and have 10 digits.\n")

    elif choice == '2':
        name = input("Enter contact name: ").strip().lower()
        if name in contacts:
            print(f"{name}: {contacts[name]}")
        else:
            print("Contact not found.")

    elif choice == '3':
        name = input("Enter contact name: ").strip().lower()
        if name in contacts:
            del contacts[name]
            print(f"Contact {name} deleted successfully.")
        else:
            print("Contact not found.")

    elif choice == '4':
        # Checking truthiness of the contacts dictionary
        if contacts:
            print("All Contacts:")
            print("=" * 40)
            for name, phone in contacts.items():
                print(f"{name}: {phone}")
            print(f"Total contacts: {len(contacts)}\n")
        else:
            print("No contacts to display.")

    elif choice == '5':
        print("Goodbye!")
        break

    else:
        print("Invalid choice, please select 1-5.\n")

Let's break down three specific ways operators and conditionals keep this program from breaking.

1. Truthiness and the `not` Operator

Look at how empty inputs are handled:

if not name:
    print("Name cannot be empty.")
    continue

In Python, empty structures, like an empty string "", an empty list [], or an empty dictionary {} are considered "falsy." That means Python treats them as False in a conditional context.

If the user hits Enter without typing a name, name is "". Python sees that as False. The not operator flips that False to True, triggering the warning and restarting the loop.

I used the same concept when printing the directory:

if contacts:
    # Print the directory
else:
    print("No contacts to display.")

Instead of writing if len(contacts) > 0:, we can test the dictionary directly. If it has items, it is truthy. If it's empty, it evaluates to False.

2. The `in` Membership Operator

Before adding, updating, or deleting a name, the program needs to know if that person already exists:

if name in contacts:
    del contacts[name]

in is a membership operator. It checks whether a specific key exists inside a collection. Using in keeps your code readable and saves you from writing manual search loops just to see if a record is there.

3. Cleaning and Validating Inputs

Real data is unpredictable. Users add extra spaces, enter letters where numbers belong, or use international prefixes instead of local ones.

The nested conditionals inside option 1 act like a filter:

if not phone.isdigit(): catches accidental letters or symbols right away.
if phone.startswith('+254'): checks for the Kenyan country code and normalizes it to a local zero (phone = '0' + phone[4:]).
An inner regular expression check ensures the number begins with 07 or 01 and contains exactly ten digits.

If any check fails, execution stops early with a clear error message instead of corrupting the dictionary with bad data.

Three Common Mistakes to Avoid

Forgetting that `input()` Returns a String

When asking users for numbers, beginners often write:

age = input("Enter your age: ")
if age >= 18:
    print("Allowed")

This crashes with a TypeError. Even if the user types 20, Python stores it as "20" (text). You cannot compare text to an integer. You must explicitly convert it using int(input(...)) or keep both sides of your comparison as strings, like I did with choice == '1'.

Accidental Assignment

Writing if choice = '1': instead of if choice == '1': will stop your script immediately. Assignment gives a variable a value; comparison evaluates a relationship.

Over-Nesting Conditionals

It's tempting to put if statements inside if statements five levels deep. If you catch yourself indenting four or five times, consider using and to combine conditions, or use guard clauses (like continue or return) to kick out invalid data early.

Practical Takeaways

Use string operators for formatting: "=" * 40 keeps your CLI output clean without clutter.
Lean on truthiness: You don't need if len(my_list) == 0:. A simple if not my_list: is cleaner and more idiomatic Python.
Validate early: Check for bad inputs first and exit early. It keeps your main logic clean and easier to maintain.
Remember that = assigns, while == compares.

Operators and conditionals are the decision-makers in your scripts. Once you get comfortable combining them, you can handle unexpected input, manage state, and build programs that work reliably. Give a simple CLI tool like this a try—building one teaches you more about logic flow than reading syntax ever will.

Python Basics: Where It All Starts

Okall Omondi — Wed, 16 Sep 2026 05:17:46 +0000

When you decide to learn programming, you run into an immediate wall of jargon: compilers, memory allocation, object-oriented paradigms, and low-level system design. It is enough to make anyone close their laptop and walk away.

This is where Python changes things. Python was designed around a simple philosophy: readability counts. The syntax reads surprisingly close to plain English, letting you focus on learning how to solve problems with logic rather than wrestling with obscure symbols.

If you are just getting started, or if you already know another language and want to pick up Python without the fluff, this guide covers the core foundation you will use every day.

Why Python Syntax Feels Different

Python strips away the visual noise common in other programming languages like C++ and Java. It uses indentation (whitespace) to determine how code blocks are structured, and new lines signify the end of a statement.

Here is the classic starting point in Python:

print("Hello, World!")

That is the entire program. The print() function takes whatever data you pass inside its parentheses and displays it on your terminal screen.

Indentation Matters!

Because Python does not rely on braces to group code, spacing is not optional aesthetic formatting. Spacing is an executable part of the language.

Standard convention is to use four spaces per indentation level. Avoid mixing tabs and spaces in the same file, as Python will raise an IndentationError if the spacing is inconsistent.

Storing Data: Variables and Dynamic Typing

Programs are essentially engines that take data, transform it, and display a result. To work with data, you need a way to label and store it temporarily in your computer's memory. That is what a variable is: a named label pointing to a value.

In Python, you do not declare a variable type in advance. You simply write the variable name, use the assignment operator (=), and provide the value.

user_name = "Navas"
user_age = 28
account_balance = 200145.50
is_active = True

This behavior is called dynamic typing. Python inspects the value on the right side of the equals sign at runtime and assigns the appropriate data type automatically.

Naming Conventions

Python developers follow a style guide known as PEP 8. For variable names, the standard convention is snake_case: lowercase letters with words separated by underscores.

Good: total_score, first_name, max_limit
Avoid: TotalScore, firstName, x (unless x is a standard math variable)

Core Data Types You Will Use Daily

Everything stored in a Python variable has a type. Let us walk through the four primitive types you will interact with constantly.

1. Integers (`int`)

Integers represent whole numbers, positive or negative, without a decimal point.

items_in_cart = 5
temperature_change = -3

2. Floating-Point Numbers (`float`)

Floats represent real numbers that include a fractional part using a decimal point.

tax_rate = 0.08
item_price = 19.99

Keep in mind that computers handle floating-point arithmetic using binary approximations. If you calculate 0.1 + 0.2, you might occasionally see 0.30000000000000004 rather than an exact 0.3. For everyday scripts, this rarely causes issues, but for financial applications, Python provides a dedicated decimal module to avoid precision rounding errors.

3. Strings (`str`)

Strings are sequences of characters used to store text. You define them using single quotes '...' or double quotes "...".

greeting = "Welcome back!"
file_path = 'documents/notes.txt'

Both styles work identically. The common convention is to pick one style and stay consistent throughout your script, switching only when you need quotes inside the string itself (for example: "Don't forget your keys").

4. Booleans (`bool`)

Booleans represent binary truth values: either True or False. Notice that both start with a capital letter in Python.

logged_in = True
has_permission = False

These become essential later when you write conditional statements (if / else) to control the flow of your program based on real-time conditions.

Taking Input and Displaying Output

A program becomes truly useful when it interacts with the person using it. You have already seen print() for output. To capture data from someone using the program, Python provides the built-in input() function.

Here is how input and output work together:

name = input("What is your name? ")
print("Nice to meet you, " + name + "!")

When Python encounters input(), it pauses execution and waits for the user to type something into the console and press Enter.

The Input Type Trap

There is one critical behavior every beginner runs into with input(): it always returns user input as a string (str), even if the user enters digits.

Consider this snippet:

age = input("Enter your age: ")
next_year = age + 1  # This will trigger a TypeError!

If you enter 25, Python does not see the number 25. It sees the string "25". Trying to add an integer to a text string causes Python to throw an error: TypeError: can only concatenate str (not "int") to str.

To fix this, convert the string into a numeric type using type casting:

age = input("Enter your age: ")
age_number = int(age)
next_year = age_number + 1

print(f"Next year you will be {next_year} years old.")

The int() function converts valid text digits into an actual integer. If you expect numbers with decimal points, use float() instead.

Formatting Strings with f-Strings

In older Python tutorials, you will see string concatenation with plus signs ("Hello " + name) or the .format() method. Modern Python (version 3.6 and newer) uses f-strings (formatted string literals).

Prefix your string with the letter f, and you can place any variable or expression directly inside curly brackets {}:

product = "Mechanical Keyboard"
price = 5000
quantity = 2

print(f"Purchased {quantity} x {product} for a total of Ksh. {price * quantity:.2f}")

Notice the :.2f inside the brackets. That is a format specifier that rounds the calculated floating-point total to two decimal places. It is clean, readable, and saves you from converting values manually just to print them.

A Working Example: Tip Calculator

Let us combine variables, arithmetic operators, user input, type casting, and f-strings into a practical terminal tool.

# Simple Bill & Tip Calculator

print("=== Bill Splitter ===")

# Gather input
total_bill_str = input("Enter the total bill amount: Ksh. ")
tip_percentage_str = input("Enter tip percentage (e.g., 15, 18, 20): ")
people_count_str = input("How many people are splitting the bill? ")

# Convert input strings to appropriate numerical types
bill = float(total_bill_str)
tip_percent = float(tip_percentage_str)
people = int(people_count_str)

# Perform the calculations
tip_amount = bill * (tip_percent / 100)
final_total = bill + tip_amount
cost_per_person = final_total / people

# Display the results
print("\n--- Summary ---")
print(f"Total tip: Ksh. {tip_amount:.2f}")
print(f"Final bill: Ksh. {final_total:.2f}")
print(f"Each person pays: Ksh. {cost_per_person:.2f}")

If you run this code, you have built a complete, interactive utility using nothing more than basic variables, type conversion, and standard input/output.

Three Mistakes to Watch Out For

Forgetting that variable names are case-sensitive. score, Score, and SCORE are three distinct variables in Python. If you create a variable named user_input and later try to print User_input, Python will stop and report a NameError.
Confusing = with ==. A single equals sign (=) assigns a value to a variable. A double equals sign (==) compares two values to see if they are equal.
Leaving out type conversion after input(). If you plan on doing any math with user-provided information, cast it to int() or float() immediately.

Key Takeaways

Python prioritizes clean, readable syntax and uses indentation rather than curly braces to define scope.
Variables do not require explicit type definitions; Python handles typing dynamically at assignment.
The core primitive types are integers (int), floating-point numbers (float), strings (str), and booleans (bool).
input() always captures text as a string; use int() or float() when you need numbers.
Formatted string literals (f"...") are the cleanest and most efficient way to embed variables inside strings.

My Take

Writing code is less about memorizing syntax rules and more about building a habit of breaking problems into small, logical steps. With variables, types, and input/output under your belt, you have the groundwork needed to start exploring decision logic, loops, and custom functions. Fire up a terminal, experiment with the tip calculator, tweak the formulas, and see what happens. And don't forget to practice, practice, practice and practice!

Python will Save You Time. Here is Why and How.

Okall Omondi — Tue, 15 Sep 2026 05:14:00 +0000

When you decide to learn to program, the first hurdle isn't a tricky concept or a confusing line of syntax. It is the overwhelming paradox of choice. You run into dozens of languages: C++, JavaScript, Go, Rust, Java, and Python. Every forum insists a different one is the absolute best starting point.

If your goal is to build things quickly, automate boring everyday tasks, or make sense of data, the debate usually ends right where it begins: with Python.

Let's look at why Python continues to dominate developer surveys, why it quietly took over the data science industry, and whether it makes sense for your specific goals.

Code That Actually Looks Like English

The biggest barrier for newcomers isn't logic; it's notation.

Many classic programming languages demand significant boilerplate code just to say hello. In Java or C++, printing a simple message involves defining classes, writing method signatures, managing memory scopes, and placing semicolons after every instruction. Miss a bracket, and the entire program halts with an error message that looks like ancient script.

Python took a completely different design path. Its creator, Guido van Rossum, believed that code is read far more often than it is written.

Consider how you display text on a screen in Python:

print("Hello, world!")

That is the entire program. No boilerplate, no headers, no memory management setup.

Python enforces readability by making indentation part of the syntax itself. In most languages, spaces and tabs are just stylistic preferences. In Python, an indent defines a block of related code. This constraint forces everyone, from hobbyists to senior engineers, to write clean, legible code that you can still decipher six months later.

The Mental Shift: From Mechanics to Problem-Solving

Every programming language requires you to juggle two things at once:

The logic: How do I solve this problem?
The syntax: How do I express this solution so the compiler accepts it?

When you work in lower-level languages, syntax often consumes 70% of your attention. You spend mental bandwidth worrying about pointer arithmetic, static type definitions, and manual memory allocation.

Python flips those priorities. Because the syntax stays out of your way, you spend your time thinking about the actual problem you set out to solve.

If you want to read a text file line by line, you write code that mirrors that thought:

with open("notes.txt") as file:
    for line in file:
        print(line.strip())

This clarity creates a positive feedback loop. Instead of spending an afternoon troubleshooting cryptic compilation errors, you see working results within minutes. That immediate feedback is what keeps beginners engaged long enough to build real competence.

Why Python Owns Data Science

Python is versatile, it powers web backends, workflow automation, and game scripts. But its strongest foothold is in data analysis, machine learning, and scientific research.

How did a general-purpose language beat out specialized statistical languages like R, SAS, or MATLAB? It comes down to two structural advantages.

1. The Modular Ecosystem

Python’s standard library comes with plenty of built-in tools. However, its real power comes from community-developed libraries. A library is simply a collection of pre-written functions you can plug into your project so you don't have to reinvent the wheel.

In the data world, Python offers a cohesive toolkit:

NumPy: Handles heavy mathematical operations and multi-dimensional arrays at lightning speed.
Pandas: Provides data structures that make filtering, grouping, and reshaping tabular datasets as straightforward as working in an Excel spreadsheet.
Matplotlib & Seaborn: Turn raw columns of numbers into clear charts and visualizations with a few lines of instructions.
Scikit-Learn: Gives you access to industry-standard machine learning algorithms through clean, consistent interfaces.

Because these tools share design philosophies, they fit together cleanly. You can load messy records using Pandas, run a statistical calculation with NumPy, and graph the pattern with Seaborn, all within the same 15 lines of script. How awesome is that?

2. Fast Development Over Fast Execution

A common criticism from systems engineers is that Python is slow compared to compiled languages like C or Rust. Technically, they are correct. Python is an interpreted language, which introduces execution overhead.

Here is the trade-off that industry learned the hard way: developer time is almost always more expensive than CPU time.

If an algorithm written in C takes 2 milliseconds to run, but requires three days to write and debug, while the Python version takes 20 milliseconds to run and two hours to build, Python wins in most business scenarios.

More importantly, the data science community solved the speed problem through smart engineering. Heavy computation libraries like NumPy and PyTorch are written in optimized C, C++, or CUDA under the hood. Python simply acts as the friendly steering wheel controlling an engine built for raw performance. You get high-level readability without sacrificing the muscle needed to process millions of rows.

Common Traps to Watch Out For

While Python is forgiving, it isn't completely frictionless. As you spend more time with the language, keep these three nuances in mind:

Dynamic typing can bite you: In Python, a variable can hold a number on one line and a string of text on the next. This flexibility is great for fast prototyping, but it can hide bugs in larger applications. Learning to use type hints (def calculate_tax(amount: float) -> float:) will save you countless headaches down the road.
Indentation errors are real errors: Because spacing carries structural meaning, mixing tabs and spaces will trigger errors. Stick to a modern editor like VS Code that automatically inserts four spaces whenever you press the Tab key.
Tutorial purgatory: Because Python is approachable, beginners often get stuck watching endless video series without building anything independently. Write your own tiny scripts early on, even if it's just a tool to rename twenty downloaded files at once.

Fun Fact: I use Python to organize my files in the Download folder in my PC.

The Direct Route Forward

Python isn't popular because of clever marketing; it earned its position because it respects your time. It strips away technical friction so you can focus on data, logic, and solutions.

If you are starting out, don't worry about mastering every feature of the language. Install Python, learn the basics of variables, loops, and functions, and then immediately pick a project that interests you. Build a simple data dashboard, scrape a table off a public webpage, or automate a repetitive work report.

My Take

The syntax will stick naturally once you use it to solve problems you actually care about. You will learn faster by doing, not by watching tutorials.

Learning SQL? Here is a Practical Guide to Read and Write SQL Queries.

Okall Omondi — Mon, 07 Sep 2026 15:05:58 +0000

Introduction

Every web application, BI dashboard, and digital checkout system has one thing in common: it runs on data. User profiles, product inventories, and transaction logs have to live somewhere durable, and that somewhere is almost always a relational database.

To get that data out, you need to talk to the database in a language it understands. That language is SQL.

If you have never written a line of code in your life, SQL is arguably the gentlest entry point into tech. It reads shockingly close to plain English, and unlike other general-purpose languages such as Python, you don't need to instruct the computer how to loop through lists or manage memory. You simply describe what data you want, and the database figures out how to retrieve it.

Let's walk through how it works, how a query is structured, and how you can write your first one today.

What SQL Actually Is

SQL stands for Structured Query Language. People pronounce it either as three individual letters ("S-Q-L") or as "sequel." Both are widely accepted across engineering teams, so use whichever feels natural.

At its core, SQL is a domain-specific language designed to manage and retrieve data stored in a relational database management system (RDBMS). Popular examples of these systems include PostgreSQL, MySQL, SQLite, and Microsoft SQL Server.

While each system has slight dialect differences, the baseline syntax remains remarkably consistent. Once you learn standard SQL, switching between MySQL and PostgreSQL feels like moving between different dialects of English: a few spelling tweaks and regional idioms, but the underlying grammar is identical.

How Data Is Organized

Before querying data, you need a mental model of where it lives.

Think of a relational database as a collection of spreadsheets.

A database is the entire workbook.
A table is a single sheet within that workbook.
A column represents a specific category or attribute (such as email, first_name, or created_at).
A row (often called a record) is a single entry across those columns (one specific user or one distinct order).

When you write a query, you are simply asking the database to open a specific sheet, inspect its columns, and hand back the rows that match your criteria.

Anatomy of a SQL Query

A SQL statement consists of reserved keywords combined with the names of your tables and columns.

Consider a practical scenario: you have a table named customers, and you want to view the first names and email addresses of everyone in that table.

Here is what that query looks like:

SELECT first_name, email
FROM customers;

Notice a few conventions right away:

Keywords are capitalized: SELECT and FROM are commands built into the language. Capitalizing them is not strictly required by most database engines, but doing so makes your code substantially easier to read.
Column names are separated by commas: You list the exact fields you want back, separated by a comma.
The statement ends with a semicolon: In SQL, the semicolon acts like a period at the end of a sentence. It tells the engine that your instruction is complete.

If you wanted to inspect every single column in the table without typing out every field name, you can use the asterisk wildcard:

SELECT *
FROM customers;

A quick word of caution from experience: using SELECT * is convenient when exploring a new dataset on your local laptop, but it becomes a performance bottleneck in production systems with millions of rows and dozens of columns. Get into the habit of asking only for what you actually need.

Filtering Data with the WHERE Clause

Pulling every record from a table is rarely useful in the real world. Usually, you want answers to specific questions: Which customers live in Nairobi? Which orders were placed today? Which accounts are inactive?

To filter rows, add a WHERE clause:

SELECT first_name, email, city
FROM customers
WHERE city = 'Nairobi';

When filtering text values (strings), wrap the text in single quotes. Numbers, on the other hand, do not take quotes:

SELECT product_name, price
FROM products
WHERE price > 50;

Combining Conditions

Real-world questions often have multiple layers. You can chain conditions together using AND, OR, and NOT.

AND requires both conditions to be true:

  SELECT product_name, price, stock_quantity
  FROM products
  WHERE price > 50 AND stock_quantity > 0;

OR requires at least one condition to be true:

  SELECT first_name, city
  FROM customers
  WHERE city = 'Nairobi' OR city = 'Kisumu';

IN handles lists cleanly: Instead of stringing together six different OR checks, you can test membership against a list:

  SELECT first_name, city
  FROM customers
  WHERE city IN ('Nairobi', 'Kisumu', 'Mombasa');

Sorting and Limiting Results

Databases do not store records in any guaranteed default order. If you run a query twice, the rows might return in a different sequence unless you explicitly tell the database how to arrange them.

Ordering Rows

The ORDER BY clause lets you sort by one or more columns, either ascending (ASC, the default) or descending (DESC):

SELECT product_name, price
FROM products
ORDER BY price DESC;

This returns your product inventory starting with the most expensive item.

Restricting the Row Count

When you only care about top performers or want a quick sample of the data, pair ORDER BY with LIMIT:

SELECT product_name, price
FROM products
ORDER BY price DESC
LIMIT 5;

Now you have a clean list of your five most expensive products.

The Hidden Rule: Written Order vs. Execution Order

Here is something that catches almost every newcomer off guard: the order in which you write a SQL query is not the order in which the database executes it.

When you write a query, standard syntax requires this sequence:

SELECT
FROM
WHERE
ORDER BY
LIMIT

Under the hood, however, the database processes your instructions in a completely different order:

FROM: First, it locates the target table on disk.
WHERE: Next, it evaluates your filters and discards rows that do not match.
SELECT: Then, it extracts the requested columns from the remaining rows.
ORDER BY: It sorts those extracted values.
LIMIT: Finally, it trims the result set to the requested count.

Understanding this sequence prevents endless debugging headaches down the road, particularly when you begin using aliases and aggregate functions.

Common Mistakes Beginners Make

Mixing up single quotes and backticks: Use single quotes ('text') for literal string values. Backticks or double quotes are reserved in some dialects for table and column names that contain spaces or special characters.
Forgetting that NULL means unknown: Missing data in SQL is represented as NULL. Because NULL signifies the absence of a value, it cannot be equal or unequal to anything. Writing WHERE status = NULL will never return any rows. You must write WHERE status IS NULL or WHERE status IS NOT NULL.
Trailing commas in SELECT lists: Placing a comma after the final column in your SELECT clause (for example, SELECT id, name, FROM users;) is an immediate syntax error in nearly every SQL engine.
Treating case sensitivity carelessly: While SQL keywords (SELECT, FROM) are case-insensitive, text comparisons within single quotes often are case-sensitive depending on your database configuration. 'Nairobi' and 'nairobi' may not match.

Key Takeaways

SQL is a declarative language: you specify the data you want, not the step-by-step algorithms required to fetch it.
A standard read query follows a strict written template: SELECT columns FROM a table WHERE conditions apply.
The query execution engine reads FROM and WHERE before it ever looks at SELECT.
Always use IS NULL and IS NOT NULL when checking for empty fields rather than standard equality operators.
Request only the columns and rows you actually need to keep queries fast and clean.

Next Steps

Reading about syntax only gets you so far. The fastest way to build intuition for SQL is to sit down in front of a real dataset and start breaking things.

You do not need to install complicated database servers on your computer to begin. Web tools like SQLite Online or DB-Fiddle give you a sandboxed database directly in your browser. You can also check SQL Bolt for free interactive lessons. Load in a simple sample dataset, start asking basic questions using SELECT and WHERE, and see how the database responds. Once the core grammar clicks, you will have a durable, transferable skill that remains relevant across every corner of the software industry.

A practical, beginner-friendly guide to understanding Python's core data structures: lists, tuples, sets, and dictionaries.

Okall Omondi — Mon, 07 Sep 2026 14:04:50 +0000

When you write a program, you quickly run into a basic challenge: where do you put all your data?

Holding a single number or a single line of text in a variable is simple enough. But real software deals with collections such as customer records, shopping carts, daily temperatures, or user permissions. To manage those effectively, you need structured ways to organize information in memory.

In Python, four built-in tools handle almost all of this heavy lifting: lists, tuples, sets, and dictionaries. Each has distinct traits, rules, and strengths. Choosing the right one makes your code cleaner, faster, and much less prone to subtle bugs.

Let's look at how each one works, how they differ, and when to reach for them.

The Big Idea: Mutability and Order

Before looking at individual syntax, two terms will come up repeatedly: order and mutability.

Ordered means the collection remembers the sequence in which you added items. If an item is at index 0, it stays at index 0 until you explicitly move or remove it.
Mutable means you can change the collection after creating it. You can add items, remove items, or overwrite existing values without recreating the container from scratch. Immutable means the opposite: once defined, its contents are locked.

Keeping those two concepts in mind makes the differences between Python's core data structures immediately obvious.

1. Lists: The Versatile Workhorse

A list is an ordered, mutable collection of items. In Python, you define a list using square brackets [].

tasks = ["go to the gym", "reply to emails", "write report"]

Because lists are ordered, every element gets an index starting at zero. You can grab the first task with tasks[0] or append something new to the end using .append().

tasks.append("call plumber")
tasks[1] = "send invoices"  # overwriting an existing item

When to Use a List

Use a list when:

You care about the order of your items.
You expect the collection to grow, shrink, or change while your program runs.
You have duplicate entries (lists have no problem storing identical values multiple times).

2. Tuples: The Permanent Record

A tuple looks very similar to a list, but with one critical difference: it cannot be altered after creation. Tuples are defined using parentheses ().

screen_resolution = (1920, 1080)
gps_coordinates = (37.7749, -122.4194)

If you try to run gps_coordinates[0] = 40.7128, Python will stop you with a TypeError.

Why would you want a container that refuses to change?

First, safety. If a piece of data represents fixed configuration settings, database IDs, or coordinate pairs, making it a tuple ensures another function cannot accidentally modify it.

Second, performance and memory. Tuples take up slightly less memory and can be slightly faster to create than lists because Python knows their size will never change.

When to Use a Tuple

Use a tuple when:

Your data should remain constant throughout the program's lifecycle.
You need to group a fixed set of related values together, like (red, green, blue) color codes.
You need to use a sequence as a dictionary key (lists cannot be dictionary keys, but tuples can).

3. Sets: The Filter for Uniques

A set is an unordered collection of unique elements. You create a set using curly braces {} or the set() constructor.

tags = {"python", "programming", "backend"}

Sets behave like mathematical sets. They carry two defining characteristics:

No duplicates allowed. If you add "python" a second time, the set silently ignores it.
No reliable index. Because items aren't stored in a specific order, you cannot access items using index syntax like tags[0].

raw_user_ids = [101, 102, 101, 103, 104, 102]
unique_ids = set(raw_user_ids)
# unique_ids is now {101, 102, 103, 104}

Sets also shine when comparing groups of data using mathematical operations like unions, intersections, and differences:

frontend_devs = {"Alice", "Bob", "Charlie"}
backend_devs = {"Bob", "David", "Edward"}

# Find people who work on both
fullstack = frontend_devs.intersection(backend_devs)  # {"Bob"}

When to Use a Set

Use a set when:

You need to strip duplicates from existing data.
You frequently check whether an item exists in a large collection. Checking item in my_set runs in constant time ($O(1)$), whereas searching a list requires Python to scan items one by one ($O(n)$).

4. Dictionaries: Labeling Your Data

Lists, tuples, and sets hold individual values. A dictionary stores associations: key-value pairs.

Like sets, dictionaries use curly braces, but each entry consists of a key, a colon, and an associated value.

user_profile = {
    "username": "alex99",
    "email": "alex@example.com",
    "login_count": 14,
    "is_active": True
}

Instead of remembering that an email address was stored at index 1 in a list, you look it up directly by its label:

print(user_profile["email"])
user_profile["login_count"] += 1

Keys must be unique and immutable (strings, numbers, or tuples). Values can be anything you want, including other lists or nested dictionaries.

When to Use a Dictionary

Use a dictionary when:

You have structured records where every value has a distinct meaning or label.
You need fast lookups based on an identifier, such as matching a product ID to inventory details.

Quick Comparison

Structure	Syntax	Ordered?	Mutable?	Allows Duplicates?	Common Purpose
List	`[1, 2, 3]`	Yes	Yes	Yes	General collections that change
Tuple	`(1, 2, 3)`	Yes	No	Yes	Fixed, protected records
Set	`{1, 2, 3}`	No	Yes	No	Uniqueness and membership checks
Dictionary	`{"a": 1, "b": 2}`	Yes*	Yes	Keys: No / Values: Yes	Keyed lookups and structured objects

*Note: Starting in Python 3.7+, dictionaries officially maintain insertion order.

Common Beginner Mistakes to Avoid

1. Creating an Empty Set with `{}`

Writing {} does not create an empty set. Python defaults to creating an empty dictionary for historical reasons. To create an empty set, always call set() directly:

empty_dict = {}       # This is a dictionary
empty_set = set()     # This is a set

2. Modifying a List While Looping Over It

Removing items from a list while iterating over it often causes the loop to skip elements because the underlying indices shift underneath Python's iterator:

# Problematic:
numbers = [1, 2, 3, 4, 5]
for n in numbers:
    if n % 2 == 0:
        numbers.remove(n)  # Skips elements unexpectedly

If you need to filter a list, create a new one using a list comprehension instead:

# Clean and predictable:
numbers = [n for n in numbers if n % 2 != 0]

3. Missing the Single-Item Tuple Comma

To define a tuple with a single item, you must include a trailing comma. Without it, Python treats the parentheses as grouping syntax around a plain expression:

not_a_tuple = ("admin")   # Type: str
is_a_tuple = ("admin",)   # Type: tuple

Choosing with Confidence

Learning these data structures is less about memorizing syntax and more about recognizing the shape of your data.

Whenever you prepare to store a group of values, pause and ask yourself three questions:

Do these values have meaningful labels? If yes, reach for a dictionary.
Does the order matter, and will the values change? If yes, pick a list.
Do you need strict uniqueness, or do you need to protect fixed values from accidental modification? Pick a set or a tuple, respectively.

Get comfortable matching these tools to your problem, and writing clear, efficient Python becomes second nature.

Connecting Power BI to SQL Databases: Local SQL Server and Aiven PostgreSQL (SSL) Using DBeaver

Okall Omondi — Sun, 12 Jul 2026 08:55:35 +0000

If you're learning Power BI, one of the first practical skills you need is connecting it to a database. Most tutorials stop after showing a simple SQL Server connection, but real projects are rarely that simple. Sometimes the database is running on your own machine. Other times it lives in the cloud and requires SSL certificates before Power BI will even talk to it.

In this guide, I'll walk through both scenarios:

Connecting Power BI to a local SQL Server.
Connecting Power BI to an Aiven PostgreSQL database using SSL, with DBeaver helping us verify the connection first.

The goal is not just to make the connection work, but to understand why each step matters so you can troubleshoot issues later.

Before You Start

You should have:

Power BI Desktop installed.
PostreSQL Server installed locally.
DBeaver installed.

An Aiven PostgreSQL service powered on and running.

The SSL certificate file downloaded from Aiven, usually named ca.pem.

DBeaver is useful because it lets you confirm that the database itself is reachable before involving Power BI. If DBeaver cannot connect, Power BI almost certainly won't either.

Part 1: Connecting Power BI to a Local SQL Server

Let's start with the easier case.

Step 1: Find Your SQL Server Name

Open SQL Server Management Studio (SSMS) if you have it installed, or check the SQL Server services list.

Common server names look like:

localhost
localhost\SQLEXPRESS
DESKTOP-ABC123\SQLEXPRESS

If you're using SQL Server Express, the \SQLEXPRESS part is often required.

Step 2: Open Power BI

Launch Power BI Desktop.
Select Get Data → SQL Server.

Step 3: Enter Connection Details

Fill in:

Field	Example
Server	127.0.0.1:0000 (localhost IP Adress:port_number)
Database	postres in my case or leave blank to see all databases, or enter a specific database name.

Choose Import mode for beginners. It loads data into Power BI and is easier to work with than DirectQuery.

Click OK.

Step 4: Authenticate

Power BI will ask how to log in.

For a local development machine, Windows authentication is usually the simplest option because it uses your current Windows account.

If your SQL Server uses SQL logins instead, choose Database and enter the username and password.

Step 5: Select Tables

After connecting, Power BI shows the available tables and views.

Select the tables you need and click Load.

At this point, your local SQL Server is connected and ready for reporting.

Part 2: Verify Aiven PostgreSQL in DBeaver First

Cloud databases introduce one extra requirement: SSL encryption.

Aiven provides PostgreSQL over an encrypted connection, which means Power BI needs the same certificate information that DBeaver uses.

Step 1: Create the Connection in DBeaver

Open DBeaver.
Click New Database Connection.
Choose PostgreSQL.

Enter the connection details from your Aiven dashboard:

Field	Example
Host	pg-12345.aivencloud.com
Port	12345
Database	defaultdb
User	Your Aiven username
Password	Your Aiven password

Step 2: Configure SSL

From the Aiven dashboard, download the CA certificate

On your windows PC launch Microsoft Management Console by typing mmc in the search console, and add the certificate snap-in by clicking on File --> Add/Remove Snap-in.

Restart Power BI if you had it open to ensure the SSL certificate is loaded.

Part 3: Connect Power BI to Aiven PostgreSQL with SSL

Step 1: Install the PostgreSQL Connector if Needed

Recent versions of Power BI already include it. If Power BI prompts you to install the PostgreSQL driver, follow the prompt and restart Power BI.

Step 2: Start the Connection

Select Get Data → PostgreSQL database.

Enter the server as host:port from the aiven connection information section.

Example

pg-12345.aivencloud.com:12345

Enter the database name, such as defaultdb.

Step 3: Configure SSL in Power BI

When the authentication window appears:

Choose Database authentication.
Enter your Aiven username and password.
Expand Advanced options if available.
Set SSL Mode to verify-full.
Browse to the same ca.pem certificate used in DBeaver.

Click Connect.

Step 4: Load the Data

Power BI will display the PostgreSQL schemas and tables.

Select the tables you need and click Load.

The first connection may take a little longer because Power BI is validating the SSL certificate.

Why Use DBeaver Before Power BI?

Beginners often try to troubleshoot everything inside Power BI, which can be frustrating because the error messages are not always specific.

DBeaver gives clearer feedback:

If the host or port is wrong, DBeaver tells you immediately.
If the password is incorrect, you'll see an authentication error.
If the SSL certificate is missing or invalid, DBeaver points directly to the SSL problem.

Once DBeaver connects successfully, Power BI usually becomes a straightforward configuration task.

Common Mistakes Beginners Run Into

Using the wrong SQL Server instance name

localhost and localhost\SQLEXPRESS are not the same thing. If one fails, check which instance is actually running. If localhost is not working, use the localhost IP address 127.0.0.1

Forgetting the port number for PostgreSQL

Aiven does not always use the default PostgreSQL port 5432. Use the exact port shown in the Aiven dashboard.

Skipping SSL configuration

Aiven requires encrypted connections. If you omit the certificate or use the wrong SSL mode, Power BI will refuse the connection.

Mixing up authentication methods

Local SQL Server often uses Windows authentication, while Aiven PostgreSQL uses database username and password authentication. Choosing the wrong method leads to login failures even when the credentials are correct.

Key Takeaways

By the end of this setup, you should be able to connect Power BI to two very different database environments:

Local SQL Server using Windows or SQL authentication.
Aiven PostgreSQL using SSL certificates and database credentials.

The local SQL Server connection is mostly about identifying the correct server instance. The Aiven PostgreSQL connection is mostly about getting SSL configured correctly. DBeaver acts as a useful checkpoint before you bring Power BI into the picture.

Once both connections are working, the experience inside Power BI is surprisingly similar. You choose tables, load the data, and start building reports. The difficult part is usually the first successful connection. After that, adding new tables or refreshing data becomes much easier because the connection settings are already saved.

If you're practicing, I recommend testing the local SQL Server connection first, then moving to Aiven PostgreSQL. It builds confidence because you learn the Power BI workflow before dealing with SSL and cloud networking details.

Understanding Data Modeling, Schemas, Relationships, and Joins: A Beginner's Guide

Okall Omondi — Sat, 11 Jul 2026 03:33:53 +0000

When people first start learning SQL, they usually focus on writing queries. You learn SELECT, WHERE, GROUP BY, and maybe even a few aggregate functions. Everything seems manageable until you come across multiple tables. Suddenly, you're asking questions like:

Why is the customer information in a different table? How are these tables connected? And what exactly is a JOIN?

If you've been wondering the same thing, you're not alone.

Before you can write meaningful SQL queries, you need to understand how data is organized. That's where data modeling, schemas, relationships, and joins come in. These concepts work together, and once they click, databases become much easier to understand.

Let's go through them one step at a time.

What Is Data Modeling?

Think about building a house.

Before anyone starts laying bricks, an architect creates a blueprint. The blueprint shows where the rooms go, how they're connected, and where everything belongs.

Data modeling works the same way.

A data model is the blueprint of a database. It defines what information needs to be stored, how it should be organized, and how different pieces of information relate to one another.

Instead of rooms and doors, a data model deals with things like:

Customers
Products
Orders
Employees
Payments

Rather than storing everything in one giant table, the data model separates information into logical groups.

For example, imagine you're designing a database for an online store.

Instead of creating one huge table containing customer details, product information, payment records, and shipping addresses, you would divide the information into smaller tables.

You might have:

Customers
Products
Orders
Order Items
Payments

Each table has a clear purpose. This makes the database easier to maintain and reduces duplicate data.

What Is a Schema?

Once you've designed your data model, the next step is creating the actual structure inside the database.

This structure is called a schema.

A schema describes how the database is organized. It contains the tables, columns, data types, constraints, and relationships.

Think of it as the database's floor plan.

For example, a Customers table might look like this:

CustomerID	Name	Email	Phone
101	Jane Doe	[jane@email.com]	555-1234

The schema defines that:

CustomerID is an integer.
Name is text.
Email stores email addresses.
Phone stores phone numbers.

It also specifies rules, such as requiring every customer to have a unique CustomerID.

Without a schema, a database would have no structure. It would simply be a collection of unorganized data.

Understanding Primary Keys

If every customer has a name, why can't we just use names to identify them?

Because names aren't always unique.

You might have two customers named John Kamau. Which one are you referring to?

This is why databases use primary keys.

A primary key is a column whose value uniquely identifies every row in a table.

For example:

CustomerID	Name
101	John Kamau
102	John Kamau

The names are identical, but the CustomerIDs are different.

This guarantees that every customer can always be identified correctly.

A good primary key should:

Never be empty
Never contain duplicate values
Stay stable over time

Almost every table in a relational database has one.

Understanding Relationships Between Tables

Databases become powerful because tables don't exist in isolation.

They're connected through relationships.

A relationship tells the database how information in one table is connected to information in another.

Imagine these two tables.

Customers

CustomerID	Name
101	Musyoka
102	Kiilu

Orders

OrderID	CustomerID	Total
5001	101	75
5002	101	120
5003	102	45

Notice something?

The Orders table contains CustomerID.

That's not a coincidence.

It links every order to the customer who placed it.

CustomerID inside the Orders table is called a foreign key.

A foreign key points to the primary key in another table.

This is how databases connect information without storing the same customer details repeatedly.

Types of Relationships

Most beginner databases use three types of relationships.

One-to-One

One record matches exactly one record.

For example:

One employee has one company ID card.

These relationships are less common.

One-to-Many

This is by far the most common relationship.

For example:

One customer places many orders.
One teacher teaches many students.
One department has many employees.

Notice that one side has a single record, while the other side can have many.

Many-to-Many

Sometimes both sides can have multiple records.

For example:

Students enroll in many courses.
Courses contain many students.

Databases usually solve this by introducing a third table called a junction table.

For example:

Students
Courses
StudentCourses

The StudentCourses table stores which student is enrolled in which course.

What Are Joins?

Now comes the question most beginners ask.

If customer information is stored in one table and order information is stored in another, how do we view them together?

The answer is JOINs.

A JOIN combines rows from two or more tables based on a related column.

Let's use the earlier example.

Customers

CustomerID	Name
101	Musyoka
102	Kiilu

Orders

OrderID	CustomerID	Total
5001	101	75

If you write a JOIN, the result becomes:

OrderID	Name	Total
5001	Musyoka	75

The database matches CustomerID in both tables and combines the related information.

This is why relationships are so important. Without them, JOINs wouldn't know how the tables are connected.

Common Types of SQL Joins

You'll encounter several types of joins as you learn SQL.

INNER JOIN

Returns only matching records.

If a customer has no orders, they won't appear in the results.

This is the join you'll probably use most often.

LEFT JOIN

Returns every record from the left table, even if there's no matching record in the right table.

This is useful when you want to find customers who haven't placed any orders yet.

RIGHT JOIN

Works like a LEFT JOIN but starts from the right table instead.

Many SQL developers rarely use it because a LEFT JOIN can usually achieve the same result by switching the table order.

FULL OUTER JOIN

Returns all records from both tables, matching where possible.

If there's no match, the missing values are shown as NULL.

Not every database system supports this join directly.

How These Concepts Fit Together

It's easy to see these as separate topics, but they're really parts of the same picture.

Here's the flow:

You create a data model to plan your database.
You implement that design using a schema.
Tables are connected through relationships using primary and foreign keys.
SQL JOINs use those relationships to retrieve data from multiple tables.

Once you understand this sequence, writing SQL queries starts to make much more sense.

Common Beginner Mistakes

Everyone makes mistakes while learning databases. Here are a few that come up often.

Putting everything into one table

It may seem simpler at first, but it quickly leads to duplicated data and maintenance headaches.

Ignoring primary keys

Without unique identifiers, it's difficult to connect tables correctly or guarantee data accuracy.

Joining on the wrong columns

Always check that you're joining a foreign key to its corresponding primary key. Joining unrelated columns can produce incorrect or misleading results.

Memorizing joins without understanding relationships

Many beginners try to memorize SQL syntax first. It's usually more effective to understand how the tables relate to one another. Once the relationships are clear, choosing the correct join becomes much easier.

Practical Tips for Learning

If you're just getting started, don't rush into complex database designs.

Instead:

Draw your tables on paper before creating them.
Label the primary and foreign keys.
Practice identifying one-to-one, one-to-many, and many-to-many relationships.
Build small databases, such as a library, school, or online store.
Write simple JOIN queries and predict the results before running them.

This approach helps you understand the logic behind the database rather than simply memorizing SQL syntax.

Key Takeaways

A data model is the blueprint that plans how data should be organized.
A schema defines the structure of the database, including tables and columns.
A primary key uniquely identifies each record in a table.
A foreign key connects one table to another.
Relationships describe how tables are linked.
JOINs combine data from related tables to answer real-world questions.

Final Thoughts

Data modeling, schemas, relationships, and joins can seem like separate topics when you're first learning databases. In reality, they're different pieces of the same foundation.

Once you understand how data is organized and why tables are connected the way they are, SQL becomes far less intimidating. Queries stop feeling like random commands and start feeling like conversations with the database.

If you're learning SQL, spend time understanding the structure before chasing more advanced syntax. A solid grasp of these fundamentals will make every future topic—from writing reports to designing databases—much easier to learn.

How Excel is Used in Real-World Data Analysis

Okall Omondi — Sat, 06 Jun 2026 06:35:07 +0000

What is Excel?

Well, the simplest answer? Excel is a tool.
You might ask, which tool?
Think of it as a bookshelf, or the wardrobe in your house.
What does the bookshelf and the wardrobe have in common? Partitions.
Most bookshelves have identifiers to help you locate the exact partition where the book is stored. The last library I visited had letters and numbers. The letters were written horizontally (from left to right) across the bookshelf and the numbers were written vertically (from top to bottom). I could easily identify the exact partition by using the letter and number combination, for example the first partition in the bookshelf was A1. This is the exact way Excel is organized with letters and numbers.

The partition A1 in the bookshelf represents a cell in Excel. The horizontal letters (from left to right) of the bookshelf represent a row in an Excel, and the vertical numbers from top to bottom in a bookshelf represent a column in an Excel. A single bookshelf represents a worksheet in Excel and several bookshelves represent a workbook in Excel. Simple right?

How Excel is used in real world Data Analysis.

You have probably heard of the phrase “data is the new oil” right? What makes it the new oil? Apart from it being the new “money printer”, data is the “know it all”, it is the real story teller. However, before data can tell you stories and turn into your cash machine, you must first make sense of it, to understand what happened and why it happened. The process of understanding what happened and why it happened is called Data Analysis. By understanding what happened and why it happened, you can easily figure out what will happen (Data Science). Excel is fundamental in the understanding phase, and in the figuring out phase, because it acts as the story for the data to be understood and figured out.

Which areas do we then use Excel in the real world? Imagine this scenario, you are running a small refurbished laptops resale shop, every laptop you sell with a small profit on top of the purchase price, and making profits in your head. However, at the end of the month you find out you are short of cash to pay bills forcing you to borrow money from friends, yet, you did not sell any laptop at a loss. What do you do? This is where Excel comes in. Excel can help you to store your sales data, organize the data and clean the data. Excel also gives you formulas such as SUM, AVERAGE, MIN, MAX, COUNT and functions such as IF, SUMIF, AVERAGEIFS, VLOOKUP which you can use to do calculations and create logics to see how your business is doing. Excel also has pivot table functionality which is helpful in summarizing data quickly. You can also draw insights from the data using the various visualization tools in Excel such as charts and graphs to help you see where you are losing money and make informed decisions.

How has learning Excel changed how I see data?

Learning Excel and understanding its capabilities has been an eye opener, and I now view every instance of my life as a data point to be tracked and understood. This past week I have started tracking simple things in my life like the time I go to bed, the time I wake up, how long I take on a task, and so much more. I will be using this data to improve and be a better person.

Diving into Bug Bounty Hunting: My Journey Begins with Resources and Tips for Beginners

Okall Omondi — Mon, 20 Jan 2025 07:31:54 +0000

After taking the much needed break and rest in the festive seasons, a period in which I had much reflection on my career and life goals, I dove into cybersecurity with a focus on bug bounty hunting. I have been contemplating on this for a while, ever since I came across the 0 to 100K in Bug Bounty Year One thread on X by @Rhynorater. I used ChatGPT to create a bug bounty hunting road map and begun on a resource finding mission. I will write weekly posts documenting my journey and milestones into becoming a bug bounty hunter. This first article will document some of the useful resources that those aspiring to become bounty hunters can use. The resources range from ChatGPT, YouTube Channels, websites, GitHub Accounts, X Accounts, and SubReddits.

Remember

When starting out, always be aware of the shiny object syndrome and analysis paralysis. Shiny object syndrome (SOS) is the tendency to be distracted by new ideas (courses) that are often at the expense of your current goal, which is becoming a bug bounty hunter in this case. Analysis paralysis is that point when you cannot decide because you are overwhelmed with courses/ materials and you are not sure of which one to use.

Another thing I will recommend while starting is developing a good note taking system. There are various Note Taking Apps you can use, such as Notion, Evernote, Microsoft OneNote, Joplin, Obsidian and many others. When choosing a note app, there are factors you have to put into consideration. Some features I look for in a note taking app are cost, ease of use, organizational features, and cross device access. My choice is Obsidian. Having a good note taking system is like having a second brain. Good notes always come in handy along your career trajectory, and they are what will catapult you to the next level.

Resources

Now, back to resources. I will focus on the free resources here, as I believe most of the required knowledge is free if you have the patience and time to go after it.

ChatGPT: The first and key resource I found helpful is ChatGPT. You are not restricted to this. You can use GPTs of your choice like copilot, Gemini or any other you may prefer. I used ChatGPT to brainstorm and be sure that I really wanted to go into bug bounty hunting. After being sure I wanted this, I prompted it to come up with a learning path and a study plan for bug bounty hunting. There are unlimited ways you can use GPTs from generating explanations, examples and analogies, motivation, role-plays, questions, mind maps, mental associations and much more. You can also use them to engineer effective prompts which you can then re-use to get exact answers you want.
YouTube Channels: Some of the YouTube channels I have found to be amazing are:
NahamSec - Has detailed bug bounty tutorials and live hacking sessions.
STÖK - Offers practical bug hunting techniques and methodologies.
InsiderPhD - Insider PHD is great for beginners, provides structured learning content. This is the channel I have been using, mostly. I highly recommend it if you are starting out.
Jason Haddix - Industry veteran sharing advanced techniques and methodologies
TCM Security - Comprehensive ethical hacking and penetration testing tutorials
HackerSploit - Detailed tutorials on various security tools and techniques
LiveOverflow - In-depth technical content about security research and exploitation
PortSwigger - Official channel for Burp Suite with web security tutorials
Learning Websites:
PortSwigger Web Security Academy - Free, comprehensive web security training. I recommend PortSwigger Academy if you are starting out.
Bugcrowd University - Free educational resources for bug bounty hunters. Bugcrowd also provides a platform for the Vulnerability Disclosure Program (VDP) and Bug Bounty Programs (BBP). It is a good place to start your bug bounty hunting by creating an account on their platform.
TryHackMe - Interactive cybersecurity training platform with guided learning paths. Try Hack Me is fully free, but it has some amazing labs that provide hands-on experience.
HackTheBox - Platform offering realistic penetration testing labs and challenges
HackerOne Hacktivity - Public bug reports to learn from real-world examples. HackerOne also provides a platform for the Vulnerability Disclosure Program (VDP) and Bug Bounty Programs (BBP).
PentesterLab - Hands-on exercises for web penetration testing
VulnHub - Provides materials to gain practical cybersecurity experience
OWASP - Comprehensive resource for web application security knowledge
GitHub Accounts:
BugBounty: This GitHub account has most of the resources you need in becoming a bounty hunter.
X Accounts: There is an amazing Bug Bounty Community on X with lots of accounts dedicated to sharing information on Bug Bounty Hunting. I will not recommend any account in particular but if you are on X, search for a bug bounty and you’ll find lots of accounts with posts that will inspire you.
SubReddits: Reddit is another Social Media platform I like. There is an amazing community here with amazing people who are always ready to jump in and assist with any query you might be having. Just be sure to search first if the question was asked and answered before. Also, be sure to ask on the right subreddit. The subreddit for bug bounty hunters which is active, and I’d recommend you join is r/bugbounty/.

DEV Community: Okall Omondi

How Python Loops Actually Work: A Hands-On Guide with Real Projects

The Two Core Loops in Python

1. The for Loop: Definite Iteration

2. The while Loop: Indefinite Iteration

Steering Loop Execution: break and continue

Project 1: User Validation Using a while Loop and break

Why this works

Project 2: Data Filtering Using a for Loop and continue

Why continue is useful here

Project 3: Clean Tracking with enumerate()

Output:

Common Mistakes to Watch For

Summary Checklist

How Python Operators and Conditionals Actually Work (With Real Project Code)

What Are Operators?

1. Arithmetic Operators

2. Comparison Operators

3. Logical Operators

Directing Traffic with Conditionals

How I Used Them in a Project: The Contact Book

1. Truthiness and the not Operator

2. The in Membership Operator

3. Cleaning and Validating Inputs

Three Common Mistakes to Avoid

Forgetting that input() Returns a String

Accidental Assignment

Over-Nesting Conditionals

Practical Takeaways

Python Basics: Where It All Starts

Why Python Syntax Feels Different

Indentation Matters!

Storing Data: Variables and Dynamic Typing

Naming Conventions

Core Data Types You Will Use Daily

1. Integers (int)

2. Floating-Point Numbers (float)

3. Strings (str)

4. Booleans (bool)

Taking Input and Displaying Output

The Input Type Trap

Formatting Strings with f-Strings

A Working Example: Tip Calculator

Three Mistakes to Watch Out For

Key Takeaways

My Take

Python will Save You Time. Here is Why and How.

Code That Actually Looks Like English

The Mental Shift: From Mechanics to Problem-Solving

Why Python Owns Data Science

1. The Modular Ecosystem

2. Fast Development Over Fast Execution

Common Traps to Watch Out For

The Direct Route Forward

My Take

Learning SQL? Here is a Practical Guide to Read and Write SQL Queries.

Introduction

What SQL Actually Is

How Data Is Organized

Anatomy of a SQL Query

Filtering Data with the WHERE Clause

Combining Conditions

Sorting and Limiting Results

Ordering Rows

Restricting the Row Count

The Hidden Rule: Written Order vs. Execution Order

Common Mistakes Beginners Make

Key Takeaways

Next Steps

A practical, beginner-friendly guide to understanding Python's core data structures: lists, tuples, sets, and dictionaries.

The Big Idea: Mutability and Order

1. Lists: The Versatile Workhorse

When to Use a List

2. Tuples: The Permanent Record

When to Use a Tuple

3. Sets: The Filter for Uniques

When to Use a Set

4. Dictionaries: Labeling Your Data

When to Use a Dictionary

Quick Comparison

1. The `for` Loop: Definite Iteration

2. The `while` Loop: Indefinite Iteration

Steering Loop Execution: `break` and `continue`

Project 1: User Validation Using a `while` Loop and `break`

Project 2: Data Filtering Using a `for` Loop and `continue`

Why `continue` is useful here

Project 3: Clean Tracking with `enumerate()`

1. Truthiness and the `not` Operator

2. The `in` Membership Operator

Forgetting that `input()` Returns a String

1. Integers (`int`)

2. Floating-Point Numbers (`float`)

3. Strings (`str`)

4. Booleans (`bool`)

1. Creating an Empty Set with `{}`