But you end up looking something like this… 😭⬇️⬇️

Here’s the truth: slow code doesn’t have to be the end of the world. And it’s a rite of passage if you’re a developer.

When you’re learning to code, you’re focused on making things work—not making them fast. But eventually, you’ll hit a wall: your app freezes, your data script takes hours, or your game lags like a PowerPoint slideshow.

The difference between working code and blazing-fast code often comes down to avoiding a few common mistakes. Mistakes that are easy to make when you’re starting out, like using the wrong tool for the job, writing unnecessary code, or accidentally torturing your computer with hidden inefficiencies.

I’ve been there. I once wrote a “quick” script to analyze data. It ran for 3 hours. Turns out, changing one line of code cut it to 10 seconds. Yes I was dumb when I was learning – but I don’t want you to be, too.

That’s the power of understanding performance.

In this guide, I’ll break down seven common mistakes that can really tank your code’s speed—and how to fix them.

Table of Contents

1. Mistake #1: Logging Everything in Production (Without Realizing It)

   • How to Fix It

2. Mistake #2: Using the Wrong Loops (When There’s a Faster Alternative)

   • Why This is a Problem

3. Mistake #3: Writing Database Queries Inside Loops (Killer of Speed)

   • Why This is a Problem

   • How to Fix It: Use Bulk Queries

   • A More Scalable Approach

4. Mistake #4: Not Knowing Your Hardware’s Dirty Secrets

   • Problem 1: The CPU’s Crystal Ball is Broken (Memory Prefetching)

   • The Fix: Use Contiguous Data Structures

   • Problem 2: The Invisible Tax of Memory Pages (TLB Thrashing)

   • The Fix: Process Data in Chunks

   • Problem 3: Your Code is a Tourist in the Wrong CPU Neighborhood (NUMA)

   • The Fix: Pin Processes to NUMA-Aware Memory

   • Problem 4: The CPU is a Drama Queen (Speculative Execution)

   • The Fix: Make Branches Predictable

   • How to Fight Back

5. Mistake #5: Memory Fragmentation

   • What’s Happening Under the Hood

   • Problem 2: The Autoboxing Trap (Java, C#, and so on)

   • The Fix: Use Primitive Collections

   • The Fix for C#

6. Mistake #6: The Cache (catch)

   • Row-Major vs. Column-Major Access

   • The Plot Twist: Your Programming Language is Gaslighting You

   • The Multidimensional Illusion: 3D+ Arrays

   • The Nuclear Option: Cache-Aware Algorithms

7. Mistake #7: The Copy-Paste Trap

   • Problem 1: The Ghost Copies in “Harmless” Operations

   • Problem 2: The Hidden Cost of “Functional” Code

   • Problem 3: The “I’ll Just Modify a Copy” Mistake

   • How to Escape the Copy-Paste hell?

8. How Do Pro Developers Write Faster Code?

   • 1. They Profile Their Code Instead of Guessing

   • 2. They Avoid Premature Optimization

   • 3. They Pick the Right Data Structures (Not Just What’s Familiar)

   • 4. They Automate Performance Checks

   • 5. They Think About Performance From Day One

9. Final Thoughts: Lessons Learned the Hard Way

Mistake #1: Logging Everything in Production (Without Realizing It)

Logging is supposed to help you understand what’s happening in your code—but if you’re logging everything, you’re actually slowing it down. A common beginner mistake is leaving print() statements everywhere or enabling verbose logging even in production, where performance matters most.

Instead of logging only what’s useful, they log every function call, every input, every output, and sometimes even entire request bodies or database queries. This might seem harmless, but in a live application handling thousands of operations per second, excessive logging can cause major slowdowns.

Why This is a Problem

Logging isn’t free. Every log message, whether printed to the console or written to a file, adds extra processing time. If logging is done synchronously (which it often is by default), your application can pause execution while waiting for the log to be recorded.

It also wastes disk space. If every request gets logged in detail, log files can grow rapidly, eating up storage and making it harder to find useful information when debugging.

Here’s an example:

def process_data(data):
    print(f"Processing data: {data}")  # Logging every input
    result = data * 2  
    print(f"Result: {result}")  # Logging every result
    return result

If this function is running inside a loop handling 10,000+ operations, those print statements are slowing things down massively.

How to Fix It

Instead of logging everything, focus on logging only what actually matters. Good logging helps you diagnose real issues without cluttering your logs or slowing down your app.

For example, let’s say you're processing user transactions. You don’t need to log every step of the calculation, but logging when a transaction starts, succeeds, or fails is valuable.

// ✅ Bad logging

logging.info(f"Received input: {data}")  
logging.info(f"Processing transaction for user {user_id}")  
logging.info(f"Transaction intermediate step 1 result: {some_var}")  
logging.info(f"Transaction intermediate step 2 result: {another_var}")  
logging.info(f"Transaction completed: {final_result}")  

// ✅ Better logging

logging.info(f"Processing transaction for user {user_id}")  
logging.info(f"Transaction successful. Amount: ${amount}")

Next, make sure debugging logs are turned off in production. Debug logs (logging.debug()) are great while developing because they show detailed information, but they shouldn’t be running on live servers.

You can control this by setting the logging level to INFO or higher:

import logging

logging.basicConfig(level=logging.INFO)  # Only logs INFO, WARNING, ERROR, CRITICAL messages

def process_data(data):
    logging.debug(f"Processing data: {data}")  # Won't show up in production
    return data * 2

Finally, for high-performance applications, consider using asynchronous logging. By default, logging operations can block execution, meaning your program waits until the log message is written before continuing. This can be a bottleneck, especially if you're logging to a file or a remote logging service.

Asynchronous logging solves this by handling logs in the background. Here’s how you can set it up with Python’s QueueHandler:

import logging
import logging.handlers
import queue

log_queue = queue.Queue()
queue_handler = logging.handlers.QueueHandler(log_queue)
logger = logging.getLogger()
logger.addHandler(queue_handler)
logger.setLevel(logging.INFO)

logger.info("This log is handled asynchronously!")

Mistake #2: Using the Wrong Loops (When There’s a Faster Alternative)

Why This is a Problem

Loops are one of the first things you learn in programming, and for loops feel natural—they give you control, they’re easy to understand, and they work everywhere. That’s why beginners tend to reach for them automatically.

But just because something works doesn’t mean it’s the best way. In Python, for loops can be slow—especially when there’s a built-in alternative that does the same job faster and more efficiently.

This isn’t just a Python thing. Most programming languages have optimized ways to handle loops under the hood—whether it's vectorized operations in NumPy, functional programming in JavaScript, or stream processing in Java. Knowing when to use them is key to writing fast, clean code.

Example

Let’s say you want to square a list of numbers. A beginner might write this:

numbers = [1, 2, 3, 4, 5]
squared = []

for num in numbers:
    squared.append(num ** 2)

Looks fine, right? But there are two inefficiencies here:

1. You're manually looping when Python has a better, built-in way to handle this.

2. You're making repeated .append() calls, which add unnecessary overhead.

In small cases, you won’t notice a difference. But when processing large datasets, these inefficiencies add up fast.

The Better, Faster Way

Python has built-in optimizations that make loops run faster. One of them is list comprehensions, which are optimized in C and run significantly faster than manual loops. Here’s how you can rewrite the example:

pythonCopyEdit# Much faster and cleaner
squared = [num ** 2 for num in numbers]

Why this is better:

1. It’s faster. List comprehensions run in C under the hood, meaning they don’t have the overhead of Python function calls like .append().

2. It eliminates extra work. Instead of growing a list dynamically (which requires resizing in memory), Python pre-allocates space for the entire list. This makes the operation much more efficient.

3. It’s more readable. The intent is clear: "I’m creating a list by squaring each number"—no need to scan through multiple lines of code.

4. It’s less error-prone. Since everything happens in a single expression, there’s less chance of accidentally modifying the list incorrectly (for example, forgetting to .append()).

When to Use For Loops vs. List Comprehensions

For loops still have their place. Use them when:

• You need complex logic inside the loop (for example, multiple operations per iteration).

• You need to modify existing data in place rather than create a new list.

• The operation involves side effects, like logging, file writing, or network requests.

Otherwise, list comprehensions should be your default choice for simple transformations. They’re faster, cleaner, and make your Python code more efficient.

Mistake #3: Writing Database Queries Inside Loops (Killer of Speed)

Why This is a Problem

This is one of the biggest slow-code mistakes beginners (and even intermediates) make. It happens because loops feel natural, and database queries feel straightforward. But mix the two together, and you’ve got a performance disaster.

Every time you call a database inside a loop, you're making repeated trips to the database. Each query adds network latency, processing overhead, and unnecessary load on your system.

Example:

Imagine you’re fetching user details for a list of user_ids like this:

pythonCopyEdituser_ids = [1, 2, 3, 4, 5]

for user_id in user_ids:
    user = db.query(f"SELECT * FROM users WHERE id = {user_id}")
    print(user)  # Do something with the user

What's wrong here?

• You're hitting the database multiple times instead of once.

• Each call has network overhead (database queries aren’t instant).

• Performance tanks when user_ids gets large.

How to Fix It: Use Bulk Queries

Instead of making 5 separate queries, make one:

pythonCopyEdituser_ids = [1, 2, 3, 4, 5]

users = db.query(f"SELECT * FROM users WHERE id IN ({','.join(map(str, user_ids))})")

for user in users:
    print(user)  # Process users efficiently

Why this is better:

• In the above code, we just have one database call instead of many. This results in faster performance.

• There’s also less network overhead which makes your app feel snappier.

• And this works even if user_ids has 10,000+ entries.

A More Scalable Approach

If you're using an ORM (like SQLAlchemy in Python or Sequelize in JavaScript), use batch fetching instead of looping:

pythonCopyEditusers = db.query(User).filter(User.id.in_(user_ids)).all()

Mistake #4: Not Knowing Your Hardware’s Dirty Secrets

Your code doesn’t run in a magical fairyland—it runs on real hardware. CPUs, memory, and caches have quirks that can turn “logically fast” code into a sluggish mess. Here’s what most tutorials won’t tell you:

Problem 1: The CPU’s Crystal Ball is Broken (Memory Prefetching)

What you think happens:

“I’m looping through data sequentially. The CPU should predict what I need next!”

What actually happens:

Modern CPUs have a memory prefetcher—a smart assistant that tries to guess which memory locations you’ll need next and loads them in advance.

But here’s the catch: If your access pattern is too random, the prefetcher gives up. Instead of smoothly fetching data ahead of time, the CPU is left waiting, like someone stuck refreshing Google Maps on a broken internet connection or blind date.

This happens a lot with linked lists and hash tables, where memory jumps around unpredictably.

Example:

# Linked list traversal (random memory jumps)  
class Node:  
    def __init__(self, val):  
        self.val = val  
        self.next = None  

head = Node(0)  
current = head  
for _ in range(100000):  # Each 'next' points to a random memory location  
    current.next = Node(0)  
    current = current.next  

# Walking this list = 100,000 cache misses

Why this hurts:

Each time the CPU needs the next Node, it has to fetch it from a random memory location, making prefetching useless and causing frequent cache misses.

The Fix: Use Contiguous Data Structures

Instead of using a linked list, store your data in a contiguous memory block (like an array or NumPy array). This way, the CPU can easily prefetch the next elements in sequence, speeding things up.

# Array traversal (prefetcher-friendly)  
data = [0] * 100000  # Contiguous memory  
for item in data:  
    pass  # CPU prefetches next elements seamlessly

Why this is better:

• The CPU efficiently prefetches upcoming values instead of waiting.

• Fewer cache misses = way faster execution.

• Hot loops (loops that run millions of times) get a huge performance boost.

📌 Hot loops are loops that execute a massive number of times, like those in data processing, AI models, and game engines. Even a small speedup in a hot loop can dramatically improve overall performance.

Problem 2: The Invisible Tax of Memory Pages (TLB Thrashing)

What you think happens:

“My 10GB dataset is just… there. Accessing it is free, right?”

What actually happens:

Your OS splits memory into 4KB pages. Every time your program accesses a new memory page, the CPU consults a Translation Lookaside Buffer (TLB)—a “phonebook” for fast page lookups.

If your program jumps between too many pages, you get TLB misses, and the CPU wastes cycles waiting for the OS to fetch memory mappings.

Example:

# Iterating a giant list with random access  
data = [x for x in range(10_000_000)]  
total = 0  
for i in random_indexes:  # 1,000,000 random jumps  
    total += data[i]  # Each jump likely hits a new page

Why this hurts:

• TLB misses can add 10-100 CPU cycles per access.

• If you have millions of random accesses, that’s billions of wasted cycles.

The Fix: Process Data in Chunks

To reduce TLB misses:

• Process data in chunks (for example, 4096 elements at a time) instead of randomly jumping around.

• Use huge pages (2MB instead of 4KB) so that more data fits in each memory page.

Problem 3: Your Code is a Tourist in the Wrong CPU Neighborhood (NUMA)

What you think happens:

“My 64-core server is a speed paradise!”

What actually happens:

On multi-socket servers, memory is divided into NUMA (Non-Uniform Memory Access) zones. Each CPU socket has its own local memory, and accessing memory from another socket is slow—like ordering Uber Eats from another city.

Example:

# Running this on a 2-socket server:  
from multiprocessing import Pool  
import numpy as np  

def process(chunk):  
    data = np.load("giant_array.npy")  # Allocated on Socket 1's RAM  
    return chunk * data  # If process runs on Socket 2's CPU... ouch  

with Pool(64) as p:  
    p.map(process, big_data)  # 64 cores fighting over remote RAM

Why this hurts:

• Accessing memory from another NUMA zone can be 2-4x slower.

• Your 64 cores end up waiting for memory instead of actually computing.

The Fix: Pin Processes to NUMA-Aware Memory

Instead of letting your processes randomly access memory, you can pin them to the correct NUMA node.

• Use numactl on Linux to allocate memory near the CPU that will use it.

• Use numba-aware libraries in NumPy to ensure data is allocated optimally.

Problem 4: The CPU is a Drama Queen (Speculative Execution)

What you think happens:

“My code runs in the order I wrote it!”

What actually happens:

CPUs speculatively execute code ahead of time. If they guess wrong, they have to rollback everything and restart, which slows things down.

Example:

// Unpredictable branches = CPU's worst nightmare  
if (rare_condition) {  // 99% of the time, this is false  
    do_work();  
}

Why this hurts:

A branch misprediction wastes 15-20 cycles. In hot loops, this can really hurt performance.

The Fix: Make Branches Predictable

Sort data to help the CPU make better predictions:

# Process all 'valid' items first, then 'invalid' ones  
sorted_data = sorted(data, key=lambda x: x.is_valid, reverse=True)  
for item in sorted_data:  
    if item.is_valid:  # CPU learns the pattern → accurate predictions  
        process(item)

Why This Works:

• Branching becomes predictable—the CPU stops guessing wrong.

• Sorting ahead of time reduces rollbacks and wasted cycles.

How to Fight Back

Here’s how you can stop your CPU from sabotaging your code:

1. Treat Memory Like a Highway: Cache lines matter. Keep data contiguous so the CPU doesn’t have to search for it.

2. Profile with perf: Use Linux’s perf tool to spot cache misses, page faults, and TLB thrashing:

    perf stat -e cache-misses,page-faults ./your_code
   

3. Assume Nothing. Benchmark Everything: CPUs have a thousand undocumented behaviors. Test different data layouts, loop structures, and memory allocations to see what’s fastest.

Mistake #5: Memory Fragmentation

You’ve optimized your algorithms. You’ve nailed Big O. Yet your app still crashes with “out of memory” errors or slows to a crawl over time. The culprit? Memory fragmentation—a ghost in the machine that most developers ignore until it’s too late.

What’s Happening Under the Hood

When your code allocates and frees memory blocks of varying sizes, it leaves behind a patchwork of free and used spaces. Over time, this creates a Swiss cheese effect in your RAM: plenty of total free memory, but no contiguous blocks for new allocations.

Example:
Imagine a C++ server that handles requests by allocating buffers of random sizes:

void process_request() {  
    // Allocate a buffer of random size between 1–1024 bytes  
    char* buffer = new char[rand() % 1024 + 1];  
    // ... process ...  
    delete[] buffer;  
}

After millions of requests, your memory looks like this:

[USED][FREE][USED][FREE][USED][FREE]...

Now, when you try to allocate a 2KB buffer, it fails—not because there’s no space, but because no single free block is large enough.

How to Fix it:

Use a memory pool to allocate fixed-size blocks:

class MemoryPool {  
public:  
    MemoryPool(size_t block_size) : block_size_(block_size) {}  
    void* allocate() { /* get a pre-allocated block */ }  
    void deallocate(void* ptr) { /* return block to pool */ }  
};  

// All requests use buffers of fixed size (1024 bytes)  
MemoryPool pool(1024);  
void process_request() {  
    char* buffer = static_cast<char*>(pool.allocate());  
    // ... process ...  
    pool.deallocate(buffer);  
}

By standardizing block sizes, you eliminate fragmentation.

The Autoboxing Trap (Java, C#, and so on)

What’s Happening?

In languages that mix primitives (like int, float) and objects (like Integer, Double), converting a primitive to its object wrapper is called autoboxing. It feels harmless, but in hot loops, it’s a performance disaster.

Example:

// Slow: Creates 1,000,000 Integer objects (and garbage!)
List<Integer> list = new ArrayList<>();
for (int i = 0; i < 1_000_000; i++) {  
    list.add(i);  // Autoboxing 'i' to Integer  
}

Why this hurts performance:

• Memory overhead: Each Integer object adds 16–24 bytes of extra memory (object headers, pointers). With 1,000,000 numbers, that’s an extra 16–24MB wasted just on overhead.

• Garbage collection (GC) pressure: Since objects are allocated on the heap, the GC constantly cleans up old Integer objects, leading to latency spikes.

• CPU cache inefficiency: Primitives like int are tightly packed in memory, but Integer objects are scattered across the heap with extra indirection, wrecking cache locality.

The Fix: Use Primitive Collections

To avoid autoboxing, use data structures that store raw primitives instead of objects. In Java, Eclipse Collections provides primitive-friendly lists like IntList that store raw int values directly.

Example: The Faster Version (Primitive Collections)

// Import primitive-friendly collection
import org.eclipse.collections.api.list.primitive.IntList;
import org.eclipse.collections.impl.list.mutable.primitive.IntArrayList;  

// Use IntArrayList to store raw ints
IntList list = new IntArrayList();  
for (int i = 0; i < 1_000_000; i++) {  
    list.add(i);  // No autoboxing! Stores raw 'int'  
}

How this fix works:

• Stores raw int values instead of Integer objects, eliminating memory overhead.

• Avoids heap allocations, so the garbage collector doesn’t get involved.

• Keeps numbers tightly packed in memory, improving CPU cache efficiency.

The Fix for C

In C#, you can avoid unnecessary heap allocations by using structs and Span<T>, which keep data on the stack or in contiguous memory rather than the heap.

// Span<T> avoids heap allocations  
Span<int> numbers = stackalloc int[1_000_000];  
for (int i = 0; i < numbers.Length; i++) {  
    numbers[i] = i;  // No boxing, no heap allocation  
}

No object wrappers. No GC pressure. Just performance.

Mistake #6: The Cache (catch)

You’ve heard “cache matters,” but here’s the twist: your loops are lying to your CPU. The way you traverse multi-dimensional arrays can turn a 10x speed difference into a mystery that leaves you questioning reality.

Row-Major vs. Column-Major Access

What you think happens:
“Iterating over a 2D array is the same whether I go row-by-row or column-by-column. Right?”

What actually happens:
Memory is laid out linearly, but CPUs prefetch data in chunks (cache lines). Traversing against the grain forces the CPU to fetch new cache lines every single step.

Example in C:

// A "tiny" 1024x1024 matrix  
int matrix[1024][1024];  

// Fast: Row-major traversal (cache-friendly)  
for (int i = 0; i < 1024; i++) {  
    for (int j = 0; j < 1024; j++) {  
        matrix[i][j] = i + j;  
    }  
}  

// Slow: Column-major traversal (cache-hostile)  
for (int j = 0; j < 1024; j++) {  
    for (int i = 0; i < 1024; i++) {  
        matrix[i][j] = i + j;  
    }  
}

The result:

• Row-major: ~5ms (data flows like a river).

• Column-major: ~50ms (CPU drowns in cache misses).

Why it’s worse than you think:
In C/C++, arrays are row-major. But in Fortran, MATLAB, or Julia, they’re column-major. Use the wrong traversal order in these languages, and you’ll get the same penalty.

The Pl**ot Twist: Your Programming Language is Gaslighting You**

In C and Python (NumPy default), arrays use row-major order. But in Fortran, MATLAB, and Julia, arrays are column-major. If you assume the wrong layout, your loops will be slow for no apparent reason.

Python Example:

import numpy as np  

# Row-major (C-style) → Fast for row-wise loops  
row_major = np.zeros((1024, 1024), order='C')  

# Column-major (Fortran-style) → Fast for column-wise loops  
col_major = np.zeros((1024, 1024), order='F')  

# ❌ Slow: Column-wise access on a row-major array  
for i in range(1024):  
    for j in range(1024):  
        col_major[i][j] = i + j  # Cache-miss chaos!

Why this is a problem:

• Row-major (default in NumPy) expects row-wise access, but the loop accesses it column-wise, causing cache misses.

• Fortran-style arrays are stored column-first, so row-wise loops will be slow instead.

The Fix:

• Match the array order to your access pattern using order='C' (row-major) or order='F' (column-major).

• Convert data layout with np.asarray() if needed.

The Multidimensional Illusion**: 3D+ Arrays**

What you think happens:
“3D arrays are just 2D arrays with extra steps. No big deal.”

What actually happens:
Each dimension adds a layer of indirection. A 3D array in C is an array of arrays of arrays. Traversing the “wrong” dimension forces the CPU to dereference pointers repeatedly, killing locality.

Example: 3D Array in Traversal in C

// ✅ Fast: Iterate in Row-Major Order (Innermost Dimension Last)

int space[256][256][256];  

for (int x = 0; x < 256; x++) {  
    for (int y = 0; y < 256; y++) {  
        for (int z = 0; z < 256; z++) {  
            space[x][y][z] = x + y + z;  // Smooth memory access  
        }  
    }  
}

So what happens is that the innermost loop moves through contiguous memory, making full use of cache lines.

// ❌ Slow: Iterate in the Wrong Order (Innermost Dimension First)

for (int z = 0; z < 256; z++) {  
    for (int y = 0; y < 256; y++) {  
        for (int x = 0; x < 256; x++) {  
            space[x][y][z] = x + y + z;  // Constant cache misses  
        }  
    }  
}

Why this is bad:

• This loop jumps across memory every time x changes.

• Instead of accessing contiguous memory, it dereferences pointers constantly.

• Penalty: Up to 100x slower for large 3D arrays!

The Nuclear Option: Cache-Aware Algorithms

For extreme performance (game engines, HPC), you need to design for cache lines:

1. Tiling: Split arrays into small blocks that fit in L1/L2 cache.

    // Process 8x8 tiles to exploit 64-byte cache lines  
    for (int i = 0; i < 1024; i += 8) {  
        for (int j = 0; j < 1024; j += 8) {  
            // Process tile[i:i+8][j:j+8]  
        }  
    }
   

2. SoA vs. AoS: Prefer Structure of Arrays (SoA) over Array of Structures for SIMD.

    // Slow: Array of Structures (AoS)  
    struct Particle { float x, y, z; };  
    Particle particles[1000000];  
   
    // Fast: Structure of Arrays (SoA)  
    struct Particles {  
        float x[1000000];  
        float y[1000000];  
        float z[1000000];  
    };
   

Mistake #7: The Copy-Paste Trap

You’d never download 10 copies of the same movie. But in code? You’re probably cloning data all the time without realizing it. Here’s how invisible copies turn your app into a bloated, slow mess—and how to fix it.

Problem 1: The Ghost Copies in “Harmless” Operations

What you think happens:
“I sliced a list—it’s just a reference, right?”

What actually happens:
In many languages, slicing creates a full copy of the data. Do this with large datasets, and you’re silently doubling memory usage and CPU work.

Python Example:

# A 1GB list of data  
big_data = [ ... ]  # 1,000,000 elements  

# Accidentally cloning the entire list  
snippet = big_data[:1000]  # Creates a copy (harmless, right?)  

# Better: Use a view (if possible)  
import numpy as np  
big_array = np.array(big_data)  
snippet = big_array[:1000]  # A view, not a copy (0MB added)

Why this hurts:

• Copying 1GB → 2GB of RAM used.

• If this happens in a loop, your program could crash with MemoryError.

The Fix:

• Use memory views (numpy, memoryview in Python) or lazy slicing (Pandas .iloc).

• In JavaScript, slice() copies arrays—replace with TypedArray.subarray for buffers.

Problem 2: The Hidden Cost of “Functional” Code

What you think happens:

“I’ll chain array methods for clean, readable code!”

What actually happens:

Every map, filter, or slice creates a new array. Chain three operations? You’ve cloned your data three times.

JavaScript Example:

// A 10,000-element array  
const data = [ ... ];  

// Slow: Creates 3 copies (original → filtered → mapped → sliced)  
const result = data  
  .filter(x => x.active)  
  .map(x => x.value * 2)  
  .slice(0, 100);  

// Faster: Do it in one pass  
const result = [];  
for (let i = 0; i < data.length; i++) {  
  if (data[i].active) {  
    result.push(data[i].value * 2);  
    if (result.length === 100) break;  
  }  
}

Why this hurts:

• 10,000 elements → 30,000 operations + 3x memory.

• Functional programming is elegant but can be expensive.

The Fix:

• Use generators (Python yield, JS function*) for lazy processing.

• Replace method chains with single-pass loops in hot paths.

Problem 3: The “I’ll Just Modify a Copy” Mistake

What you think happens:
“I need to tweak this object. I’ll duplicate it to avoid side effects.”

What actually happens:
Deep cloning complex objects (especially in loops) is like photocopying a dictionary every time you edit a word.

Python Example:

import copy  

config = {"theme": "dark", "settings": { ... }}  # Nested data  

# Slow: Deep-copying before every edit  
for user in users:  
    user_config = copy.deepcopy(config)  # Copies entire nested structure  
    user_config["theme"] = user.preference  
    # ...  

# Faster: Reuse the base config, overlay changes  
for user in users:  
    user_config = {"theme": user.preference, **config}  # Shallow merge  
    # ...

Why this hurts:

• deepcopy is 10-100x slower than shallow copies.

• Multiplied by 1,000 users, you’re wasting minutes.

The Fix:

• Use immutable patterns: Create new objects by merging instead of cloning.

• For big data, use structural sharing (libraries like immutables in Python).

How to Escape the Copy-Paste hell?

1. Ask: “Do I need a copy?”: 90% of the time, you don’t. Use views, generators, or in-place edits.

2. Profile memory usage: Tools like memory_profiler (Python) or Chrome DevTools (JS) show copy overhead.

3. Learn your language’s quirks:

   • Python: Slicing lists copies, slicing NumPy arrays doesn’t.

   • JavaScript: [...array] clones, array.subarray (TypedArray) doesn’t.

How Do Pro Developers Write Faster Code?

Most beginners think "fast code" just means writing cleaner syntax or using a different framework. But in reality, performance isn't just about what language or framework you use—it's about how you think.

Pro developers don’t just write code. They measure, test, and optimize it. Here’s how they do it.

1. They Profile Their Code Instead of Guessing

🔥 Beginners: “This function feels slow… maybe I should rewrite it?”
💡 Pros: “Let’s profile it and see what’s actually slow.”

Instead of randomly rewriting code, pro developers measure first using profiling tools.

Example: In Python, you can use cProfile to analyze where your code is spending the most time:

pythonCopyEditimport cProfile

def slow_function():
    total = 0
    for i in range(10**6):
        total += i
    return total

cProfile.run('slow_function()')

👀 What this tells you:

• Which function takes the longest

• How many times is a function being called

• Where is the actual bottleneck

✅ Takeaway: Before optimizing, always profile your code. You can’t fix what you don’t measure.

Other useful tools:

• Python: cProfile, line_profiler

• JavaScript: Chrome DevTools Performance Tab

• Java: JProfiler

• General: perf, Valgrind

2. They Avoid Premature Optimization

🔥 Beginners: “I’ll spend hours optimizing this loop before testing it.”
💡 Pros: “I’ll make it work first, then optimize only what matters.”

Donald Knuth famously said, "Premature optimization is the root of all evil." Many beginners waste time optimizing things that aren’t actually slow.

Example: A beginner might spend hours optimizing a loop that runs in 0.001 seconds, while the real slowdown is an extra database query that takes 500ms.

✅ Takeaway:

• First, make your code work.

• Then, profile and optimize only what’s slow.

3. They Pick the Right Data Structures (Not Just What’s Familiar)

🔥 Beginners: “I’ll just use a list.”
💡 Pros: “Which data structure is optimal for this task?”

Most slowdowns happen because of bad data structure choices. Pro developers pick the right tool instead of just going with the default.

Example: Fast lookups
❌ Slow (List - O(n))

pythonCopyEditusers = ["alice", "bob", "charlie"]
if "bob" in users:  # Searches the entire list
    print("Found")

✅ Fast (Set - O(1))

pythonCopyEditusers = {"alice", "bob", "charlie"}
if "bob" in users:  # Uses a hash table for instant lookup
    print("Found")

✅ Takeaway: When performance matters, choose the right data structure, not just the most familiar one.

4. They Automate Performance Checks

🔥 Beginners: “I’ll check for performance issues when I feel like it.”
💡 Pros: “I’ll use tools to automatically catch performance bottlenecks.”

Instead of manually looking for slow code, pro developers rely on automated tools that flag inefficiencies.

Example:

• Python: py-spy (lightweight sampling profiler)

• JavaScript: Chrome DevTools Performance Monitoring

• Java: JMH (Java Microbenchmark Harness)

• AI-assisted code reviews: There are tools like CodeAnt that analyze and auto fix your code automatically when you push on GitHub(or anywhere) and suggest performance improvements.

✅ Takeaway: Set up automated checks so you catch performance issues early—before they hit production.

5. They Think About Performance From Day One

🔥 Beginners: “I’ll optimize later.”
💡 Pros: “I’ll write efficient code from the start.”

While premature optimization is bad, writing slow code from the start is worse. Pro developers avoid common pitfalls before they become real problems.

Example: Writing efficient loops from the start
❌ Slow (Unnecessary .append())

pythonCopyEditresult = []
for i in range(10**6):
    result.append(i * 2)  # This is slow

✅ Fast (List Comprehension - Optimized from the Start)

pythonCopyEditresult = [i * 2 for i in range(10**6)]  # Faster, more efficient

✅ Takeaway: Small choices add up. Think about performance as you write, rather than fixing it later.

🚀 Final Thoughts: Lessons Learned the Hard Way

Thanks for reading! These are some of the tips I’ve personally bookmarked for myself—things I’ve learned the hard way while coding, talking to dev friends, and working on real projects.

When I first started, I used to guess why my code was slow instead of measuring. I’d optimize random parts of my code and still wonder why things weren’t getting faster. Over time, I realized that pro developers don’t just “write fast code” by instinct—they use tools, measure, and optimize what actually matters.

I wrote this to save you from making the same mistakes I did. Hopefully, now you have a clearer roadmap to writing faster, more efficient code—without the frustration I went through! 🚀

If you found this helpful, bookmark it for later, and feel free to share it with a fellow dev who might be struggling with slow code too.

Happy coding! 😊

There are lightweight Linux distributions designed to breathe new life into older hardware. These operating systems are streamlined to use limited system resources while still providing a smooth user experience.

Here are some lightweight Linux distros we'll discuss in this article:

• Puppy Linux.
• Bodhi Linux.
• Peppermint OS.
• AntiX.
• Lubuntu.

Why Choose a Lightweight Linux Distro?

If your old PC is struggling to keep up with modern operating systems and software, it may be time to consider a lightweight Linux distro. These streamlined OS options are designed to run well on older and lower-spec hardware.

Why choose a lightweight distro? For starters, it will breathe new life into your old PC. Tasks like web browsing, emailing, and basic productivity will run smoothly again without lag or freezing.

Lightweight Linux distros are perfect for:

• Old laptops - Give that aging laptop a second lease on life. A lightweight OS can make it usable again for on-the-go work and play.
• Netbooks - Underpowered netbooks will benefit greatly from a minimalist Linux distro. You'll be amazed how much more you can do.
• Secondary PCs - For a spare system or kids' computer, a lightweight distro is ideal. No need for expensive, power-hungry software.
• Learning Linux - If you're new to Linux, a lightweight distro with simple interface is easy to get started with. You can focus on learning the operating system without fancy extras getting in the way.

With options like Bodhi, Peppermint OS, and AntiX, there's a lightweight Linux distro for every skill level and need. And since they're open source, the price is right — free!

Puppy Linux: Small but Mighty

Image credit – PuppyLinux Official

If you have an older PC that's low on resources, Puppy Linux is a great lightweight distro to try. This tiny OS weighs in at under 300MB, so it can run smoothly even on systems with as little as 512MB of RAM.

Despite its small size, Puppy Linux packs a punch. It comes bundled with essential apps like a word processor, spreadsheet software, a web browser, and more. You'll have everything you need to be productive right out of the box.

Puppy Linux is also extremely flexible. You have the option to run it directly from RAM, which will make the system fly even on the oldest hardware. You can also install it to a USB drive, or internal hard drive, or even save your settings and files on the cloud.

This distro may be small in size, but it's big on customization. You can choose from a variety of window managers, desktop environments, and themes to make the interface look and work the way you want. You can also install thousands of additional packages from the Puppy and Ubuntu software repositories.

Whether you just want to breathe new life into an aging PC or experiment with Linux, Puppy is a perfect choice. Its tiny footprint, solid software selection, and extreme customizability makes it a small but mighty distro that can run well even on systems that have long been forgotten. Give your old PC a new leash on life with Puppy Linux.

Bodhi Linux: Enlightened and Extra Light

Image Credit – BodhiLinux Official

If you’re looking for an OS that will run smoothly on aging hardware without sacrificing functionality, Bodhi Linux is a great choice. Bodhi is a lightweight Linux distribution based on Ubuntu that uses the Moksha desktop environment. It has a minimalistic yet elegant feel that’s perfect for older PCs.

Bodhi comes with only the essential apps pre-installed so you have full control over what runs on your system. You can choose from thousands of free software packages in the Bodhi repository using the built-in app center. Despite its lightweight nature, Bodhi supports thousands of Ubuntu packages, so you’ll have access to a wide range of software.

One of the best parts of Bodhi is how customizable it is. You can change desktop themes, icons, and more with just a few clicks. If there’s something you don’t like about the default setup, chances are that you can tweak it to your liking. The Enlightenment desktop environment that Bodhi is based on is highly modular, so you have a lot of flexibility.

Bodhi is available for both 32-bit and 64-bit systems, so no matter what type of PC you have, there’s a version that will work for you. System requirements are just 512MB of RAM and a 500MHz processor. Just lightweight.

If you want to breathe new life into an older laptop or desktop, Bodhi Linux is a perfect choice. With its minimal system requirements, elegant interface, and highly customizable nature, Bodhi will run well on older hardware while giving you a modern Linux experience.

Give Bodhi a try and enjoy an “enlightened” computing experience on your PC.

Peppermint OS: Refreshingly Lightweight

Image Credit – PeppermintOS Official

Peppermint OS is a lightweight Linux distro designed for older PCs and laptops. If your aging hardware is struggling under the weight of Windows or macOS, Peppermint could give it a new lease on life.

Here are some of its features:

Light on Resources

Peppermint OS uses the LXDE desktop environment that’s optimized for older CPUs and limited memory. It only needs 512MB of RAM to run, so it will fly on that Pentium 4 machine or Core 2 Duo laptop you have stashed in your closet.

The OS takes up about 3GB of storage. This keeps your system resources focused on the tasks that matter to you.

Cloud Support

While Peppermint OS is light on local resources, it integrates well with cloud and web apps. The OS builds in close integration with services like Dropbox, Google Drive, and more.

You can save files directly to and open files from these cloud services. This means you have access to lots of functionality without needing high-powered local software.

User-Friendly

Don’t worry if you’re not a Linux expert, Peppermint OS is designed to be easy to use. The menu is simple to navigate, and installing software is straightforward.

The distro is also compatible with lots of Windows programs, so you may be able to use some of the same software you’re familiar with.

The best part is that Peppermint OS is free to download and try. You can install it on your aging PC to give it a boost and see how it runs without committing to anything. If you find it’s not for you, you can simply uninstall it and you’re back to where you started.

For a PC that’s losing its charm, Peppermint OS could be just the refresh it needs. Why not give it a go?

AntiX: As Lean as They Come

Image Credit – ItsFoss

If you have an older PC that struggles with modern software, AntiX is an excellent lightweight Linux distro to try. AntiX is designed to run on systems with as little as 64MB of RAM and a Pentium II processor. Despite these minimal requirements, AntiX provides a complete desktop experience.

AntiX uses the IceWM window manager and lightweight alternatives to popular software. The Claws email client, AbiWord word processor, and mtPaint are also included. AntiX also has its own lightweight system tools for things like managing users, networks, and services.

You should know these before using the AntiX distro:

• AntiX is based on Debian, so the package management and repositories will feel familiar to most Linux users.
• The AntiX ISO is under 700MB, so it’s quick to download and install.
• AntiX is highly configurable. You can easily add and remove components to suit your needs.
• AntiX releases are rolling, so you get continuous updates without needing to install a new version.

AntiX is ideal if you want to give new life to that old PC collecting dust in your closet. It will run smoothly on systems that struggle with Windows and most mainstream Linux distributions. The minimal requirements mean it can work with nearly any x86 computer from the last 20 years.

Despite its lightweight nature, AntiX provides a complete desktop experience with office tools, internet apps, multimedia players, and more. If raw performance and responsiveness are your top priorities, AntiX is one of the best Linux distributions available for vintage PCs and older hardware.

Lubuntu

Image Credit – Wikipedia

If you’re looking for an Ubuntu-based distro that’s lightweight enough for older PCs, Lubuntu is a great choice. It uses the LXDE desktop environment which is super lightweight yet still user-friendly.

Lubuntu will run smoothly on computers with as little as 512 MB of RAM and a 1 GHz processor. This makes it ideal for breathing new life into older laptops or desktops. The interface is simple but attractive, with lots of customization options if you want to tweak it.

• Software selection: Lubuntu comes with a basic set of apps for web browsing, office tasks, and more. You can always install more software from the Ubuntu repos which contains thousands of options.
• Easy to use: The LXDE desktop is designed to be straightforward to navigate, even for Linux newbies. Things are laid out in an intuitive, familiar way.
• Great community support: As an official Ubuntu flavor, Lubuntu receives continuous security and software updates. The large Ubuntu community can also provide help if you get stuck.

Whether you just want to experiment with Linux or hope to give your old PC a speed boost, Lubuntu is worth checking out.

You can test it out by downloading the ISO and running the live session from a USB drive before doing a full install. With a lightweight yet capable distro like Lubuntu, that old hardware of yours has years of life left!

Conclusion

So there you have it, five Linux options that will breathe new life into your older PC without demanding too much from it. Any of these lightweight yet fully functional Linux distributions would be a great way to extend the useful life of your aging hardware.

Give one a try, see how it runs, and you might just fall in love with the speed and simplicity. Your old computer has more to offer, so set it free with a lightweight OS and enjoy hassle-free computing once again.

What are you waiting for? Pick a distro, back up your files, and take your vintage PC for a spin.

Thank you for reading. Happy Exploring.

I am Rahul, 19, Hustler. I am building Fueler.io, a platform for generalists to create proof of work profile and land opportunities. Let’s connect on Twitter.

In this article, I'll introduce you to some lesser-known Linux commands that will help you become a more productive and effective developer.

Whether you’re looking to boost your productivity, tighten system security, or just want to show off your Linux chops to fellow devs, these commands have you covered.

Chroot: Run Commands With a Different Root Directory

Ever wanted to run commands in a different root directory? The chroot command allows you to do just that.

Chroot, short for “change root,” lets you run commands with a different root directory. So if you wanted to test out software in a contained environment or build a minimal Linux system, chroot is your friend.

To use chroot, first you’ll need to set up a directory to act as the new root. Then you run the chroot command, passing it the path to that directory. For example, to chroot into /home/testdir, you’d run:

chroot /home/testdir

After that, any commands you run will be relative to / in the /home/testdir directory. So you could install packages, run shell scripts, compile programs, and so on. When you’re done, just exit the chroot with exit.

Chroot creates an isolated environment, so any changes you make won’t affect the rest of your system. It’s a handy tool for testing and development or for emergency recovery. Once you get familiar with chroot, you’ll find all sorts of uses for it.

Crontab: Schedule Tasks to Run Automatically

Crontab is a handy Linux command that lets you schedule tasks to run automatically at specific times. You’ll wonder how you ever lived without it!

To get started, open the crontab file with crontab -e. This will open your default text editor where you can create schedule entries, called cron jobs. Each entry has five-time fields – minute, hour, day of month, month, day of week, followed by the command to run.

For example, 0 0 * * * /home/user/daily_script.sh would run the daily_script.sh script at midnight every day. You can also do 30 8 * * 1-5 /home/user/work_script.sh to run work_script.sh at 8:30am every weekday.

Crontab allows a ton of flexibility. You can schedule jobs to run:

• Minutely, hourly, daily, weekly, monthly or yearly
• At a specific minute/hour
• On certain days of the week/month
• With wildcards to run, for example every 3 hours or every Monday and Thursday

The possibilities are endless! You can schedule backup scripts, system maintenance, email reports and so much more.

Df: Check Disk Space Usage

Ever run out of disk space and wonder where it all went? The df command is here to help. df stands for “disk free” and shows you exactly how much space is used and available on your Linux system.

Check Usage for All Mounted Filesystems

To see an overview of disk space usage for all mounted drives and partitions, simply run:

df -h

The -h flag formats the output in human-readable format, showing sizes in GB and MB instead of bytes. The output will show:

• Filesystem: The drive or partition name
• Size: Total space
• Used: Space currently in use
• Available: Free space still available
• Use%: Percentage of space used

This gives you a quick snapshot of where you have space and where it's running low.

Check Usage for a Specific Filesystem

To check space on a specific drive or partition, pass its mount point to df:

df -h /home

This will show usage stats just for your /home partition.

Keeping an eye on disk usage with df and related tools is important for any Linux system administrator. No one wants to run out of space unexpectedly.

Dmesg: View Kernel Messages

Ever wonder what’s happening behind the scenes in your Linux system? The dmesg command lets you peek under the hood and view messages from the kernel, the core of your operating system.

When your Linux system boots up, the kernel initializes hardware, loads drivers, starts services, and performs other startup tasks. The dmesg command displays the messages that get logged during this process so you can see what’s going on.

To view the kernel messages, just open your terminal and run the dmesg command. You'll see pages and pages of status updates, diagnostics, errors, and more as your system came to life. Skim through to check for any issues, or search for specific keywords like the name of your Wi-Fi adapter or other hardware components.

The dmesg output can also provide clues to solving any problems you're having. For example, if your network isn’t working, check dmesg for error messages related to your Ethernet or wireless card. You may spot something like “error initializing network device eth0” that points you to a driver issue.

The dmesg command is a handy diagnostic tool for any Linux system administrator or power user. It offers an inside look at your Linux system and can help uncover the source of both major malfunctions and minor annoyances. Ps: you can feel like a hacker.

Grep: Search for Patterns in Files

The grep command allows you to search for patterns in files and text. It’s ideal when you need to find something specific in a sea of data.

Say you have a massive log file full of information, but you only want to see the lines containing the word “error.” Just run:

grep error log.txt

This will print only the lines in log.txt that contain the word “error.”

You can also use grep to search for patterns rather than just words. For example, to find all lines in a file that start with “A” followed by a number, use:

grep ^A[0-9] log.txt

The ^A anchors the match to the start of the line, and [0-9] matches any digit.

Grep has many more advanced features as well. You can use:

• Regex patterns for complex searches
• -i to ignore case
• -v to invert the search and show lines that don’t match
• -c to just get a count of matches
• -r to recursively search all files in a directory

The next time you need to search through files, don’t do it manually—let grep do the work for you.

Head/Tail: View the First/Last Part of a File

Have you ever needed to quickly check just the first or last few lines of a long file? The head and tail commands are perfect for that.

The head command shows you the first 10 lines of a file by default. You can specify how many lines you want to see by using the -n flag, like head -n 5 filename to show the first 5 lines.

The tail command shows you the last 10 lines of a file by default. Again, use the -n flag to specify how many lines you want to see, like tail -n 20 filename to show the last 20 lines.

Both head and tail are useful when you want to do a quick check of the start or end of a long file without having to scroll through the entire thing. Some other uses of these commands:

• Checking log files for recent errors or warnings
• Viewing email headers
• Previewing configuration files
• And more!

Give head and tail a try – you'll be amazed at how much simpler they make tasks you do all the time.

Ps: List Running Processes

The Ps command allows you to see info about the processes running on your system. This includes programs, commands, and daemons that are currently active. Using Ps is a quick way to get an overview of what your Linux system is doing at the moment and the system resources each process is using.

To see a basic list of running processes, enter:

ps aux

This will show you:

• A: All processes
• U: User
• X: Processes without terminals

The output will contain info like:

• USER: The owner of the process
• PID: The process ID
• %CPU: The CPU usage
• %MEM: The memory usage
• VSZ: The virtual memory usage
• TTY: The terminal associated with the process
• STAT: The process state (Running, Sleeping, Zombie, and so on.)
• START: The start time of the process
• TIME: The CPU time used
• COMMAND: The command that started the process

You can also filter the Ps output by:

• Username: ps aux | grep root
• Process name: ps aux | grep cron
• PID: ps aux | grep 555

The Ps command allows you to quickly check in on what your system is doing and ensure there are no runaway or zombie processes hogging resources. For any Linux user, Ps is an indispensable tool for system monitoring and troubleshooting.

Rsync: Sync Files and Folders

As a Linux user, you’ve probably found yourself needing to sync files and folders between locations. Maybe you have files on your desktop you need to transfer to your laptop, or you want to backup your most important folders to an external drive. The rsync command makes syncing and backing up your files a breeze.

Rsync is a fast and versatile file copying tool. It can copy and sync files and folders locally or remotely over SSH. It’s smart enough to only transfer the differences between two locations, saving time and bandwidth.

To use rsync, open your terminal and enter the command:

rsync [options] source destination

• The source is the location of the files you want to copy. This could be a folder on your desktop or a remote server.
• The destination is where you want to copy the files. This could be an external drive mounted on your system or a folder on another server.
• Options allow you to specify items like:
• -a: Archive mode which preserves permissions, timestamps, group, owner and symlinks
• -v: Verbose output so you can see what’s being copied
• -z: Compression to speed up transfers over slow networks
• -h: Human-readable sizes (e.g. 1K, 234M, 2G)

Rsync is a must-have tool for any Linux user. Once you get the hang of it, you’ll be syncing and backing up your files with confidence.

For broad reading please refer to RSync Examples – Rsync Options and How to Copy Files Over SSH.

The Powerful Pipe Viewer (pv)

Ever wanted to see the progress of data through a pipe? The pv command allows you to do just that. It's a pipe viewer that shows you the progress of data through a pipeline.

Say you have a large file that you want to compress, like a video or backup file. Rather than staring at a blinking cursor while gzip does its thing, you can see the progress with pv. Just pipe the data through pv, then to gzip:

cat mylargefile.mp4 | pv | gzip > mylargefile.mp4.gz

pv will display the throughput and estimated time remaining as your data is compressed. It's a simple way to get feedback on long-running commands.

You can also use pv to see throughput and transfer rates of data over the network. For example, when copying a file with scp or rsync, add pv to the pipeline:

rsync -avz myfiles user@host:/backup | pv

Now you'll see the progress of your files copying over the network. pv gives you information like:

• Transferred bytes
• Transfer rate
• ETA
• Progress
• And more

It's a handy tool to give you more insight into what's happening in those long-running terminal commands.

mtr: Network Diagnostics

Have you ever needed to diagnose network issues but didn’t have access to expensive tools? mtr is a simple but powerful Linux network diagnostic tool. It combines the functionality of the ‘traceroute’ and ‘ping’ programs in a single network diagnostic tool.

mtr sends ICMP echo requests to test the network connectivity between the host mtr runs on and a user-specified destination host. It prints the response times and packet loss statistics for each router along the path. This allows you to quickly pinpoint network issues.

To use mtr, open a terminal and enter:

mtr [domain name or IP address]

For example, to trace the route to google.com, enter:

mtr google.com

mtr will start tracing the route and printing results that update in real time. It will show:

• The IP address and hostname of each router along the path
• The percentage of packet loss for each router
• The response times in milliseconds for each router

The output will continue to update until you press Ctrl+C to stop the trace.

mtr is a simple but useful tool for any Linux network administrator. It can save you hours of troubleshooting time when the network goes down by helping you identify the source of latency or packet loss.

jq: Parse JSON

Ever come across a messy JSON file and wish you had an easy way to parse through it? Meet jq, a command line tool that lets you filter and analyze JSON data with ease.

jq works like a filter. You pass it JSON data on stdin, and it passes the filtered/transformed data to stdout.

For example, say you have a JSON file called data.json with an array of objects. You can filter it to only show objects where name is equal to John like this:

cat data.json | jq '.[] | select(.name == "John")'

This will print only the John objects to the console.

jq supports many more filters than just select(), here are a few more useful ones:

• .key: Access a key from objects
• .[10:]: Show elements from index 10 onwards
• .[10:15]: Show elements from index 10 to 15
• length: Print the length of an array
• map(.): Apply a filter to each element of an array
• group_by(.key): Group objects by a key

With jq, you can manipulate JSON data in pretty much any way you want right from the command line. jq may seem niche, but JSON is used everywhere on the web, so being able to analyze and transform it efficiently is a useful skill.

tac: View Config Files in Reverse

Have you ever made a mistake while editing a config file and saved the changes, only to realize you preferred the previous version? The tac command allows you to quickly view config files in reverse, so you can see what the file looked like before your edits.

Tac simply prints files in reverse order, line by line. To view a file called config.txt in reverse, run:

tac config.txt

This will print the last line of the file first, then the second last line, and so on until it reaches the first line.

• Use tac when you want to quickly view a log file in reverse to see the latest entries first.
• Tac can also be useful when editing config files through the command line. If you make a mistake, run tac to see what the file looked like before so you can revert your changes.

Tac is a simple but useful utility to have in your Linux toolkit.

perf: Analyze CPU Performance

If you've ever wondered why your Linux system seems slower over time, the perf command can help you figure it out. Perf is a profiling tool in Linux that can analyze the performance of your CPU to help identify any bottlenecks.

To get started, run the basic perf list command to see a list of the events you can monitor. There are hundreds! Some of the most useful ones for profiling CPU performance are:

• cpu-clock: Measure the CPU clock cycles
• task-clock: Measure the time spent on task execution
• cache-misses: Count the number of cache misses
• branch-misses: Count the number of branch prediction misses

Pick an event you want to monitor, then run a command like:

perf stat -e cpu-clock sleep 5

This will run the sleep 5 command and measure the cpu-clock event while it's running. Perf will then give you a summary of the stats for that event.

To get more detailed profiling info, use the perf record command. For example, to profile a script called script.sh, run:

perf record script.sh

This will run the script and record the profiling data. You can then view the results with:

perf report

This gives you an interactive report to analyze the results. You'll see things like:

• The percentage of time spent in each function
• The actual time spent in each function
• The number of calls to each function

Using perf, you have a powerful tool to optimize the performance of your Linux system. Perf really is an amazing (if underused) tool.

Conclusion

So there you have it, some helpful Linux commands that will make you feel like a power user in no time.

With these tricks up your sleeve, you'll be zipping around Linux like a pro. The next time you're stuck or frustrated, give one of these a shot. You might just surprise yourself with what you can accomplish.

Linux is an incredibly powerful operating system if you know how to speak its language. Consider this your starter guide to becoming fluent.

I am Rahul, 19, Hustler. I am building Fueler.io a platform for generalists to create proof of work profile and land opportunities. Let’s connect on Twitter.

You write some promise-based code, everything is chugging along nicely, and then boom – one little promise rejects and the whole chain comes crashing down.

Your code grinds to a halt and you're left wondering why JavaScript couldn't just ignore that one little hiccup and continue on its merry way. Well, friend, do I have good news for you.

Meet Promise.allSettled(), your new best friend and the promise you never knew you needed. Promise.allSettled() is a game-changer, allowing you to wait for all your promises to settle – either resolve or reject – and then take action based on the results.

No more ruined promise chains or unhandled rejections. Just pure, unadulterated promise bliss. Join me as we dive into this little-known but incredibly useful promise method and see just how much it can simplify your asynchronous JavaScript code.

What Is Promise.allSettled()?

So you want to use JavaScript's Promise.allSettled() method, but aren't quite sure how it works or why you'd want to use it? No worries, I've got you covered.

Promise.allSettled() waits for all promises you give it to settle, meaning either resolve or reject. It then returns an array of objects with the status and value or reason for each promise.

This is useful when you have multiple asynchronous tasks that you want to ensure have completed, but don't necessarily care if some fail.

For example, say you have three API calls that return promises, and you want to get all the data back from the successful calls, even if one fails. You could do:

Promise.allSettled([apiCall1(), apiCall2(), apiCall3()]).then((results) => {});

This will run all three API calls, and the .then() callback will be called once they have all settled. The results array will have three objects: one for each promise, with either a status of 'fulfilled' and the data, or 'rejected' and the error.

We can filter to just get the successful calls, and proceed using that data.

The key things to remember are:

• Promise.allSettled() waits for all input promises to settle and returns their outcomes.
• Settled means either resolved (fulfilled) or rejected.
• It returns an array of objects with status and value/reason for each input promise.
• It allows handling successful promises even when some reject.

The problem with Promise.all() and the solution with Promise.allSettled()

Promise.all() is great when you want to wait for multiple promises to complete and get an array of all the resolved values. But it has one major downside: if any of the promises reject, the entire Promise.all() rejects immediately.

This can be problematic in some cases. For example, say you make requests to three different backend services, and you don't really care if one fails as long as the other two succeed. With Promise.all(), a single rejected promise would reject the entire group, and you'd miss the successful responses from the other promises.

Fortunately, there's a simple solution: Promise.allSettled(). This works similarly to Promise.all() but instead of rejecting immediately if any promise rejects, it waits for all promises to settle (either resolve or reject) and then returns an array of objects with the status and value/reason for each promise.

For example:

Promise.allSettled([
  Promise.resolve(1),
  Promise.reject(new Error("2")),
  Promise.resolve(3),
]).then((results) => {
  // results is an array of:
  // {status: "fulfilled", value: 1}
  // {status: "rejected", reason: Error}
  // {status: "fulfilled", value: 3}
});

As you can see, even though the second promise rejected, we still get the resolved values from the other promises. This allows you to handle rejections gracefully without missing any successful responses.

Promise.allSettled() provides more flexibility in these types of situations. You get the full picture of all your promises, regardless of some rejecting, so you have the opportunity to still make use of any resolved values and handle rejections appropriately.

So next time you need to wait on multiple promises but can't afford to miss any resolved values due to a rejection, be sure to reach for Promise.allSettled()! It's a very useful addition to the Promise API.

Common Questions About Promise.allSettled()

Will Promise.allSettled() slow down my code?

Not really. Promise.allSettled() simply waits for all the promises you pass to it to settle, either by fulfilling or rejecting. It doesn’t do anything else that would impact performance.

Can I still catch errors with Promise.allSettled()?

Yes, you absolutely can! Promise.allSettled() will give you the outcome of each promise, whether it was fulfilled or rejected.

For any rejected promises, you'll get the reason why it rejected, usually an error. You can catch these errors in the .catch() handler of the Promise.allSettled() call.

When should I use Promise.allSettled() vs Promise.all()?

Use Promise.allSettled() when you want to run multiple promises in parallel, but don’t want a single rejected promise to cause the entire group to reject.

For example, if you're fetching data from multiple third-party APIs, a rejected promise from one API shouldn’t stop you from getting data from the other APIs.

Use Promise.all() when you want to run promises in parallel but need them all to successfully complete for your code to continue.

For example, if you need to fetch data from two APIs to display on a page, you’d want both promises to fulfill before rendering the data.

Can I get the results of the settled promises?

Yes! Promise.allSettled() returns an array of objects with the status and value/reason for each promise. For example:

Promise.allSettled([
  Promise.resolve(1),
  Promise.reject(new Error("2")),
  Promise.resolve(3),
]).then((results) => {
  console.log(results);
  /*
    [
      { status: "fulfilled", value: 1 },
      { status: "rejected", reason: Error: 2 },
      { status: "fulfilled", value: 3 }
    ]
    */
});

You'll get information on all the promises, whether they fulfilled or rejected, so you have the full picture of the parallel operations.

Conclusion

So there you have it. Promise.allSettled() is a handy method you never knew you needed.

No longer do you have to wrap Promise.all() in a try/catch just to handle potential rejections. You can let Promise.allSettled() handle all that for you and just focus on the resolved values. Your async code will be cleaner and easier to read.

Thank you for reading. I am Rahul, 19, and a technical writer. Here is my proof of work.

But how do you come up with new ideas to build? Sooner or later, you will find yourself running out of features to add or algorithms to implement.

Fortunately, there is a simple solution: APIs. APIs are infinitely versatile and you can use them to create countless unique projects.

To help jumpstart your coding practice, I'll show you 9 different project ideas—all of which leverage APIs in some way—that you can use to build up your programming skills.

Let's get started!

How to Build an E-Signature App

We'll start by building an e-signature app using a few APIs. These APIs have most of the features required to build an e-signature app.

You can use the DocuSign API to generate personalized digital signatures, set up workflows, templates, tagging rules, secure document storage, encryption, and so on in a safe environment.

So how would you get started with this project? I'd recommend using React, Node and MongoDB to create this type of app. Here's a rough outline of some steps you could take:

• Read the DocuSign API documentation and signup for a developer account.
• Design the UI using React or Angular
• Implement the back-end logic using NodeJS
• Test and debug your app in the DocuSign API sandbox, and you're good to go.

How to Build a Stock Market Tracking App

If you're looking to sharpen your development abilities while also producing something worthwhile and impressive, creating a stock market tracking application could be a great option.

This type of app can monitor stock values and store them in a database for fast access and evaluation. Utilizing the Alpha Vantage API, you can access data on stocks and prices.

For this project, you'll need to use a charting library like Chart.js, Highcharts or D3.js. These libraries will help to show the data in more visually appealing way.

You may also want to store data such as stock quotes, historical data, and user portfolios, so you'll need a database for that. I'd suggest MongoDB or PostgreSQL as a couple good choices. For the front end, React would be a good choice, and you can use Node for the back end.

So how do you get started?

1. First, you'll want to identify the key functionalities you want to include, like real-time stock quotes, historical stock data, portfolio tracking, customizable watchlists, alerts, and so on.
2. You'll use the Alpha Vantage API as your data source for stock market data. Alpha Vantage provides a comprehensive and reliable set of APIs for accessing stock market data, including stock quotes, technical indicators, historical data, and more.
3. You'll also need to create an intuitive and user-friendly interface.
4. You'll have to integrate the Alpha Vantage API to fetch real-time or historical stock market data.
5. Then you'll implement the core functionality using the Alpha Vantage API. This can include displaying real-time stock quotes, charts, news, portfolio tracking, watchlists, alerts, and notifications.
6. Finally, you'll make sure user data and financial information is protected and secure by implementing appropriate security measures, such as data encryption, authentication, and authorization.

Building an application like this is an excellent way to help you practice your development skills with something exciting and useful.

How to Build a Delivery Management App

Creating a delivery management app is actually quite straightforward. It helps entrepreneurs and business owners get their goods delivered to customers in an efficient manner.

• You'll need tools like Google Maps, Geocoding, or other geolocation APIs to get started.
• You'll have to create an interface for customers to enter their delivery address and track the real-time location of delivery drivers using the Google Maps API.
• For each driver, you should create a profile with contact information, estimated time of arrival, and any details about the goods being delivered.
• Customers should be able to track their deliveries in real-time while calculating distance and route optimization for better predictions on arrival times.

It's just like creating a smaller version of Zomato or DoorDash (in the US).

How to Develop an Online Shopping Mall App

If you're ready to work with a lot of different APIs, this online shopping mall app project will be a fun one for you. You'll use the below APIs to build a modern e-commerce app for selling anything from clothes and accessories to groceries or furniture.

For this project, you will need to use the following APIs:

• A payment gateway API like the PayPal API or the Stripe API to collect payment from users.
• A query language like GraphQL API to manage data operations and fetch the data needed by the app.
• A shipping API to provide delivery services to customers.
• An inventory API to sync inventory across multiple stores and warehouses.
• A review API to record customer reviews of the products.

By using these APIs and developing your own front-end code, you can create an online shopping mall application that will make it easier for customers to order products from multiple stores.

How to Design a Tax Rate Calculator Tool

For your next project, why not try designing a tax rate calculator tool for personal use?

With taxes varying from country to country and state to state, it can be confusing to accurately calculate your tax rate.

You'll need an API, like TaxJar's SalesTax API, that provides up-to-date information about local sales taxes for products and services.

With basic HTML, CSS, JavaScript and API knowledge, you can create a fully functional tax rate calculator tool. Not only will this be helpful to users, but it also offers great practice development experience for developers.

How to Develop an Image Editing App

Developing an image editing web application can be quite a bit of work, but there are many APIs that can help you simplify some of the processes like adjusting contrast, resizing an image, or making some quick image edits.

If you're thinking of developing your own image editor, here are some resources:

• You can use ImageMagick's Image Processing API to manipulate and transform images.
• You can use Azure Computer Vision's APIs to add text overlays on images.
• You can use Slazzer's Remove Background API to clear up any unwanted background noise or add this feature if necessary.
• Everypixel Image Collage API helps you create customized photo collages.

How to Create an Online Video Conferencing App

Video conferencing apps are becoming more and more popular as they provide us with an easy way to stay connected, no matter the distance.

It's possible to build your own video conferencing app with the help of APIs, and a bit of coding know-how.

To begin with, you'll need an API that provides the video conferencing feature, such as the Twilio Video API.

You'll also need an API for authentication such as the Auth0 API.

With these two APIs combined, you can make an app that allows users to securely register and log in, and then start a video call with their contacts.

How to Build a Real Estate Management System

Building a real estate management system to keep track of your properties sounds like a great project idea, don't you agree?

By combining different APIs, you can assemble a system that would help you efficiently manage and maintain your investments.

You can use the Google Maps API to acquire geographical info regarding your properties and store it in the database.

Also, with the assistance of APIs such as the Zillow API or the Trulia API, you can get accurate pricing info for similar properties located in particular areas.

This is beneficial when it comes to getting the market value of your properties.

Lastly, the Google Calendar API or the Microsoft Outlook API can be utilized to generate automated notifications when collecting rent payments from tenants.

In summary, merging these APIs can help you create an effective real estate management system that saves time and money while properly organizing your properties!

How to Build an Event Planning Organizer Tool

Organizers looking to plan events of all sizes – from birthdays to weddings, and corporate gatherings – need help managing the tasks associated with them.

An event planning app provides a great tool for this, giving users deadlines and reminders as they work to prepare for the occasion.

• Using Google Calendar and the Trello API, it's possible to provide calendar integration features that pull in event details and allow users to sync between multiple platforms.
• The Trello API also helps users keep track of tasks both before and after an event, creating lists that outline what needs to be accomplished.
• Each task can be assigned a due date and a priority level, so that you can be sure nothing is missed or overlooked before the big day arrives.

You can also set up a notification feature for users, letting them know when a task needs attention or providing them with helpful reminders regarding upcoming deadlines.

All of these features combined would make your tool a useful resource for any type of event planner or organizer.

Conclusion

You can develop your skills and knowledge as a programmer by building some basic projects. With the help of the APIs and project ideas presented in this article, you can build some interesting projects and enhance your development journey.

APIs can be intimidating at first, but with constant practice, you'll get used to working with them. And as your programming skills grow, you’ll be able to push the boundaries and explore more possibilities.

Happy coding!

Read more on APIs:

• Public APIs for Developers
• API Testing Best Practices – How to Test APIs for Beginners
• Use React and APIs to Build a Weather App

It's natural to get excited about launching something new, but it's also important to remember the basics of website security. As a developer, you know it’s important to protect your web app from malicious users, attackers, hackers, and other cyber threats.

You've put in a lot of hard work building the perfect user experience and now it's time to keep it secure.

In this tutorial, we'll walk through some simple yet powerful strategies that help you protect your PWA. Let’s get started!

What is a PWA?

PWA Illustration by undraw.co

Are you interested in bringing a native mobile app experience to your users without the headache of app development? Progressive Web App is the way.

PWAs are a type of web application that uses the latest web tech to deliver a user experience similar to that of a native mobile app.

They are built to take advantage of native mobile device features and work for apps regardless of whether the user has poor or no internet connection.

Additionally, PWAs are reliable, fast, and engaging — plus, they’re easier to develop and maintain than traditional apps.

The best part about PWAs is that they offer the same experience on all major browsers like Chrome, Firefox, Edge and Safari — so you don’t have to be concerned about compatibility issues.

Also, since PWAs don’t require installation from an app store, users don’t have to wait for their device manufacturer to approve or update them.

All these factors make PWAs ideal for businesses looking for cost-effective mobile solutions.

How to Secure a PWA

Authentication and Authorization in PWAs

authentication illustration by undraw.co

If you're building a Progressive Web App (PWA), you need to ensure that it is properly secured. In order to do this, you'll need to understand the basics of authentication and authorization.

Authentication is the process by which users prove their identity and verify that they have the proper authorization to access the app.

Authorization, on the other hand, ensures that those users have access only to areas and content that they are allowed to see, while enforcing restrictions on what they can do.

In order to implement effective authentication and authorization within your PWA, there are some best practices you should follow.

1. Firstly, use secure passwords that are difficult for hackers or bots to guess or crack, as well as two-factor authentication (2FA) for added security.
2. Secondly, use roles-based access control (RBAC) for authorization. This establishes user permissions based on roles which can be quickly adjusted when needed.
3. Lastly, use HTTPS with SSL/TLS encryption for all web traffic from your PWA. This will ensure that all data sent between clients and servers is encrypted, protecting user information from malicious actors.

It is important to keep in mind that authentication and authorization can also be vulnerable to attack by malicious users if not implemented correctly. So it is essential to stay aware of common attack vectors like SQL injection threats and cross-site scripting (XSS) attacks.

By implementing proper security measures such as input validation and penetration testing, you can protect your PWA from these threats.

How to Use HTTPS and SSL/TLS to Secure Your PWAs

HTTPs and SSL/TLS are two of the most important tools when it comes to securing PWAs.

Let's see what exactly they are:

What is HTTPS?

HTTPS stands for Hyper Text Transfer Protocol Secure. It's a protocol used for secure communication between a web server and a web browser, and is vital for protecting data from being intercepted by third parties.

To put it simply, HTTPS helps ensure that the data you send and receive from your PWA is always secure.

What is SSL/TLS?

SSL (Secure Sockets Layer) and TLS (Transport Layer Security) are cryptographic protocols that provide authentication, encryption and data integrity.

These protocols allow secure connections between web browsers, applications, and servers over the internet via an encrypted handshake process.

As such, they play an important role in ensuring that your web app's data remains safe and secure.

Best Practices for Implementing HTTPS and SSL/TLS in PWAs

To protect your PWA effectively, you should make sure that you're following some best practices for implementing HTTPS and SSL/TLS in PWAs:

1. Use HTTPS Everywhere: Make sure that all of your pages are served over HTTPS, rather than insecure HTTP connections. This will help ensure your users' data is protected while they're on your website or application.
2. Install an SSL Certificate: This will enable HTTPs connections on your site and provide authentication between the server hosting your PWA and the users visiting it.
3. Regularly Test Connections: Ensure that all of your connections are still secure by testing them regularly for any vulnerabilities or risks to security
4. Implement Certificate Pinning: Certificate pinning is an important security measure that involves binding a host domain to a specific SSL certificate. This prevents man-in-the-middle attacks and will help protect your PWA from malicious actors.
5. Keep Your Security Protocols Up to Date: Regularly update your web server's security protocols to ensure that you're always running the most secure version.
6. Configure Appropriate Firewall Rules: Configure your firewall rules to allow only secure connections and block any suspicious traffic. This will help protect your PWA from malicious attacks.

Once you've implemented these best practices, you can feel pretty confident that your PWA is as secure as possible.

But, security isn't just about preventing malicious attacks. It's about ensuring that your users' data is always kept safe and secure.

By taking the above steps, you can ensure that your PWA is always compliant with the latest security standards and guidelines. This will help protect your users' data from unauthorized access and potential security threats.

How to Protect against Cross-Site Scripting (XSS) and Cross-Site Request Forgery (CSRF)

Cross-site scripting and cross-site request forgery are both security threats that can cause serious damage to PWAs.

XSS works by injecting malicious code into the browser via a vulnerable web application.

This code can be used to exfiltrate data from the PWA, like passwords or credit card numbers, or to execute any other malicious code.

CSRF, on the other hand, is a form of attack that manipulates a user's browser into sending forged requests without them knowing.

This can be used to execute actions within an application, such as transferring money or deleting data.

Fortunately, there are steps you can take to protect your PWA against XSS and CSRF attacks:

• Sanitize all user input: Sanitizing user input is one of the best ways to protect against XSS and CSRF attacks. Make sure that you always validate and filter out any potentially harmful content before it’s added to your database.
• Use CAPTCHA protection: Adding CAPTCHA protection to web forms will help ensure that any requests from users are coming from real people rather than malicious bots or scripts.
• Use secure cookies: Secure cookies allow you to store data about your users in an encrypted format and limit access only to authorized users. This can help make sure that data isn’t exposed in case of a compromise.

By taking these steps, you can help protect your PWA against XSS and CSRF attacks.

How to Develop a Content Security Policy (CSP)

Content Security Policy (CSP) is an important web security mechanism designed to prevent malicious attacks.

To put it simply, a CSP is a set of rules that specify what sources are allowed when loading resources such as scripts, images, and stylesheets. By defining the sources of these content types, CSP helps protect your applications from cross-site scripting (XSS) and data injection attacks.

By implementing a CSP on your PWA, you can add an extra layer of protection against malicious attacks.

Some best practices for implementing CSP include:

• Defining allowed origins: This makes sure that only authorized sources can access content on your application.
• Whitelisting inline styles: When possible, use the nonce attribute to whitelist specific inline scripts and styles so that the code is only executed if the nonce matches what is specified in the policy.
• Disallowing unsafe methods: Include a directive that blocks dangerous methods such as eval() in order to protect against code injection attacks.
• Setting up reporting/logging: Configure reporting/logging so you can track incoming requests and flag any suspicious activity.

By following these best practices and setting up CSP properly, you can effectively protect your PWAs from malicious attacks while ensuring they remain secure and performant.

Conclusion

In short, if you want to keep your web app secure, it’s important to follow best practice security protocols such as robust authentication and encryption, regular security patch updates, and secure APIs. It's also essential to have a secure development process in place to ensure that only the most secure code is being deployed.

Finally, user education is key when it comes to web apps. Providing users with a secure platform is only half the battle, as ultimately it’s up to the user to stay vigilant about their online security.

Read more on PWAs:

• What is a PWA? Progressive Web Apps for Beginners
• How to build a PWA from scratch with HTML, CSS, and JavaScript