Forem: Sujit Mali

A real-world walkthrough of regression using coffee, code, and actual data

Sujit Mali — Wed, 20 May 2026 17:36:04 +0000

I failed my first stats class in college.

Not because the math was hard. Because every example in the textbook was about iris flowers or Boston housing prices and I couldn't figure out why anyone in real life would care. So the formulas just slid off my brain.

Years later, I'm a backend dev in Mumbai with a serious filter coffee habit and an even more serious sleep deficit. One Sunday morning, somewhere between my second tumbler of decoction and a half-broken Saturday deploy, I asked myself a question I could actually feel in my body: does more coffee actually mean I write more code?

That question is what finally taught me linear regression. Not the textbook. Not the YouTube playlist. A Google Sheet, my git log, and 30 cups of filter coffee.

Here's the whole thing, including the math by hand, the part where I got it wrong, and the Python at the end.

The setup (and why I think most tutorials skip it)

Every linear regression tutorial I'd ever opened started with this line:

y = mx + b

And then immediately jumped into matrices. Cool. Useless.

The thing tutorials skip is what problem are you even trying to solve. Linear regression is, at its core, one question:

If I know X, can I make a reasonable guess at Y?

That's it. If I know the size of a flat in Malad, can I guess the rent? If I know how many standup minutes I sat through, can I guess how many I actually retained? If I know how much coffee I drank today, can I guess how many lines of code I'll commit?

I'm going to answer that last one.

The data I actually collected

For 30 weekdays I tracked two numbers:

X: cups of filter coffee I drank that day (one tumbler = one cup, no chai counted)
Y: lines of code I committed that day (net additions, from git log --shortstat)

Here are the first 10 rows. The full 30 are at the bottom of this post if you want to play with them yourself.

Day	Coffees (X)	Lines of code (Y)
1	2	142
2	4	287
3	1	95
4	3	210
5	5	305
6	2	160
7	0	40
8	4	250
9	3	195
10	6	360

Before doing any math, Before doing any math, I dropped the numbers into a scatter plot maker and just sat with it for a minute. You should always do this first. Eyeballs are a free regression model.
and just looked at it. You should always do this first. Eyeballs are a free regression model.

What I saw: a clear-ish upward smear. Not a perfect line — day 5 (5 coffees → 305 lines) and day 10 (6 coffees → 360 lines) sit a bit off the trend, and day 7 (zero coffee, 40 lines) was the day there was a 4-hour power cut and I worked off my laptop battery in a café. But overall, more coffee, more code.

That smear is what linear regression turns into a number.

What we're actually trying to find

We want to draw the single straight line that fits this cloud of points as well as possible.

A line has two parts:

Slope (m): how many lines of code does one extra cup of coffee buy me?
Intercept (b): how many lines of code do I write on a day with zero coffee?

If I find good values for m and b, then for any future day, I can plug in my coffee count and get a prediction.

But "fits as well as possible" — what does that mean? This is the bit that took me embarrassingly long to internalize.

The "least squares" idea, explained without the squares

Imagine I draw a random line through the cloud. For each real data point, there's a gap between where the point actually is and where my line thinks it should be. That gap is called the residual — basically, how wrong the line was for that day.

If I add up all those gaps, I get a "total wrongness" score. The best line is the one with the smallest score.

One catch: some gaps are positive (line predicted too low), some are negative (predicted too high). If you just add them, they cancel each other out and you get a line that looks correct on paper but is actually terrible.

The fix is to square each gap before adding them. Negatives become positives, big mistakes get punished more than small ones, and now you have a real "wrongness" number worth minimizing.

That's why it's called least squares regression. We're picking the line that makes the sum of squared gaps as small as possible.

That's the whole intuition. The formulas below are just the calculus result of "find the m and b that minimize that sum."

Doing it by hand on 5 data points

Let me use just 5 points so the numbers stay sane:

X	Y
2	142
4	287
1	95
3	210
5	305

Step 1: averages.

Mean of X: (2+4+1+3+5)/5 = 3
Mean of Y: (142+287+95+210+305)/5 = 207.8

Step 2: deviations and products.

For each row I compute (X - meanX), (Y - meanY), their product, and (X - meanX)².

X	Y	X − 3	Y − 207.8	product	(X−3)²
2	142	−1	−65.8	65.8	1
4	287	1	79.2	79.2	1
1	95	−2	−112.8	225.6	4
3	210	0	2.2	0	0
5	305	2	97.2	194.4	4

Sums: products = 565.0, squared deviations = 10.

Step 3: slope.

m = sum of products / sum of squared deviations
m = 565 / 10
m = 56.5

Step 4: intercept.

b = meanY - m * meanX
b = 207.8 - 56.5 * 3
b = 207.8 - 169.5
b = 38.3

So my fitted line is:

lines_of_code ≈ 56.5 * coffees + 38.3

Read in English: every extra cup of coffee buys me ~56 more lines of code, and on a zero-coffee day I'd still grind out about 38 lines. That intercept matches my power-cut day pretty well (40 lines).

I checked this against an online linear regression calculator and got the same numbers, which was nice — I'd been low-key worried I'd dropped a sign somewhere. (When you're learning this, do the by-hand version and then verify with a tool. Two methods agreeing is how you know you actually understand it, not just memorized it.)

The mistake I made the first time

When I ran this on all 30 days, I got a slope of about 53 and an intercept of about 42. Close enough.

But then I made a prediction:

"If I drink 15 cups of coffee, I'll write 53 × 15 + 42 = 837 lines of code."

This is wrong, and it's wrong in a way that's worth understanding. My data only ranged from 0 to 6 cups of coffee. Predicting for 15 cups is called extrapolation, and a linear model has no idea that at 15 cups I would actually be in the ER, not in VS Code.

The relationship is probably linear-ish in the range I measured. Outside that range, all bets are off. Most real-world relationships curve, plateau, or break at some point. Linear regression is a local approximation, not a universal law.

This is the most common mistake I see beginners make, and honestly it's the most common mistake I see in production dashboards too. "Our user growth was linear for six months, so we'll hit ten lakh users by Q4." No you won't.

How good is my line, actually?

A line that's "best" can still be terrible. Imagine if my data were a random cloud — there'd still be a best line, but it would predict nothing useful.

The standard score for this is R² (pronounced "R squared"). It's a number between 0 and 1:

R² = 1: the line passes through every point. Perfect.
R² = 0: the line is no better than just guessing the average.
R² = 0.7: the line explains about 70% of the variation in Y.

For my 30-day coffee experiment, R² came out to about 0.89. That's strong — coffee really does seem to track my coding output. But correlation isn't causation, and here's where I have to be honest: on high-coffee days I was probably also more rested, more motivated, and not stuck in a 90-minute Outer Ring Road jam. The coffee might be a side effect of a productive day, not the cause of one.

Linear regression will happily fit a line. It will not tell you what causes what. That's your job.

The Python version (5 lines)

Once you understand what's happening, the code is almost a letdown:

import numpy as np

x = np.array([2, 4, 1, 3, 5, 2, 0, 4, 3, 6])
y = np.array([142, 287, 95, 210, 305, 160, 40, 250, 195, 360])

slope, intercept = np.polyfit(x, y, 1)
print(f"y = {slope:.1f}x + {intercept:.1f}")

If you want R² and the rest of the diagnostics, scipy.stats.linregress is the friendlier version:

from scipy.stats import linregress

result = linregress(x, y)
print(f"slope: {result.slope:.2f}")
print(f"intercept: {result.intercept:.2f}")
print(f"r-squared: {result.rvalue**2:.3f}")
print(f"p-value: {result.pvalue:.4f}")

The p-value is asking: "what's the chance this slope is just noise?" Anything under 0.05 is the traditional cutoff for "probably real." Mine came in at 1e-14, which means: almost certainly not a coincidence. (Doesn't mean coffee causes code. Just means the relationship is real, whatever it is.)

When to reach for linear regression in real life

Honestly, more often than you'd think. Some boring-but-genuinely-useful examples from my own work:

Estimating ticket resolution time from ticket length. Helps with sprint planning.
Predicting cloud bill from monthly active users. Helps when pricing a new tier — and trust me, the finance team will ask.
Figuring out at what page-load speed users start churning on a landing page. The slope tells you how many sign-ups each extra 100ms costs.
Calibrating a sensor. If your IoT temperature reading drifts linearly off a reference thermometer, regression gives you the correction formula in two lines of Python.

The pattern is always the same: you have an X you can measure cheaply, and a Y you actually care about, and you want a quick "if I move the dial on X by this much, what happens to Y?"

It is not magic. It is a ruler. But it's a ruler that knows about uncertainty, which is more than most rulers can claim.

What to try this week

If you want this to actually stick, don't just read it. Pick something annoying in your life that has two numbers attached to it, and track it for two weeks.

Some ideas to steal:

Hours of sleep vs. time-to-first-coffee (or chai) the next morning
Number of standup attendees vs. how long it actually ran
PRs opened that day vs. PRs you reviewed
Daily commute minutes vs. how cranky you felt at the 6 PM standup

Plug it into any regression tool (I obviously used this one), look at the slope, and ask: does this number match my gut? If yes, you've quantified your intuition. If no, you've found something interesting.

That's the whole point of stats, when you strip away the textbook flavor. It's a tool for arguing with your own assumptions.

The full dataset

If you want to reproduce what I got, here's all 30 days:

coffees = [2,4,1,3,5,2,0,4,3,6,2,3,4,1,5,3,2,4,5,1,3,4,2,6,3,4,2,5,3,4]
lines   = [142,287,95,210,305,160,40,250,195,360,170,225,260,80,330,
           205,150,265,310,90,200,255,165,355,200,270,155,315,210,275]

Drop those into the snippet above. You should get a slope around 53, intercept around 42, R² around 0.89.

And then go track something of your own. That's when it actually clicks.

If you spot a math mistake, please yell at me in the comments. I'd rather be embarrassed than wrong.

Scatter Plots: The "By Hand" Method vs. The 30-Second Shortcut

Sujit Mali — Mon, 08 Dec 2025 06:14:29 +0000

If you work with data in Python, matplotlib is basically muscle memory at this point. It is the grandfather of Python visualization libraries - powerful, flexible, and capable of doing almost anything if you have enough patience.

But let’s be honest: sometimes you don't want to write 20 lines of code just to see if two columns of data are correlated.

I wanted to share a quick refresher on the "standard" way to build a production-ready scatter plot in Matplotlib, and then share a quick browser-based utility I found for when you just need the chart now without firing up a Jupyter Notebook.

Part 1: The Matplotlib Way

If you are building a pipeline or need something highly reproducible, you have to code it. Here is the boilerplate I use to get a scatter plot that doesn't look like it was made in 1995.

We need to handle the data, the labels, the alpha (transparency), and the grid manually.

import matplotlib.pyplot as plt
import numpy as np

# 1. Generate some dummy data
# Let's pretend this is "Page Load Time" vs "User Bounce Rate"
np.random.seed(42)
x = np.random.rand(50) * 10
y = 2 * x + 1 + np.random.randn(50) * 2  # Positive correlation with noise

# 2. Create the figure
plt.figure(figsize=(10, 6))

# 3. The Scatter Plot command
# We add 'alpha' because overlapping points are misleading
# We add 'edgecolors' to make the dots pop
plt.scatter(x, y, color='dodgerblue', alpha=0.7, edgecolors='k', s=100)

# 4. The Styling (The part we always forget)
plt.title('Page Load Time vs. Bounce Rate', fontsize=16)
plt.xlabel('Load Time (seconds)', fontsize=12)
plt.ylabel('Bounce Rate (%)', fontsize=12)
plt.grid(True, linestyle='--', alpha=0.5)

# 5. Show it
plt.show()

It works perfectly. But, to get that image, I had to:

Spin up my environment.
Remember the syntax for figsize (is it width, height or height, width?).
Google how to set the transparency of the grid lines again.

Part 2: The "I Just Need a PNG" Way

Sometimes, I’m just chatting with a PM or a client, and I have a CSV file. I don't want to open VS Code. I just want to visualize the relationship instantly.

For those moments, I stopped coding it.

I started using this Scatter Plot Maker

It’s effectively a wrapper for the visualization process but without the coding overhead.

You paste your data.
It handles the axis scaling automatically.
You get the downloadable image.

I timed it: The Python script took me about 4 minutes to write and debug (mostly formatting the axis labels). The online tool took about 45 seconds.

The Verdict?

If you are building a dashboard for a client? Stick to Python. If you just need to visualize a dataset for a presentation, a Slack message, or a quick sanity check? Save your brain cells and use the generator.

Do you guys have any other "no-code" tools you use to skip the boilerplate? Let me know in the comments.

How to import and export functions in JavaScript ?

Sujit Mali — Wed, 15 Feb 2023 06:34:00 +0000

In this blog, we will discuss how to import and export functions in JavaScript.

In JavaScript, there are different ways to import and export functions. Here are 2 common ways:

Default Export
Named Exports

1. Default Export

// greet.js 
export default function greet(name) {  // EXPORT
  console.log(`Hello, ${name}!`);
}

// app.js
import greet from './greet.js';  // IMPORT
greet('Sam');

In this example, we're exporting a function using the export default syntax. This allows us to import the function using any name we want in the importing file, and it doesn't require us to use curly braces when importing.

NOTE: The export default syntax allows you to export only a single value from a module as the default export.

2. Named Exports

// math.js
export function add(a, b) {            // EXPORT
  return a + b;
}

export function subtract(a, b) {      // EXPORT
  return a - b;
}

// app.js
import { add, subtract } from './math.js'; // IMPORTS
console.log(add(3, 4));
console.log(subtract(5, 2));

In this example, we're exporting two functions (add and subtract) using the named exports syntax. To import these functions, we need to use curly braces and specify the names of the functions we want to import.

NOTE: While importing, the Name of the function should be the same as defined.

OR
Export all function in one line.

// math.js
function add(a, b) { 
  return a + b;
}

function subtract(a, b) {      
  return a - b;
}

export { add, subtract };      // EXPORT ALL FUNTION IN ONE LINE

// app.js
import { add, subtract } from './math.js'; // IMPORT

console.log(add(2, 3));
console.log(subtract(5, 3));

How to make a line graph in google sheets?

Sujit Mali — Fri, 20 Jan 2023 09:59:28 +0000

To make a line graph in Google Sheets, follow these steps:

Step 1: Enter the data

Enter your data in your sheets.
E.g

Step 2: Select the data

The second step after the step 1 is to selecting the data.

Step 3: Click on Insert Chart

Click on "Insert Chart" at top toolbar.

Step 4: Select the line chart.

Select the chart you want to create.

Step 5: Customize

Final step customize your chart such as Color, Point, Legend, Axis and Text.

Step 6: Download

First select your graph and click on three dots.

Finally download your graph as png, svg or pdf format.

OR
You can try line graph maker to create graph easily.

How to read a histogram?

Sujit Mali — Fri, 20 Jan 2023 06:55:24 +0000

A histogram is a graphical representation of the distribution of a dataset. It is an estimate of the probability distribution of a continuous variable. To read a histogram in detail, you should pay attention to the following elements:

The x-axis represents the variable of interest, while the y-axis represents the frequency of that variable.
The bars of the histogram show the frequency of observations within each class or bin. The height of each bar corresponds to the number of observations that fall within the corresponding class.
The shape of the histogram can reveal information about the distribution of the data. For example, a symmetric histogram with a bell-shaped curve indicates a normal distribution, while a histogram with a long tail to the right or left indicates a skewed distribution.
The number of classes or bins can also be important. A histogram with too few classes can make the data appear more variable than it really is, while a histogram with too many classes can make the data appear less variable than it really is.
The histogram can also be used to identify patterns or outliers in the data by looking for gaps or clusters in the distribution.

Finally, it is important to keep in mind that histograms are just one way of visualizing data, and other types of plots such as box plots, scatter plots, etc might be better suited depending on the context and the question you want to answer.
You can create histogram easily using histogram maker.