Time Complexity 101: O(1), O(n), O(n )

Utku Catal — Tue, 12 May 2026 18:09:50 +0000

Modern algorithms can be complex. Big O Notation helps developers measure performance by analyzing how runtime grows with input size. Understanding O(1), O(n), and O(n²) is essential for writing efficient code.

Big O describes the worst-case scenario. It captures how an algorithm scales as n (input size) increases.

O(1): Constant Time

Accessing an array element by index. Always 1 operation regardless of size.

package main
import "fmt"

func getFirst(arr []int) int {
    return arr[0] // Always O(1)
}

func main() {
    arr := []int{10, 20, 30, 40}
    fmt.Println(getFirst(arr)) // Output: 10
}

O(n): Linear Time

Scanning an entire array. Operations grow proportionally with n.

func findMax(arr []int) int {
    max := arr[0]
    for i := 1; i < len(arr); i++ { // n iterations
        if arr[i] > max {
            max = arr[i]
        }
    }
    return max
}

O(n²): Quadratic Time

Nested loops. Disastrous for large n (n=1000 → 1M operations).

func bubbleSort(arr []int) []int {
    n := len(arr)
    for i := 0; i < n-1; i++ {
        for j := 0; j < n-i-1; j++ { // n*n iterations
            if arr[j] > arr[j+1] {
                arr[j], arr[j+1] = arr[j+1], arr[j]
            }
        }
    }
    return arr
}

Why It Matters

O(n²) works for n=100 but crashes at n=10,000. Choosing the right complexity class is the difference between a feature that scales and one that times out under load.

O(1): instant, regardless of input
O(n): predictable, scales linearly
O(n²): fine for small inputs, deadly at scale

Conclusion

Time complexity is the language engineers use to reason about performance before writing a single benchmark. Master O(1), O(n), and O(n²) first. They show up in nearly every algorithm you'll touch.

Next up: O(log n) and O(n log n), the complexities that power search and sort.

What is Object-Oriented Programming (OOP)?

Utku Catal — Mon, 11 May 2026 21:09:33 +0000

Modern software systems can be complex. Object-Oriented Programming (OOP) is one of the most widely used programming paradigms that helps developers manage this complexity by modeling real-world entities as objects. These objects combine data and behavior, making complex systems easier to design and maintain.

OOP is built around several core concepts such as class, inheritance, encapsulation, and polymorphism. These concepts help developers to write code that is more modular, reusable, and maintainable.

Let’s take a quick look at what they mean:

Class: A class is a blueprint for creating objects. It defines the properties (attributes) and behaviors (methods) that the objects created from it will have.

For example, consider a class called Computer. There may be many computers with different brands, types, and models, but all of them share the same properties: motherboard, CPU, GPU, and PSU. Here, Computer is the class, and motherboard, CPU, GPU, and PSU are attributes of the class.

Usage:

// Class definition
class Computer {
    public $motherboard;
    public $cpu;
    public $gpu;
    public $psu;

    // Constructor to initialize properties
    public function __construct($motherboard, $cpu, $gpu, $psu) {
        $this->motherboard = $motherboard;
        $this->cpu = $cpu;
        $this->gpu = $gpu;
        $this->psu = $psu;
    }

    // Method to display computer specs
    public function showSpecs() {
        echo "Motherboard: " . $this->motherboard . "\n";
        echo "CPU: " . $this->cpu . "\n";
        echo "GPU: " . $this->gpu . "\n";
        echo "PSU: " . $this->psu . "\n";
    }
}

// Creating an instance (object) of Computer
$myPC = new Computer("ASUS ROG", "Intel i7", "NVIDIA RTX 4070", "Corsair 750W");

// Using the object
$myPC->showSpecs();

Inheritance: Inheritance allows a class to acquire the properties and methods of another class. This promotes code reuse and helps establish a hierarchical relationship between classes.

For example, you might have a base class called Device and a derived class called Computer. The Computer class can inherit common properties such as powerStatus or brand from Device, while also defining its own specific attributes like GPU or CPU.

Encapsulation: Encapsulation is the practice of restricting direct access to an object’s internal data and instead exposing it through controlled methods. This helps protect the integrity of the data and prevents unintended interference.

In many programming languages, this is achieved using access modifiers such as private, protected, and public. For instance, instead of directly modifying a Computer’s CPU property, you might use a setter method to ensure only valid values are assigned.

Polymorphism: Polymorphism allows objects of different classes to be treated as objects of a common superclass. It enables a single interface to represent different underlying forms (data types).

For example, multiple classes like Desktop and Laptop can implement a method called getPowerUsage(), but each class can provide its own implementation. The same method name behaves differently depending on the object that calls it.

Simple Example:

class Device {
    public function start() {
        echo "Device is starting...\n";
    }
}

class Computer extends Device {
    public function start() {
        echo "Computer is booting up...\n";
    }
}

class Laptop extends Device {
    public function start() {
        echo "Laptop is powering on...\n";
    }
}

// Polymorphism in action
$devices = [new Computer(), new Laptop()];

foreach ($devices as $device) {
    $device->start();
}

Explanation: In this example, both Computer and Laptop override the start() method from the Device class. Even though they share the same method name, each class provides its own behavior. This is a simple demonstration of polymorphism.

Why It Matters

OOP provides a structured approach to software development. By organizing code into objects, developers can better manage complexity, especially in large-scale applications.

It improves code reusability through inheritance.
It enhances security and data integrity via encapsulation.
It allows flexibility and scalability with polymorphism.
It makes code easier to maintain, test, and extend.

In real-world projects, these benefits translate into faster development cycles, fewer bugs, and cleaner architecture.

Conclusion

Object Oriented Programming is a powerful paradigm that helps developers model complex systems in a clear and organized way. By understanding and applying its core principles: class, inheritance, encapsulation, and polymorphism, you can write code that is not only functional but also scalable and maintainable.

As software systems continue to grow in size and complexity, mastering OOP becomes an essential skill for any modern developer.

*paradigm: A paradigm is a standard, perspective, model, or set of ideas that acts as a pattern for how something is viewed, made, or understood

DEV Community: Utku Catal