DEV Community: Devanshu Biswas

OrderHub Day 5: Clean Error Handling With RFC-7807 ProblemDetail (Spring Boot)

Devanshu Biswas — Wed, 24 Jun 2026 14:54:38 +0000

OrderHub Day 5: stop returning ugly, inconsistent errors. Today every failure — validation, not-found, bad state, or an unexpected crash — comes back in ONE standard, machine-readable shape: RFC-7807 ProblemDetail. One @RestControllerAdvice does it all.

🚧 See every error shape: https://dev48v.infy.uk/orderhub/day5-exception-handling.html

The problem with scattered try/catch

Handle errors in each controller and you get inconsistent JSON, leaked stack traces, and duplicated code. Centralize it instead.

One advice, RFC-7807 everywhere

Spring Boot 3 has ProblemDetail built in. A single @RestControllerAdvice maps exceptions to a consistent envelope (type, title, status, detail, instance, + extensions):

MethodArgumentNotValidException → 400 + an errors field→message map
OrderNotFoundException → 404
IllegalStateException (confirming an already-confirmed order) → 409 Conflict
any other Exception → 500 with a generic message — never leak the stack trace

Let exceptions flow

The trick: don't swallow errors in controllers. The service throws a domain exception (OrderNotFoundException), it propagates up, and the advice turns it into the right status. Controllers stay clean; the web layer owns HTTP, the service owns domain rules.

🔨 Full walkthrough (@RestControllerAdvice → ProblemDetail → 400/404/409/500, no leaks) on the page: https://dev48v.infy.uk/orderhub/day5-exception-handling.html

OrderHub — a production-grade Spring Boot backend, one feature a day.
🌐 https://dev48v.infy.uk · Code: https://github.com/dev48v/order-hub-from-zero

RAG Explained: Give an LLM Your Own Knowledge

Devanshu Biswas — Wed, 24 Jun 2026 14:53:55 +0000

An LLM doesn't know your company's docs, last week's news, or your private data — and it'll confidently make things up. RAG fixes that: retrieve the relevant facts, put them in the prompt, then generate. It's the backbone of almost every real LLM app. Here's the full pipeline, live.

📚 See it answer from a private knowledge base: https://dev48v.infy.uk/ai/days/day15-rag.html

Retrieve → Augment → Generate

Embed the question into a vector (last two posts: embeddings + vector DBs).
Retrieve the top-k most similar chunks from your knowledge base.
Augment the prompt: system instructions + the retrieved chunks as context + the question.
Generate — the model answers grounded in those chunks, and can cite them.

In the demo, flip RAG off and the bare model hallucinates or refuses — it never saw your data. Flip it on and the answer is correct and sourced.

Two pipelines

Offline (indexing): chunk your docs → embed → store in a vector DB.
Online (querying): embed question → search → build prompt → generate.

RAG vs fine-tuning

RAG adds knowledge (fresh, private, citable) without retraining. Fine-tuning changes behavior/style. Most teams reach for RAG first.

Where it breaks

Bad retrieval → bad answer. That's why reranking, HyDE, and Corrective-RAG (earlier posts) exist — they all make the retrieve step better.

🔨 Build it (chunk → embed → upsert → retrieve top-k → augment → generate + cite) on the page: https://dev48v.infy.uk/ai/days/day15-rag.html

Part of AIFromZero. 🌐 https://dev48v.infy.uk

Diffusion Models Explained: Turning Noise Into Images

Devanshu Biswas — Wed, 24 Jun 2026 14:53:13 +0000

GANs (yesterday) make images with two networks fighting. Diffusion models — what actually powers Stable Diffusion, DALL·E, and Midjourney — do it differently and far more stably: they learn to turn noise into images, one denoising step at a time. Here's the process, visualized.

🌫️ Scrub the noise → image chain: https://dev48v.infy.uk/dl/day15-diffusion.html

Two processes

Forward (fixed, no learning): take a real image and add a little Gaussian noise, over and over, for T steps — until it's pure static.
Reverse (the learned part): train a network to undo one noise step. Run it backward from pure noise and an image emerges.

What the network actually predicts

Not the image — the noise that was added at each step. Subtract the predicted noise, repeat. The training loss is just MSE between predicted and actual noise. That simplicity is why diffusion trains so much more stably than GANs (no adversarial game, no mode collapse).

How you steer it

Text-to-image conditions the denoiser on a prompt (via cross-attention), and "latent diffusion" runs the whole thing in a compressed latent space for speed — that's the Stable Diffusion recipe.

GANs vs diffusion

GANs: fast to sample, tricky to train. Diffusion: stable to train, slower to sample (many steps) — though that gap keeps closing.

🔨 Full picture (forward noising → train to predict noise → sample by denoising) on the page: https://dev48v.infy.uk/dl/day15-diffusion.html

Part of DeepLearningFromZero. 🌐 https://dev48v.infy.uk

Gradient Boosting From Scratch: Weak Trees Fixing Each Other

Devanshu Biswas — Wed, 24 Jun 2026 14:52:32 +0000

Random forests build many trees in parallel and average them. Gradient boosting builds trees one at a time, each one fixing the previous trees' mistakes — and it's what wins most Kaggle competitions on tabular data. Here it is, fitting residuals live.

🌲 Watch it boost (add trees one by one): https://dev48v.infy.uk/ml/day15-gradient-boosting.html

The core loop

Start with a constant prediction (the mean).
Compute the residuals — how far off you are at each point.
Fit a small, shallow tree to those residuals.
Add it to the ensemble, scaled by a learning rate.
Repeat. Each tree chips away at the remaining error.

In the demo you watch the prediction curve bend toward the data and the residual bars shrink while the MSE drops every round.

Forest vs boosting

Random forest: independent trees, built in parallel, averaged. Reduces variance.
Boosting: dependent trees, built sequentially, summed. Reduces bias by correcting errors.

Learning rate = shrinkage

Small steps (e.g. 0.1) generalize better than big ones — but need more trees. Too many trees / too high a rate → overfitting, so use early stopping.

The "gradient" part: fitting residuals is just gradient descent on squared error; swap the loss and it generalizes (that's XGBoost / LightGBM / CatBoost).

🔨 Built from scratch (mean → residuals → tree → add lr×tree → repeat) on the page: https://dev48v.infy.uk/ml/day15-gradient-boosting.html

Part of MachineLearningFromZero. 🌐 https://dev48v.infy.uk

I Built a JSON Formatter & Validator in the Browser (No Library)

Devanshu Biswas — Wed, 24 Jun 2026 14:51:50 +0000

A JSON formatter sounds like a weekend project — and it is, because the browser does the hard part. Here's a live formatter + validator with syntax highlighting and real error locations, no library.

🧾 Try it (paste JSON): https://dev48v.infy.uk/solve/day15-json-formatter.html

Format = parse then re-stringify

const obj = JSON.parse(input);          // validate (throws if invalid)
const pretty = JSON.stringify(obj, null, 2);  // 2-space indent

That's the entire formatter. JSON.stringify(obj) with no third arg gives you minify for free.

Validation is "did parse throw?"

Wrap JSON.parse in try/catch. On failure, the error message often includes a position — turn that into a line/column and show the offending snippet, so the user sees where it broke (trailing comma, single quotes, unquoted key — the usual suspects).

Syntax highlighting

Tokenize the pretty output with a regex and wrap keys / strings / numbers / booleans / null in colored spans. ~15 lines.

One safety rule

Never eval() JSON. JSON.parse is safe; eval runs arbitrary code.

🔨 Full build (parse → stringify → highlight → minify → error position) on the page: https://dev48v.infy.uk/solve/day15-json-formatter.html

Part of SolveFromZero. 🌐 https://dev48v.infy.uk

Chain-of-Verification: Make an LLM Fact-Check Itself

Devanshu Biswas — Wed, 24 Jun 2026 14:51:07 +0000

LLMs state wrong facts with total confidence. Chain-of-Verification (CoVe) is a prompting pattern that makes the model catch its own mistakes — by drafting, then fact-checking each claim independently, then revising. Here's a live walkthrough.

🔬 Watch it catch a wrong fact: https://dev48v.infy.uk/prompt/day15-chain-of-verification.html

Four stages

Draft — the model answers normally (e.g. "5 politicians born in NYC"). One entry is subtly wrong.
Plan — it generates one verification question per claim ("Was X born in NYC?").
Verify independently — it answers each question in a fresh context. This independence is the whole trick: if it re-checked while staring at its draft, it'd just repeat the error ("snowballing").
Revise — it regenerates the answer, dropping/fixing whatever failed verification.

Why it works

Splitting one big claim into small, isolated checks turns "sound confident" into "answer this single fact." Small factual questions are much easier to get right, so the revision is grounded in verified pieces.

The cost

Several LLM calls per answer — worth it for fact- and list-heavy responses, overkill for casual chat.

🔨 Full pattern (draft → plan questions → answer independently → revise) on the page: https://dev48v.infy.uk/prompt/day15-chain-of-verification.html

Part of PromptFromZero. 🌐 https://dev48v.infy.uk

I Built a Drag-and-Drop Kanban Board With Zero Libraries

Devanshu Biswas — Wed, 24 Jun 2026 14:50:25 +0000

Trello, Linear, Jira — they all have the same draggable board. You can build it with zero libraries using the browser's native HTML5 Drag and Drop API. Here's a live Kanban with cards you drag between columns.

🗂️ Try it (drag the cards): https://dev48v.infy.uk/design/day15-kanban-board.html

The native DnD lifecycle

Mark a card draggable="true".
On dragstart, stash the card's id in dataTransfer.
On the column's dragover, call preventDefault() — this is the #1 gotcha: without it, the element is not a valid drop target and nothing happens.
On drop, read the id, move the DOM node into that column, and update your model.

State vs DOM

Move the node for instant feedback, but keep a small data model (which card is in which column) as the source of truth — then re-render counts from it and persist to localStorage. Don't let the DOM be your database.

The caveats

Native DnD has no touch support (mobile needs Pointer Events or a lib like dnd-kit) and weak accessibility — fine for learning the mechanics, reach for a library in production.

🔨 Full build (draggable → dragstart/dataTransfer → dragover preventDefault → drop → persist) on the page: https://dev48v.infy.uk/design/day15-kanban-board.html

Part of DesignFromZero. 🌐 https://dev48v.infy.uk

I Built Doodle Jump in Vanilla JS (the Endless Bouncer)

Devanshu Biswas — Wed, 24 Jun 2026 14:49:43 +0000

Doodle Jump is the classic "go up forever" game — and it teaches one idea every platformer needs: instead of moving the player up, you move the world down. Here's a playable build in vanilla JS + canvas.

🦘 Play it (←/→ to steer): https://dev48v.infy.uk/game/day15-doodle-jump.html

The bounce is automatic

There's no jump button. Every time the character lands on a platform (detected only while falling, vy > 0), you set its velocity to a fixed upward value. Gravity pulls it back down, it lands, it springs again. Your only job is steering left/right — with screen-edge wrap.

The camera trick

The player never actually rises past the middle of the screen. When it climbs above a threshold, you scroll everything else down by that amount and add the distance to the score. It feels like flying up; really the world is sliding down.

Endless platforms

As platforms scroll off the bottom you remove them, and you spawn fresh ones above with slightly random spacing (wider as the score grows = harder). Miss them all, fall off the bottom → game over.

🔨 Full build (loop → gravity/bounce → collision-on-descent → camera scroll → spawn/cull → score) on the page: https://dev48v.infy.uk/game/day15-doodle-jump.html

Part of GameFromZero. 🌐 https://dev48v.infy.uk

OrderHub Day 4: Bean Validation + Clean DTOs (Spring Boot)

Devanshu Biswas — Tue, 23 Jun 2026 06:17:34 +0000

OrderHub Day 4: never trust the client. Today the backend gets proper Bean Validation — bad requests are rejected at the edge with a clear 400, long before they reach the business logic. And it's all declarative.

✅ Try the validating form (see the 400 body): https://dev48v.infy.uk/orderhub/day4-validation.html

Three DTOs, three jobs

A common beginner mistake is using one class everywhere. OrderHub keeps them separate:

Request DTO (CreateOrderRequest) — what the client sends, and where validation lives.
Domain/Entity (Order) — the internal model.
Response DTO (OrderResponse) — what the API returns, so internal fields never leak.

Validation is just annotations

public record CreateOrderRequest(
    @NotBlank @Size(max = 120) @CleanText String customer,
    @NotBlank @Size(max = 200) @CleanText String item,
    @Min(1) @Max(1000) int quantity) {}

Add @Valid @RequestBody on the controller and Spring checks every rule before your method runs. Break one and it throws MethodArgumentNotValidException.

A custom constraint + clean errors

@CleanText is a custom ConstraintValidator (rejects blank-after-trim + a small blocklist) — you can write your own rules, not just the built-ins. A @RestControllerAdvice turns validation failures into a tidy 400 with a field→message map. (Day 5 upgrades this to full RFC-7807 ProblemDetail.)

🔨 Full walkthrough (constraints → @valid → custom validator → 400 handler) on the page: https://dev48v.infy.uk/orderhub/day4-validation.html

OrderHub — a production-grade Spring Boot backend, one feature a day.
🌐 https://dev48v.infy.uk · Code: https://github.com/dev48v/order-hub-from-zero

Vector Databases: Search by Meaning, at Scale

Devanshu Biswas — Tue, 23 Jun 2026 06:16:52 +0000

Embeddings turn meaning into vectors (last post). But if you have a million of them, how do you find the right ones for a query — fast? That's what a vector database does, and it's the retrieval engine behind every RAG app. Here's a live semantic search demo.

🗂️ Search by meaning (not keywords): https://dev48v.infy.uk/ai/days/day14-vector-databases.html

Search becomes "find the nearest vectors"

Embed your query into the same space as your documents, then find the document vectors closest to it (by cosine similarity). Because closeness = meaning, the query "how do I reset my password" matches a doc about "recovering account access" — even with zero shared keywords. The demo shows this beating a keyword search that returns nothing.

Why you need a database, not a for-loop

Comparing your query to every vector (brute-force kNN) is fine for hundreds, hopeless for millions. Vector DBs use ANN (approximate nearest neighbour) indexes like HNSW to find the closest vectors in milliseconds — trading a tiny bit of accuracy for huge speed.

What a vector DB actually stores

Vectors + the original text + metadata, behind an ANN index. Pipeline: chunk your docs → embed → upsert. Query: embed the question → search top-k → (often) filter by metadata or combine with keyword search (hybrid).

This is the retrieval half of RAG. Real options: Pinecone, Weaviate, Chroma, pgvector, FAISS.

🔨 Build it (embed → upsert → similarity search → top-k → RAG) on the page: https://dev48v.infy.uk/ai/days/day14-vector-databases.html

Part of AIFromZero. 🌐 https://dev48v.infy.uk

GANs Explained: Two Networks That Make Fakes Real

Devanshu Biswas — Tue, 23 Jun 2026 06:16:11 +0000

Before diffusion models, GANs were how AI learned to generate realistic images. The idea is a game between two networks — and you can watch it reach its eerie equilibrium on a 2D scatter. Here's a live GAN-training demo.

🎭 Watch the fakes become real: https://dev48v.infy.uk/dl/day14-gans.html

Two networks, one game

The Generator turns random noise into fake data, trying to mimic the real distribution.
The Discriminator is a detective: given a sample, is it real or fake?

They train against each other. The generator wants to fool the discriminator; the discriminator wants to catch fakes. Forger vs. detective.

The equilibrium

At first the fakes are obvious noise and the discriminator nails them (~90% accuracy). As the generator improves, its fakes drift onto the real distribution — until the discriminator can't do better than a coin flip (~50%). That stalemate means the fakes are indistinguishable from real. In the demo, the rose "fake" cloud morphs onto the teal "real" ring while the accuracy bar slides to 50%.

The catch

GANs are famously unstable to train — mode collapse (the generator outputs one thing), oscillation, sensitive hyperparameters. Variants like DCGAN and StyleGAN tamed it (StyleGAN's faces went viral). Today, diffusion models have largely taken over image generation — but the adversarial idea is foundational.

🔨 Full build (G and D nets → sample noise → train D on real+fake → train G to fool D) on the page: https://dev48v.infy.uk/dl/day14-gans.html

Part of DeepLearningFromZero. 🌐 https://dev48v.infy.uk

PCA From Scratch: Compress Data, Keep the Signal

Devanshu Biswas — Tue, 23 Jun 2026 06:15:29 +0000

Got 100 features and can't visualize or train fast? PCA finds the few directions that carry most of the information and throws away the rest — and you can watch it happen on a 2D scatter. Here's PCA computed for real in the browser.

📉 See the principal axes (drag the correlation slider): https://dev48v.infy.uk/ml/day14-pca.html

The idea: rotate to where the variance is

PCA finds new axes — principal components — pointing along the directions your data spreads the most. PC1 is the longest spread, PC2 the next (perpendicular to it), and so on. Keep the top few and you've compressed the data with minimal loss.

How it's actually computed

Center the data (subtract the mean).
Build the covariance matrix (how features vary together).
Find its eigenvectors (the component directions) and eigenvalues (how much variance each holds).
Sort by eigenvalue, keep the top-k, project onto them.

The demo draws PC1/PC2 through the cloud and shows the "variance explained" percentages — collapse to PC1 and watch how much information survives.

When to reach for it

Visualization (high-dim → 2D), compression, denoising, speeding up training. Scale your features first; remember it only captures linear structure.

🔨 Built from scratch (center → covariance → eigen → project) on the page: https://dev48v.infy.uk/ml/day14-pca.html

Part of MachineLearningFromZero. 🌐 https://dev48v.infy.uk