A Deep Dive into Arrays – Part 1: What, Why & How

Ananya Kallankudlu — Tue, 10 Jun 2025 10:59:20 +0000

🔹 What's an Array?

An array is a data structure that holds multiple values of the same data type in contiguous memory locations.
Let’s break this down:

What’s a Data Structure? A data structure is a specific way of storing and accessing data in a computer so it can be used efficiently. Common operations: Read, Write, Update, Delete.
We choose different data structures based on our needs. Some examples:
- Arrays (specifically 2D arrays or matrices) are used to represent pixels in an image. Since array elements are stored in contiguous memory, accessing them is very fast — something that's critical in graphics rendering.
- Trees are a natural choice for implementing file systems. Folders nested within folders can be best modeled as trees, with the root folder at the top.

🔹 Why Arrays?

Arrays are optimized for locality of reference — a key concept in making memory access fast.

Locality of Reference:

This refers to the tendency of programs to access:

Recently used memory locations → called Temporal Locality
Nearby memory locations → called Spatial Locality

These patterns are utilized by:

The CPU: When the CPU fetches data from memory, it also fetches nearby memory locations, anticipating future access.
Programmers: Take an image processing task where pixels are stored in a matrix (2D array). In most programming languages, matrices are stored in row-major order, meaning all columns of row 1 are stored first, then row 2, and so on.
So consider this code:
```
        for col in range(N):
            for row in range(N):
                sum += matrix[row][col]
```
This accesses data column-first, skipping memory in the way it’s laid out, leading to cache misses. A better approach would be to access data row-first.

🚀 Why arrays are fast:

Array elements are stored contiguously (spatial locality).
When you access array[0], the CPU preloads array[1], array[2], etc., into the CPU cache.
This makes index-based access blazing fast. Hence, arrays are ideal when:
You need to store large amounts of data of the same type
You need to perform common operations across all elements, like scaling pixels in an image.

🔹 Here's a mind map of everything I just learned — what’s yours?

Next Up:

Dynamic arrays — what happens when we want to grow or shrink arrays on the fly?

Hope you enjoyed reading!

Let me know if something wasn’t clear or if you’ve got a better mental model!

Mail-minders: a zero-UI task assistant in your inbox

Ananya Kallankudlu — Wed, 04 Jun 2025 07:20:18 +0000

This is a submission for the Postmark Challenge: Inbox Innovators.

What I Built

Mail-minders is a fully email-based task reminder system — no apps, no dashboards, just your inbox. Users interact with Mail-minders entirely through email:

Send an email with subject START to get onboarding instructions.
Compose an email with the subject ADD, using the format provided in the onboarding email, to submit your task reminders.
Mail-minders automatically reminds users of pending tasks.
Users can mark tasks as complete or add new ones by replying to reminder emails.
Send an email with the subject LIST to get a snapshot of all your current tasks.
Send ANALYZE to receive a visual summary (bar and pie charts) of your categorized tasks.

TL;DR High Level Flow:

Demo

Try it out:

Just shoot out an email to reminders@mailminders.tech with the subject START and wait for your instructions.
Follow the instructions in the onboarding email.
Submit tasks, wait for reminders, and reply to mark them done.

No UI. No login. Just email.

Sample Screenshots:

Inbox showing onboarding email:

Task Analysis Email (Bar & Pie Charts) — Sent when you email with subject ANALYZE:

Code Repository

Here is the link to the Github repository.

How I Built It

Mail-minders is built with:

Next.js — Handles incoming webhook requests from Postmark.
Supabase — Stores user's email-ID and tasks along with their categories.
Postmark — Powers all email communication (inbound + outbound)
Postmark templates — For the emails themselves
Python (FastAPI) — Generates bar and pie chart images for task summaries.
Render— Hosts the backend services, including the webhook and the cron job for daily reminders. (The cron job is implemented here but not configured to run because of Postmark's limit of 100 emails with the free trial)
Hugging Face Spaces — Hosts the task categorization fast-API, which uses the all-MiniLM-L6-v2 model from sentence-transformers to generate embeddings and classify tasks by similarity.

Postmark’s reliable delivery, easy to use email templates, and efficient inbound processing made it possible to build a complete experience using just email. Embedding-based classification added a layer of intelligence, allowing users to get structured insights.

Future Possibilities

Along with charts that show task summaries by categories, support for the following statistics may be added:

Basic Task Completion Metrics

Total tasks created
Total tasks completed
Task completion rate

Time-Based Analysis

Average time to complete a task
Median time to complete a task
Fastest completed task (shortest duration)
Longest completed task (longest duration)

Daily & Weekly Patterns

Most productive day of the week
Least productive day
Average number of tasks completed per day

Achievement Highlights

Fastest streak (most tasks completed back-to-back in under an hour)
Best day (day with most tasks completed)

This was a solo submission, built from scratch during the challenge.

Thanks to

Dev.to for hosting this hackathon
Postmark for sponsoring it.
AI tools for helping with the coding, building and learning along the way.

Forem: Ananya Kallankudlu