DEV Community: Leandros Georgiou

Big-O explained simply

Leandros Georgiou — Tue, 22 Sep 2026 14:07:18 +0000

When I first heard about Big-O it sounded intimidating, but it turned out to be a simple idea once I saw a few examples. Here's how it finally clicked for me.

What does Big-O measure?

Big-O is used to describe the efficiency of a program, specifically, how the amount of work grows as the input gets bigger. Let's look at an example:

def first(items: list[Any]) -> Any:
    return items[0]

This function takes a list of any type and returns the first item. Whether the list has 1 item, 10 items, or 1,000,000 items, there's only ever one step - just grabbing the first item. That's O(1) - constant time. The work doesn't grow at all, even as the list grows.

Let's look at another example:

def count(items: list[Any]) -> int:
    total = 0
    for i in items:
        total += 1
    return total

This function takes in a list and returns the number of items in it, by going through every item (with the for loop) and adding 1 to the total for each one. So if there's 1 item, the loop runs once. If there are 10 items, it runs 10 times. If there are 1,000,000 items, it runs 1,000,000 times. As the list grows, the number of steps grows with it. The function's efficiency is directly dependent on the size of the list (n), so its Big-O is O(n) - linear time.

Now a cleverer one. Suppose we have a phonebook sorted in alphabetical order and we want to find a particular name. One method: go to the middle page. If it's not the right name, throw away half the pages and look at the other half. Then look in the middle of the new half and do the same. Keep repeating until you find the name.

At each step we throw away half of what's left to search. So a phonebook with 8 names takes 3 steps to find the name, a phonebook with 1024 names takes only 10 steps. This "halving" pattern is called O(log n) - log base 2 of n. It's incredibly efficient: even a phonebook with a billion names would take only about 30 steps.

So to summarise the three so far:

O(1) - the work never grows (grab the first item).
O(n) - the work grows in step with the input (look at every item).
O(log n) - the work grows very slowly, because each step halves what's left (the phonebook search).

Searching a list vs a set

This is where Big-O stops being theory and starts mattering in real code. Let's compare two versions of the same function.

The list

def has_duplicates_v1(items: list[Any]) -> bool:
    already_seen: list[Any] = []
    for i in items:
        if i not in already_seen:
            already_seen.append(i)
        else:
            return True
    return False

This function takes a list and asks whether it has any duplicates. It goes through each item and asks "is this item in the already_seen list?" If not, it adds it, to note we've seen it. If it is already there, we return True - a duplicate exists. If we get through the whole list without ever returning True, we return False, because there are no duplicates.

Here's the catch. When the function asks if i not in already_seen, it has to go through the entire already_seen list from start to finish, checking each item against i. That check alone is O(n). And it happens inside a for loop that itself goes through every item in the list - another O(n). So for every item in the list, we scan the whole already_seen list. That's n × n, which gives us O(n²).

The set

Now the same function with one change:

def has_duplicates_v2(items: list[Any]) -> bool:
    already_seen: set[Any] = set()
    for i in items:
        if i not in already_seen:
            already_seen.add(i)
        else:
            return True
    return False

The only difference is that already_seen is now a set instead of a list. The powerful thing about a set is that checking whether something is in it has constant lookup time - O(1). It doesn't scan from start to finish, it instantly checks whether the item is there. So now we have O(n) for the for loop, times O(1) for the set check, which gives us O(n).

I actually timed both versions on a list of 20,000 items: the list version took about 1.1 seconds, and the set version took about 0.001 seconds - over a thousand times faster. Same logic, one word changed.

So the takeaway: whenever you need to check if an item is present, reach for a set, not a list. It's one of the simplest changes you can make, and the difference is enormous as your data grows.

I built a task tracker as my first real Python project

Leandros Georgiou — Sat, 19 Sep 2026 16:13:44 +0000

I built a task tracker, which is a simple to-do list app that runs in the terminal. The task-tracker keeps a list of things you need to do, and marks whether each one has been completed. The tasks are stored in a JSON file, so they're saved between runs - you can close the program and pick up where you left off.

To do this, I created a class called TaskList. When you create a TaskList object, it automatically creates an empty dictionary and a new JSON file to store it in, if the program has never been run before. Otherwise, it loads the dictionary from the existing JSON file and assigns it to the dictionary within the class:

class TaskList:
    def __init__(self) -> None:
        self.dictionary: dict[str, list[str]] = {}
        if Path("to_do_list.json").exists():
            with open("to_do_list.json") as f:
                self.dictionary = json.load(f)
        else:
            with open("to_do_list.json", "w") as f:
                json.dump(self.dictionary, f)

The TaskList lets you add tasks to the dictionary by creating a key with the name of the task and giving it a value of an empty list. The empty list simply means the task hasn't been completed yet:

def addTask(self, task: str) -> None:
    self.dictionary[task] = []
    with open("to_do_list.json", "w") as f:
        json.dump(self.dictionary, f)

You can also delete tasks. I used try/except to handle the error that happens if the task doesn't exist:

def deleteTask(self, task: str) -> None:
    try:
        del self.dictionary[task]
        with open("to_do_list.json", "w") as f:
            json.dump(self.dictionary, f)
    except KeyError:
        print(f"Task {task} does not exist in the to-do list.")

You can mark tasks as completed too. This checks if the task is a key in the dictionary, and if it is, it sets its value to ["X"] so we can clearly see it's been done:

def completeTask(self, task: str) -> None:
    if task in self.dictionary:
        self.dictionary[task] = ["X"]
        with open("to_do_list.json", "w") as f:
            json.dump(self.dictionary, f)

Finally, we can see the list using the show method. This prints each key with its value next to it, line by line, so the user can clearly see what's in the task list:

def show(self) -> None:
    for key in self.dictionary:
        print(f"{self.dictionary[key]} : {key}")

For the program to work, I wanted it to keep asking the user what they'd like to do, and after every action to ask again, with the option to quit and stop the program. I used a while loop for this, and it also handles the input checking:

while True:
    option_str = input(
        "To see your current list, type 1\n"
        "To add a task to your list, type 2\n"
        "To delete a task from your list, type 3\n"
        "To mark a task as completed, type 4\n"
        "To quit, type 5\n"
        "Type answer here: "
    )

    option_int = to_int(option_str)

    if not is_valid_option(option_int):
        continue

Once the user gives an answer, I wanted to make sure they actually typed a number (not something like "one" instead of 1), and that the number was between 1 and 5. To do that, I used two small functions - one to convert the answer into an integer, and one to check whether the number is valid.

The to_int function uses try/except. It tries to return the answer as an integer, but if that fails (because the user typed something that isn't a number), it prints "Not an int" and returns -1 to signal that the input was invalid:

def to_int(answer: Any) -> int:
    try:
        return int(answer)
    except ValueError:
        print("Not an int\n\n")
        return -1

The is_valid_option function then checks whether the number is between 1 and 5:

def is_valid_option(option: int) -> bool:
    return 1 <= option <= 5

So the flow is: first we try to convert the input to an int. If it works, we've got a real number, if not, to_int gives us -1. Then we pass that through is_valid_option to check it's between 1 and 5. Since -1 is outside that range, a non-number automatically counts as invalid. If the option is valid, we carry on, if not, I use continue to loop back and ask again.

If the user picks option 1 (see the current list), I just run the show method. (I created a variable called task_list of type TaskList just above the while loop. The empty print() calls are only there to add spacing so it's easier to read in the terminal.)

if option_int == 1:
    print()
    task_list.show()
    print()

Each option links to the matching method. For example, to complete a task, we run completeTask:

elif option_int == 4:
    print()
    task: str = input("What task would you like to complete: ")
    print()
    task_list.completeTask(task)
    print()
    task_list.show()
    print()

And if the user picks option 5, I use break to stop the while loop, which ends the program:

elif option_int == 5:
    break

What I found difficult

The hardest part was getting the menu to keep working properly. If someone typed a letter instead of a number, my early versions would either crash or quietly do nothing. My first attempt used two separate loops and got into a real mess - bad input would slip through and the menu would behave strangely. What fixed it was rethinking it as a single loop that reads the choice, checks it's a valid number, and only then acts on it. Once it was one clean loop, all the weird behaviour went away.

What I would do differently

Right now, each task is stored as a key in a dictionary, with its "done or not" status as the value. That works, but I've since learned it might be cleaner to make a separate Task class that holds a task's description and whether it's done, and have TaskList hold a list of those Task objects. For a small app like this it isn't really necessary, but if I wanted to add more information to each task later, like a due date or a priority, giving a task its own class would make that much easier.

Coming from Java: functions are values in Python

Leandros Georgiou — Mon, 14 Sep 2026 17:32:40 +0000

I have recently started to learn python, and coming from Java there are a few interesting things I have found about functions.

The first thing that stuck out to me is that in Python, functions are values. What I mean by that, is a function is a thing that you can store, just like you can store a number or a string. For example, let's look at this simple function below which squares a number:

def square(item: int) -> int:
    return item * item

This simple function can be assigned to a new variable (an alias):

square_2 = square

Therefore, if we wanted to square a number we could either use square_2 or square as they both do the same thing.

You can even pass a function into another function like this:

print(apply_to_each(square, nums))

So when a function doesn't have parentheses after it, it can be passed around and stored as a value. But, if we have a parentheses after, it runs the function instead. Therefore, if we wrote square_2 = square(), that would run the function square() and store the result, not the function itself.

In Java, if I wanted to pass some behaviour into another method like this, I'd usually have to wrap it up in an object first (a class that mimics function behaviour). In python, I can just pass the function straight in, which feels a lot simpler.

Here is the full example of passing a function into another function:

from typing import Callable

nums = [1, 2, 3, 4, 5, 6, 7]

def apply_to_each(fn: Callable, items: list[int]) -> list[int]:
    new = []
    for i in items:
        new.append(fn(i))
    return new

def square(item: int) -> int:
    return item * item

print(apply_to_each(square, nums)) # [1, 4, 9, 16, 25, 36, 49]
print(apply_to_each(lambda x: x-5, nums)) # [-4, -3, -2, -1, 0, 1, 2]
print(apply_to_each(str, nums)) # ['1', '2', '3', '4', '5', '6', '7']

This is really useful because it allows us to write one general function (apply_to_each) that changes what it does based on the function we pass in. So we don't need to write a new loop every time we might want to do something different to a list.

Another thing I learnt about functions is that when we have a particularly small function, we don't even need to name it. We can use something called a lambda. Here is an example:

lambda x : x * 2

Let's break it down. Lambda here just means I am creating a simple function. Everything before the colon (the x) is the input, and everything after the colon (the x * 2) is what gets given back. So if x = 2, then lambda x : x * 2 gives us 4.

Coming from Java, treating functions as values felt strange at first, but it makes a lot of code shorter and simpler.

Linear algebra explained simply: how to calculate the dot product

Leandros Georgiou — Sun, 13 Sep 2026 15:29:57 +0000

The dot product works by taking two vectors of the same dimension and returning a single value.

For example,
Let's say we want to find the dot product of vectors [1, 2, 3] and [4, 5, 6]:

Step 1 - Multiply the numbers in matching positions:

1 * 4 = 4
2 * 5 = 10
3 * 6 = 18

Step 2 - Add up the results

4 + 10 + 18 = 32

Therefore [1, 2, 3]⸳[4, 5, 6] = 32

Let's look at another example. Let's say we wanted to find the dot product of vectors [8, 7] and [5, 2]:

Step 1 - Multiply the numbers in matching positions:

8 * 5 = 40
7 * 2 = 14

Step 2 - Add up the results

40 + 14 = 54

Therefore [8, 7]⸳[5, 2] = 54