Forem: Sanju Shaw

You, Me, and Microservices

Sanju Shaw — Thu, 16 Apr 2026 16:17:01 +0000

Let me tell you something.

Every beginner learns how to build apps like this:

One backend
One database
Everything connected
Everything… tightly packed

Feels nice. Simple. Clean.

Until one day…

everything breaks.

The Day Your App Betrays You

Imagine this.

You built a cool app:

login system
payment system
notifications
search
user profiles

All inside one backend.

Life is good.

Then suddenly:

Payment API slows down
Entire app becomes slow
One small bug → whole server crashes
You try to fix one thing → 10 things break

Welcome to the monolith nightmare.

This is exactly why companies moved away from it.
Because in monoliths:

“one failure can bring the entire system down”

So What Did Smart Engineers Do?

They said:

“Why are we building ONE giant system…
when we can build MANY small ones?”

Boom.

Microservices were born.

What Even Is a Microservice?

Simple.

Instead of this:

One giant backend doing EVERYTHING

You now have:

Auth Service
Payment Service
Notification Service
Search Service

Each one:

runs independently
deploys independently
breaks independently 😌

Technically speaking:

Microservices are “small, independent services that communicate with each other”

But forget the definition.

Think of it like a team.

Think Like a Startup

Imagine a startup.

You don’t hire:

one guy who does everything

You hire:

backend dev
frontend dev
designer
marketer

Each person:

does one job
does it well
works with others

That’s microservices.

Now Let’s Get Real (Production Level Stuff)

This is where most tutorials lie to you.

They show:

“Create 3 services, connect with REST API, done.”

That’s NOT production.

Real world looks like chaos.

Example: Amazon (Real System)

When you click “Buy Now”:

Behind the scenes:

Product Service → checks item
Inventory Service → checks stock
Payment Service → processes money
Order Service → creates order
Notification Service → sends email

All of these are **different services talking to each other.

And guess what?

If notification fails…

Your order STILL goes through.

The Hidden Truth Nobody Tells You

Microservices are NOT easier.

They are:

harder to build
harder to debug
harder to manage

Because now you’re dealing with:

network calls (not function calls)
latency
failures between services
distributed systems

Even the docs admit:

Microservices introduce “additional complexity… like latency and fault tolerance”

So Why Do Big Companies Still Use It?

Because at scale…

Monolith = death ☠️

Microservices = survival 🚀

Companies like:

Netflix
Uber
Amazon

use microservices because:

they can scale parts independently
deploy features faster
avoid full system crashes

What Actually Happens in Production

Let’s simplify a real production flow:

User → API Gateway → Services → Database

But inside?

It’s more like:

User
  ↓
Load Balancer
  ↓
API Gateway
  ↓
Auth Service → Token
  ↓
Order Service → calls Inventory Service
                  ↓
              Payment Service
                  ↓
           Event Queue (Kafka)
                  ↓
         Notification Service

Yeah…

It’s not pretty.

But it’s powerful.

The One Concept That Will Make You Dangerous

If you understand just this, you’re ahead of 90% devs:

Each microservice owns ONE business responsibility.

Not “user service does everything”.

No.

Auth handles login only
Payment handles money only
Inventory handles stock only

This is called:

👉 Single Responsibility at system level

Should YOU Use Microservices?

Let’s be honest.

If you are:

building a college project
small startup
solo dev

👉 Don’t.

Start with monolith.

Microservices are for when:

system grows
team grows
traffic grows

Final Thoughts :

Microservices are not about code.

They are about how you think about systems.

From:

“Let me build this feature”

To:

“How will this behave when 1 million users hit it?”

That shift…

That’s what separates:

developers → engineers

How to implement Pagination in Spring-boot project?

Sanju Shaw — Sat, 15 Nov 2025 16:26:55 +0000

Before beginning, let’s understand what pagination actually is.

Pagination simply means breaking a huge dataset into smaller chunks or pages. This is exactly what you see on e-commerce websites when products load page by page, or when you scroll through Google search results — you never get all the data at once.

It's useful because:

You save bandwidth.
Backend responds faster
UI becomes smoother.
Database queries remain optimized

How to set-up pagination

Suppose we have an API like:

/api/books?query=adventure

Now we can easily configure the backend to limit the number of items returned.
Spring Data JPA already gives built-in support for pagination using Pageable.

We can also let the client decide how many results they want:

/api/books?query=adventure&page=0&size=20

page -> which page number(0-based index)
size -> how many items per page

Let's implement this properly.

Coding time 🧑‍💻

We are using Spring Boot + MySQL + Spring Data JPA.

1. Controller Layer

@RestController
@RequestMapping("/api/books")
public class BookController {

    @Autowired
    private BookService bookService;

    @GetMapping
    public Page<Book> getBooks(
            @RequestParam(defaultValue = "adventure") String query,
            @RequestParam(defaultValue = "0") int page,
            @RequestParam(defaultValue = "10") int size) {

        return bookService.getBooks(query, page, size);
    }
}

we use Spring's Page class
page & size have default values.
Output automatically includes : totalElements, totalPages, current page number, size, and you actual data list.

2. Service Layer(Business Logic):

@Service
public class BookService {

    @Autowired
    private BookRepository bookRepository;

    public Page<Book> getBooks(String query, int page, int size) {
        Pageable pageable = PageRequest.of(page, size);
        return bookRepository.findByTitleContainingIgnoreCase(query, pageable);
    }
}

Here:

`PageRequest.of(page, size) creates the pagination configuration.
Repository method automatically handles pagination.

3. Repository Layer:

This is the beauty of Spring Data JPA - no SQL written manually.
It handles :

LIMIT
OFFSET
Filtering
Sorting All under the hood.

want to sort the results??

bash /api/books?page=0&size=10&sort=price,desc

Change your controller parameter:

Final Result

If you call:

bash GET /api/books?query=adventure&page=0&size=5

Response be like:

This is how pagination works smoothly in Spring Boot.

Follow me for more Java oriented and system design content. Thanks for reading!

How to build a scalable backend , step-by-step

Sanju Shaw — Sun, 26 Oct 2025 10:58:38 +0000

TL;DR: Start with clear goals and metrics, design small stateless services, move heavy work off the critical path with asynchronous messaging, cache aggressively, scale horizontally, automate everything, and observe continuously.

Follow proven principles (e.g. the Twelve-Factor approach) and pick patterns like CQRS/event sourcing only when the complexity pays off.

Why “scalable” and what that really means

“Scalable” doesn’t mean “can handle infinite traffic.”

It means your system can meet future load and change requirements without a full redesign: add machines (horizontal scaling), add automation (CI/CD, infra as code), and keep operations cheap and predictable.

Before coding, pick measurable goals:

Target traffic: requests/sec, concurrent users, or data - growth per month.
SLOs: p99 latency ≤ X ms, availability 99.9% (SLA), error budget.
Cost budget: expected monthly infra spend.

Measure these — they will drive all tradeoffs later.

Step 1 - Start with good principles(do this first)

Treat services as processes, externalize config, and make deployments reproducible.

The Twelve-Factor App is a concise, practical baseline for cloud-native, scalable apps: one codebase, config in env, processes are stateless, backing services treated as attached resources, logs as event streams, etc.
These principles make horizontal scaling predictable.

Quick checklist

Single repo per service(or mono-repo with clear boundaries).
Config in environment variables or a config service.
Build -> release -> run pipeline(CI/CD).
Processes must be stateless whenever possible.

Step 2 — Define bounded contexts and verticals (domain decomposition)

Split complexity by business domain (users, orders, billing). Each domain becomes a candidate microservice or logical module.
This reduces blast radius and lets you scale only hot domains.

Ex:

api-gateway
  ├─ auth-service
  ├─ orders-service
  ├─ inventory-service
  └─ billing-service

Step 3 — Make services stateless and externalize state

Stateless processes are the easiest to scale: add more instances behind a load balancer.

Where to keep state:

Relational/NoSQL DB for canonical data.
Cache(redis) for hot reads.
Object-storage(S3) for blobs.

Twelve-Factor explicitly recommends processes be stateless and backing services treated as attached resources — design with that in mind.

Step 4 — Put slow work off the critical path (async messaging)

Synchronous calls couple latency and availability. Use message queues or event buses for background processing (email sending, heavy reports, third-party API retries).

Common patterns:

Queue-based workers: produce to queue (RabbitMQ/SQS/Kafka), workers consume and process.
Event-driven: publish events to an event bus; multiple subscribers react. For long-lived state or audit trails, consider event sourcing.

When to use Event Sourcing / CQRS: useful for systems where auditability, replay-ability, or complex read models matter (financial systems, order histories). They add complexity — evaluate tradeoffs.

Step 5 — Caching: reduce load and latency

Cache at multiple levels:

Client : HTTP cache headers, ETag.
Edge/CDN : cache static assets and cacheable api responses.
App-level : in-memory caches for repeated computations.
Distributed cache : Redis for shared hot data.

Design cache invalidation carefully — “cache invalidation” is famously one of the two hardest problems in CS. Prefer short TTLs for dynamic data and event-based invalidation when possible.

Step 6 — Database scaling: replicas, partitioning, and polyglot storage

Start simple (single primary + read replicas). When read traffic overwhelms, add replicas; when writes are the bottleneck, consider sharding/partitioning.

Options :

Read replicas for read-heavy workloads.
Sharding for very large datasets or high write throughput.
Choose the DB that fits access pattern: relational for transactions, wide-column or document DBs for flexible schemas, and time-series for metrics.

Step 7 — Load balancing and autoscaling

Exterior layer :

API Gateway / Load balancer(NGINX) + routing, retries, rate limiting.
Horizontal pod autoscaler(k8s) or cloud groups for compute.

Autoscaling rules should be driven by business metrics (requests/sec, queue length, CPU) and respect warm-up time for new instances.

Step 8 — Deploy with containers and orchestration

Containerize with Docker, deploy to Kubernetes or managed container platforms.
Benefits:

consistent runtime
resource isolation
standard deployment patterns(rolling updates, rolling restarts).

FROM node:18-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY . .
CMD ["node", "server.js"]

k8s snippet (deployment + HPA)

apiVersion: apps/v1
kind: Deployment
metadata: { name: orders-service }
spec:
  replicas: 2
  template:
    spec:
      containers:
      - name: orders
        image: your-registry/orders:1.0
        resources:
          requests: { cpu: "100m", memory: "128Mi" }
---
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata: { name: orders-hpa }
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: orders-service
  minReplicas: 2
  maxReplicas: 20
  metrics:
  - type: Resource
    resource:
      name: cpu
      target: { type: Utilization, averageUtilization: 60 }

(Autoscaling in k8s is a standard pattern — use sensible metrics and test.)

Step 9 — Observability: logs, metrics, tracing

_ You can't fix what you can't see._ Implement :

Centralized logs (JSON logs -> ELK/ Loki).
Metrics (Prometheus + Grafana).
Distributed tracing(OpenTelemetry, Jaeger).

Correlate traces with logs to find latency hotspots and understand end-to-end flows.

Step 10 — Reliability practices: retries, circuit breakers, and bulkheads

Design services to fail gracefully :;

Retries with exponential backoff.
Circuit breakers to abvoid cascading failures.
Bulkheads to isolate resource pools(e.g., separate thread pools or queues per integration).

These patterns help maintain partial availability during degraded conditions.

Step 11 — Security and operational concerns

Use IAM and least privilege for cloud resources.
Secure secrets (Vault, cloud KMS).
harden APIs with rate limits and auth(JWT/OAuth).
Plan backups, DR strategies, and recovery drills.

Step 12 — Test for scale (not just correctness)

Load testing(k6, wrk).
Soak test(long running) to expose memory leaks.
Chaos engineering (start small - kill a pod, simulate network partition).

Seeing how the system behaves under stress reveals real bottlenecks and bad assumptions.

When to adopt advanced patterns (and when not to)

CQRS/Event Sourcing: adopt if you need auditability, replayability, or independent read models. They’re powerful but add complexity — only for high-value use-cases.
Microservices: useful for larger teams and independent scaling. For small teams or simple apps, a well-structured monolith (modular codebase) often beats premature microservices.

A simple growth roadmap....

MVP: single service, RDS/managed db, simple caching.
Scale reads: add CDN and DB read replicas.
Decouple: add queues for background work.
Split: extract hot domains into separate services.
Optimize: add autoscaling, observability, and chaos tests.
Evolve: use CQRS/event sourcing only if business justify it.

Building a Web Scraper in 1 Java File☕

Sanju Shaw — Mon, 04 Aug 2025 15:27:23 +0000

I was deep in the Oracle java.net docs, coffee in hand, when the idea hit me: build a minimalist web scraper in a single file—just to see if I could :)

✨ Introduction

Ever wondered how search engines crawl web pages?
Or how job sites gather listings from other websites?

That’s all thanks to web scraping. In this post, I’ll show you how I built a simple web scraper in pure Java, without any libraries, all in a single file.

Even if you’re new to Java’s networking or regex features, don’t worry—I’ll walk you through it all.

📌What you'll learn

How to take a website URL from the user
How to fetch its HTML using HttpURLConnection
How to extract the <title> and all <a href="..."> links using regex
How to handle common errors gracefully
Why this is a powerful starting point for automating the web

Let's dive in 🤿

Create a file WebScraper.java(or name anything you desire).

public class WebScraper {
 public static void main(String[] args) {
        if (args.length < 1) {
            System.err.println("❌ Please provide a URL as the first argument.");
            return;
        }

        String inputUrl = args[0];

What this code snippet does is to take provided url from CLI and if not found any URL then throw an error and quit running.

Next part :

 try {
        URI uri = URI.create(inputUrl); 
            URL url = uri.toURL();
            String html = fetchHTML(url);

            if (html == null || html.isEmpty()) {
                System.err.println(" Failed to fetch content or empty page.");
                return;
            }

            String title = extractTitle(html);
            System.out.println(" Page Title: " + (title != null ? title : "N/A"));

            List<String> links = extractLinks(html);

            System.out.println("\n Links found:");
            if (links.isEmpty()) {
                System.out.println("No <a> tags found.");
            } else {
                links.forEach(System.out::println);
            }

        } catch (Exception e) {
            System.err.println(" Error: " + e.getMessage());
        }
    }

This portion creates URL from provided string in CLI with the help of URI package as direct use of URL has been deprecated from Java 11+.

Next we're fetching HTML from a function, thereafter fetching associated links in the site and printing them gracefully.

Here's fetchHTML fucntion:

private static String fetchHTML(URL url) {
        StringBuilder html = new StringBuilder();

        try {
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            conn.setRequestMethod("GET");

            try (BufferedReader reader = new BufferedReader(
                    new InputStreamReader(conn.getInputStream()))) {

                String line;
                while ((line = reader.readLine()) != null) {
                    html.append(line).append("\n");
                }
            }

            return html.toString();

        } catch (Exception e) {
            System.err.println("❌ Failed to fetch HTML: " + e.getMessage());
            return null;
        }
    }

First off all we're opening a connection using openConnection() method in URL and type-casting the return into HttpURLConnection type for dispatching a GET request to access the site.
Later creating an InputStream using BufferedReader and storing entire HTML content in our string builder one at a time. Go ahead print this string-builder and see how it looks.

Now, we've 2 more functions one for extracting title from html and extracting links.

-extractTitle(html):

private static String extractTitle(String html) {
        Pattern pattern = Pattern.compile("<title>(.*?)</title>", Pattern.CASE_INSENSITIVE | Pattern.DOTALL);
        Matcher matcher = pattern.matcher(html);
        return matcher.find() ? matcher.group(1).trim() : null;
    }

Why not you tell me in the comments how this pattern matching works?
Let's see how much you are following😀

extractLinks(html):

 private static List<String> extractLinks(String html) {
        List<String> links = new ArrayList<>();
        Pattern pattern = Pattern.compile("<a\\s+(?:[^>]*?\\s+)?href=[\"'](.*?)[\"']", Pattern.CASE_INSENSITIVE);
        Matcher matcher = pattern.matcher(html);

        while (matcher.find()) {
            String link = matcher.group(1).trim();
            if (!link.isEmpty()) {
                links.add(link);
            }
        }

        return links;
    }

Matching <a> tag pattern and storing them to a list.

Here's the full code :

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URI;
import java.net.URL;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.ArrayList;
import java.util.List;

public class WebScrapper {

    public static void main(String[] args) {
        if (args.length < 1) {
            System.err.println("❌ Please provide a URL as the first argument.");
            return;
        }

        String inputUrl = args[0];

        try {
        URI uri = URI.create(inputUrl); 
            URL url = uri.toURL();
            String html = fetchHTML(url);

            if (html == null || html.isEmpty()) {
                System.err.println(" Failed to fetch content or empty page.");
                return;
            }

            String title = extractTitle(html);
            System.out.println(" Page Title: " + (title != null ? title : "N/A"));

            List<String> links = extractLinks(html);

            System.out.println("\n Links found:");
            if (links.isEmpty()) {
                System.out.println("No <a> tags found.");
            } else {
                links.forEach(System.out::println);
            }

        } catch (Exception e) {
            System.err.println(" Error: " + e.getMessage());
        }
    }

    private static String fetchHTML(URL url) {
        StringBuilder html = new StringBuilder();

        try {
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            conn.setRequestMethod("GET");

            try (BufferedReader reader = new BufferedReader(
                    new InputStreamReader(conn.getInputStream()))) {

                String line;
                while ((line = reader.readLine()) != null) {
                    html.append(line).append("\n");
                }
            }

    System.out.println(html+"\n");
            return html.toString();

        } catch (Exception e) {
            System.err.println("❌ Failed to fetch HTML: " + e.getMessage());
            return null;
        }
    }

    private static String extractTitle(String html) {
        Pattern pattern = Pattern.compile("<title>(.*?)</title>", Pattern.CASE_INSENSITIVE | Pattern.DOTALL);
        Matcher matcher = pattern.matcher(html);
        return matcher.find() ? matcher.group(1).trim() : null;
    }

    private static List<String> extractLinks(String html) {
        List<String> links = new ArrayList<>();
        Pattern pattern = Pattern.compile("<a\\s+(?:[^>]*?\\s+)?href=[\"'](.*?)[\"']", Pattern.CASE_INSENSITIVE);
        Matcher matcher = pattern.matcher(html);

        while (matcher.find()) {
            String link = matcher.group(1).trim();
            if (!link.isEmpty()) {
                links.add(link);
            }
        }

        return links;
    }
}

Compile and Run the file:

javac WebScraper.java

java WebScraper https://github.com

Output:

🙌 Final Thoughts:

Yes, I know this is a simple scraper. Several developments can be made integration of tools such as JSoup can be done and much more.

But, This small scraper gave me a deep understanding of:

How Java connects to the web
How to read and process HTML
How regex can extract meaningful data

If you found this useful, drop a 💬 or ❤️.
And if you want me to turn this into a downloadable CLI tool, let me know in the comments!

✨ Connect With Me

You can follow me here on Dev.to or connect with me on GitHub for more hands-on Java + tooling content!

☁️ AWS Free Tier – Your Survival Guide to Building on the Cloud

Sanju Shaw — Tue, 29 Jul 2025 12:04:47 +0000

Slurping coffee ☕

AWS is like that intimidating gym in your neighborhood — full of shiny machines, you don’t know where to start, and you’re scared you might pull something (in this case, your wallet).

If you’re a beginner, the AWS Free Tier is your entry ticket. But here’s the thing:

It’s not a magic “everything is free forever” card.
It’s not idiot-proof (you can still launch a $200/month server by clicking the wrong dropdown).
It is a golden sandbox if you know what you’re doing.

This isn’t a “hey, just sign up for AWS and it’ll be fun!” post. This is the comprehensive guide that tells you:

what’s actually free,
how not to get billed,
what you can realistically build,
and why you should even care.

Coffee ready? Let’s go.

🏗 What the Heck Is AWS Free Tier?

The AWS Free Tier is basically Amazon saying:

“Here, try out our services before you decide whether you want to commit. Oh, and if you mess up — that’s on you.”

It comes in 3 categories (don’t mix them up):

✅ 1. Always Free

Stays free. Forever.
Stuff like 1M Lambda requests/month, 25GB DynamoDB storage, 1M API Gateway calls.
Perfect for tiny side projects and “learning mode” work.

📅 2. 12-Month Free

Free for your first year after account creation.
Includes big-ticket items like 750 hours/month of EC2 t2.micro/t3.micro and 750 hours of RDS.
Important: Month 13 comes. The bill comes with it.

⏳ 3. Short-Term Trials

“Try SageMaker for 2 months” or “Kendra for 30 days.”
Useful for testing, easy to forget to turn off.

Check out their official docs: AWS Free Tier official page

🖥 What’s Actually Worth Using (and What You’ll Break Stuff With First)

Let’s cut through the AWS glossary soup. Here’s the Free Tier starter pack and what you can do with it:

🖥 EC2 (Elastic Compute Cloud)
- 750 hours/month for a t2.micro or t3.micro.
- Think of it as your first “tiny Linux box in the cloud.”
- Build: a portfolio site, a simple API, or a WordPress blog.
- ⚠️ Danger Zone: Don’t pick “m5.4xlarge” because it “sounds faster.” That’s a Lamborghini rental, not a free bicycle.
📦 S3 (Simple Storage Service)
- 5GB Standard Storage, thousands of requests.
- Build: host a static website, backup project files, store memes.

🎯 CLI Example – Create an S3 bucket:

  aws s3 mb s3://my-free-tier-bucket
  aws s3 cp index.html s3://my-free-tier-bucket

(For those who are using aws CLI can store media in S3 by running the command above)

🗄 RDS (Relational Database Service)
- 750 hours for MySQL/PostgreSQL t2.micro.
- Build: a managed DB for your app (without “sudo apt install mysql” headaches).
☁️ Lambda
- 1M free requests/month.
- Build: a Discord bot, a webhook, or a cron job that runs “every morning at 7 AM” without leaving your PC on.
🌐 CloudFront
- 1TB/month free data transfer.
- Build: a CDN for your site → faster load times (and bragging rights).

⚠️ The Dark Side of Free Tier:

AWS won’t stop you from making expensive mistakes. Here’s what beginners learn the hard way:

⚡ The “free” instance trap → Free tier covers t2.micro and t3.micro. Click anything bigger → cha-ching.
📤 Data Transfer Gotchas → Inbound traffic = usually free. Outbound = not always. Your side project going viral? That might cost you.
🗑 Zombie Resources → You stop using an EC2 instance but forget to terminate it? AWS doesn’t “assume you’re done.”
🔔 No Billing Alerts → If you don’t set them, you’ll only find out about charges when your card statement hits.

One can set up a billing alarm using AWS CloudWatch.

📌 🧠 Some AWS wisdom

☑ “Stopped” ≠ “Deleted” – Stopping EC2 doesn’t stop charges for storage. TERMINATE.

☑ Regions matter – Some Free Tier resources are “per region,” some are global. Don’t scatter them everywhere.

☑ IAM users > root account – Never develop with the root account. Use IAM users.

☑ Billing dashboard is your friend – Check it like you check your phone battery.

🚀 So… What Can You Actually Build for Free?

Here’s where the magic happens. Real beginner-friendly projects that don’t trigger billing nightmares:

✅ Host Your Portfolio or Blog

EC2 (server) + S3 (assets) + CloudFront (CDN).
Tell recruiters: “Yeah, my site runs on AWS infrastructure.” Boom 💥.

✅ Create a Serverless REST API

Lambda + API Gateway + DynamoDB.
No server management, no 24/7 EC2 bill.

✅ Build a Discord/Telegram Bot

Lambda runs only when triggered.
Free Tier = no “always-on server” costs.

✅ Experiment with CI/CD

Play with AWS CodePipeline + CodeBuild, or even Terraform → Learn DevOps for free.

✅ Run a Small Database

RDS for MySQL/Postgres → Learn DB management without local setup pain.

🛠 Tips for Staying Sane on Free Tier

☑ Always check the region. Free Tier applies everywhere, but pricing differs.
☑ Delete resources. EC2 stopped ≠ EC2 deleted. Delete. Terminate. Burn the evidence.
☑ Use the AWS Pricing Calculator. Before you YOLO deploy something, sanity-check it: calculator.aws.
☑ Stay in the docs. Not glamorous, but AWS Free Tier docs will save you🍀.

☕ Final Sip

The AWS Free Tier isn’t just a “free hosting coupon.” It’s your cloud playground. You can:

Learn how real-world infrastructure works.
Build a side project or even an MVP for $0.
Impress interviewers (“Oh yeah, I deployed that API on AWS Lambda”).

But it’s also not a toy — treat it recklessly and you’ll learn the fastest DevOps lesson of all: cloud billing is scarier than any production bug.

👉 So go ahead. Spin up that t2.micro, deploy your first Lambda, host your blog.
And remember: delete your experiments before AWS deletes your bank balance.

📌 P.S. – This was your map of the AWS Free Tier jungle.
Next up: we’ll dive into real beginner-friendly projects you can build on AWS for $0 — from serverless APIs to personal dashboards. Stay tuned with coffee🍵.

🚀 Java Streams Explained Like You’re Five (But With Pro-Level Depth)

Sanju Shaw — Sat, 12 Jul 2025 07:47:29 +0000

“Stream API is not just syntactic sugar. It's a paradigm shift.”

Whether you're new to Java or already knee-deep in lambda expressions, you've probably heard of Streams—Java’s way of making code beautiful, declarative, and parallel-friendly. Introduced in Java 8, which I would quote it as "Revolutionary".

But what exactly are streams?
Are they just fancy loops?
Are they fast?
Are they magic?

Grab a cup of coffee ☕—we’re about to crack Java Streams wide open in a way that anyone (yes, even beginners) can understand.

🏁 Part 1: What Are Java Streams?

At its core, a Stream is a sequence of data that you can operate on in a functional style—map, filter, reduce, etc.—without mutating the original data.

🆚 Traditional vs Stream

Let's say you want to add people with > 18 age to names list:

Traditional Java:

List<String> names = new ArrayList<>();
for (Person p : people) {
    if (p.getAge() > 18) {
        names.add(p.getName());
    }
}

With Streams:

List<String> names = people.stream()
    .filter(p -> p.getAge() > 18)
    .map(Person::getName)
    .collect(Collectors.toList());

Notice how:
✅Cleaner
✅Declarative
✅Chainable

🔄 Part 2: How Streams Work – Under the Hood

Streams are not collections. They don’t store data, they carry data from source to destination through a pipeline of operations.

🔗 Stream Pipeline
Every stream has 3 steps:

Source
Like Collection.stream(), Files.lines(), IntStream.range(), etc.
Intermediate Operations (lazy)
Like filter(), map(), sorted() – they return a new stream.
Terminal Operation (eager)
Like collect(), forEach(), reduce() – triggers the pipeline.

Until a terminal operation is called, nothing happens.
This is lazy evaluation.

🧠 Stream Internals – Building a Lazy Machine

Here’s a simplified internal flow:

people.stream()
    .filter(p -> p.getAge() > 18)  // creates a FilterOp
    .map(p -> p.getName())         // creates a MapOp
    .collect(...)                  // traverses and pulls one element at a time

Each intermediate op builds a pipeline stage. When terminal operation starts, it pulls one element through the chain.

Think of it like a conveyor belt, not a loop.

💥 Performance: Streams vs Traditional

✅ When Streams are Faster or Better:

Parallelism: stream().parallel() runs operations on multiple cores.
Lazy filtering: Stops processing once terminal condition is met.
Readability: Less boilerplate, easier to reason.

❌ When They’re Not Ideal:

For super simple loops, traditional for may be faster (less overhead).
Streams create more objects (lambda wrappers, collectors).
Streams don't allow mutating external state reliably (avoid side effects).

📊 Benchmark instance:

Say you want to sum even numbers from a list of 10 million integers.

Traditional loop:

long sum = 0;
for (int i : list) {
    if (i % 2 == 0) sum += i;
}

Stream:

long sum = list.stream()
    .filter(i -> i % 2 == 0)
    .mapToLong(Integer::longValue)
    .sum();

Parallel Stream:

long sum = list.parallelStream()
    .filter(i -> i % 2 == 0)
    .mapToLong(Integer::longValue)
    .sum();

In practice, parallelStream wins on multi-core machines with large data.

⚔️ Stream vs Loops:

Feature	For Loop	Stream
Readability	😬 verbose	✅ concise
Functional style	❌ No	✅ Yes
Lazy evaluation	❌ No	✅ Yes
Parallelism	Manual	Easy via `.parallel()`
Control (break/continue)	✅ Easy	❌ Not intuitive
Performance	⚡ Best for simple logic	⚡ Best for complex pipelines

🚀 Why Streams Are Revolutionary:

Encourage declarative programming. (saying what to do instead how to)
Let you parallelize logic without rewriting loops
Built for immutable, side-effect-free logic
Introduced a new mindset to Java programming

🤔 Why not you go ahead and try these things:

Refactor a for loop using stream()
Use .peek() to inspect stream data.
Benchmark .stream() vs .parallelStream() performance.
Write a custom collector.

And comment down what you learnt in the process

You can learn more about streams and it's methods and working from articles on baeldung, gfg, oracle docs etc.

💬 What's Your Stream Story?

Have a cool use case or a parallelStream() horror story? Let’s chat in the comments 👇

You are My-SQL 🧡

Sanju Shaw — Wed, 05 Feb 2025 17:56:33 +0000

This article assumes you're a beginner—even if you aren't. Just grab a coffee and let's begin. ☕

Why Database?

In the IT industry, everything revolves around data—collecting it, cleaning it, manipulating it, visualizing it, making sense out of it, and even predicting outcomes based on it. Data is the backbone of modern applications, and we need a structured way to store it—that's where databases come into play.

There are two primary types of databases: SQL (Structured Query Language) databases and NoSQL (Not Only SQL) databases.

SQL Databases (Relational Databases) are structured as tables containing rows and columns. Examples include MySQL, MariaDB, PostgreSQL, and Oracle DB.
NoSQL Databases store data in formats like BSON (Binary JSON). A popular example is MongoDB, which is widely used in modern applications.
Vector Databases are a relatively new category designed for storing and searching high-dimensional vector embeddings. These are used in AI/ML applications, but for now, we'll focus on MySQL.

What is SQL?

SQL (Structured Query Language) is the language used to query, retrieve, and manipulate data in relational databases. It enables users to interact with stored data efficiently.

Brewing

Head over to the official MySQL download page: MySQL Downloads
Install MySQL on your PC following the setup instructions.
Run the installer, accept the terms and conditions, and configure it. If you face any issues, search for your OS-specific installation guides on Google or YouTube.

Accessing MySQL

Once installed, open your terminal and enter:

mysql -u root -p

-u root specifies the user (root is the default administrator).
-p prompts for a password (enter the one you set during installation).

After logging in, check existing databases with:

SHOW DATABASES;

This lists all available databases, including system-generated ones. You can play with.

Note: SQL commands are case-insensitive, but using uppercase for keywords (SELECT, FROM, etc.) is a common practice. The semi-colon (;) at the end of commands is required—it marks the end of an SQL statement.

Let's create and manage DataBase in MySQL

Create a Database:

CREATE DATABASE LabDB;

If you see an "OK" message, you're good to go.

To use this database run:

use LabDB;

Check for tables (initially, none will exist):

show tables;

A database contains tables, and a table consists of columns (fields) and rows (records).

CREATE TABLE Students (
    StudentID INT PRIMARY KEY,
    Name VARCHAR(255) NOT NULL,
    Age INT,
    Department VARCHAR(50)
);

Here, PRIMARY KEY ensures each record has a unique identifier.

INT represents an integer data type.

VARCHAR(n) stores strings (up to n characters).

NOT NULL enforces that a column must have a value.

Describe your table, do 'desc' with table name:

desc Students;

Let's insert data into Table by:

INSERT INTO Students (StudentID, Name, Age, Department)  
VALUES 
(1, 'Alice', 20, 'Computer Science'),
(2, 'Bob', 22, 'Physics'),
(3, 'Charlie', 19, 'Mathematics');

Here, we're simply adding values manually respective to the field type. Notice VarChar field gets a String, Int type got an Integer value.

Created Table, added Values. Now, Let's take a look 👀

SELECT * FROM Students;

'*' means all. Select all from Table Name(Students).

📌 Output:

StudentID	Name	Age	Department
1	Alice	20	Computer Science
2	Bob	22	Physics
3	Charlie	19	Mathematics

Update and Delete Data

To update a record:

UPDATE Students SET Age = 21 WHERE StudentID = 1;

This updates Alice's age to 21.

To delete Charlie's record:

DELETE FROM Students WHERE StudentID = 3;

Use 'Truncate' to remove all records without deleting table

TRUNCATE TABLE Students;

To modify a table structure :

ALTER TABLE Students ADD Email VARCHAR(100);

It says to add Email field of type string in our 'Students' table.

Filtering Data with WHERE, AND, OR:

Use 'where' clause to query specific data :

SELECT * FROM Students WHERE Department = 'Computer Science';

Fetches students from the Computer Science department.

- AND, OR o

Using AND/OR operator:

SELECT * FROM Students WHERE Age > 18 AND Department = 'Physics';

Says to select those students whose age is above 18 and belongs to Physics department.

SELECT * FROM Students WHERE Age < 18 OR Department = 'Biology';

Guess what this does? 😉 (Try it out!)

See, I feel SQL commands are pretty much self-explanatory and sort of writing English which makes it easy to master.

Using IN, BETWEEN, LIKE, GROUPBY, ORDERBY, HAVING

IN ( Multiple values matching)

SELECT * FROM Students WHERE Department IN ('Computer Science', 'Biology');

Fetches students from either department.

BETWEEN (To query between a range)

SELECT * FROM Students WHERE Age BETWEEN 18 AND 22;

Fetches students whose age is between 18 and 22 (inclusive).

LIKE (Pattern matching ):

SELECT * FROM Students WHERE Name LIKE 'A%';

Finds names starting with 'A'.
(% is a wildcard representing any number of characters).

ORDER BY(Sorting purpose)

SELECT * FROM Students ORDER BY Age DESC;

By default ORDER BY arranges your data in Ascending order.

Group By and Having:

SELECT Department, COUNT(*) FROM Students GROUP BY Department HAVING COUNT(*) > 5;

Using Aggregate Functions:

To get the average:

Select avg(Age) from Students;

To get the Max age:

SELECT MAX(Age) FROM Students;

There are others as well.

Creating Views and Column Aliases:

- View is a virtual table that stores frequently used queries.

CREATE VIEW CS_Students AS  
SELECT * FROM Students WHERE Department = 'Computer Science';

Now, you can retrieve only Computer Science students just by using:,

SELECT * FROM CS_Students;

Column Aliases is a way to change how columns are displayed.

SELECT Name AS Student_Name, Age AS Student_Age FROM Students;

📌 Output:

Student_Name	Student_Age
Alice	21

To delete a table entirely:

DROP TABLE Students;

What's Next?

You've learned how to create, insert, retrieve, update, and delete data in MySQL. Now, try JOINs on your own!

🚀 Challenge:

Create another table (Courses).
Use INNER JOIN, LEFT JOIN, RIGHT JOIN to combine data.
Explore user management (GRANT, REVOKE).

Post your results in the comments! See you in the next post—another ☕ awaits.

You, me and Computer Networks

Sanju Shaw — Fri, 17 Jan 2025 11:48:01 +0000

This article is intended for beginners in Computer Networks.

First of all let's understand what is "Network" in computer?

Network is defined as the connection of different computers or machines both via wirelessly and wired to the internet.

Let's assume you have a router, this creates a LAN (Local Area Network) by connecting your devices. These devices need to be within a certain range to maintain a connection, especially if using Wi-Fi. The router itself connects to a WAN (Wide Area Network) through your ISP (Internet Service Provider), providing internet access to your LAN.

Basic Network Hardware: To connect devices in a network, we use essential hardware like routers, switches, and modems.

A router directs data between your local network (LAN) and the internet, often connecting multiple devices wirelessly or via cables.

Switch is used within a LAN to connect multiple devices, enabling them to communicate with each other efficiently by forwarding data only to the intended recipient.

Modem connects your network to your ISP, converting digital data from your devices into a signal that can be transmitted over your internet connection, whether it's cable, DSL, or fiber. Together, these devices form the backbone of most home and business networks.

Understanding IP Addresses in Networking

Consider IP addresses like real-life addresses. To send something to a particular place, you need that place's address. Similarly, an IP address is a unique identifier assigned to every machine that wants to send and receive data over the internet. Without IP addresses, devices wouldn't know where to send or receive data.

Types of IP Addresses

IPv4 and IPv6 An IPv4 address looks like 192.168.0.1. It consists of four numbers separated by dots, with each number ranging from 0 to 255. Due to the limited number of IPv4 addresses, we moved to IPv6, which looks like 2001:0db8:85a3:0000:0000:8a2e:0370:7334. IPv6 provides a much larger pool of addresses, but even with this, managing IP addresses efficiently remains a challenge due to the increasing number of internet-connected devices.

Public and Private IP Addresses

img-3

Public IP Address: Assigned by your ISP, used to connect your network to the internet.

For example, 203.0.113.42 might be the public IP address assigned to your home router. This public address is used as the default gateway for your devices to send and receive data from the internet outside your local area network.

Private IP Address: Used within a local network, such as 192.168.1.0, to communicate between devices without using the internet.

Subnetting

Subnetting is a method of dividing a large network into smaller, more manageable segments or sub-networks (subnets). This helps improve network performance and security by limiting the number of devices in each subnet.

Example: If you have a network with the IP range 192.168.1.0/24 (256 addresses), you can create two subnets:
192.168.1.0/25 (128 addresses)
192.168.1.128/25 (128 addresses)
This ensures each subnet can handle up to 128 devices, making network management more efficient.

Check your IP address

Windows: Type ipconfig in Command prompt.
macOS/Linux: type ifconfig or ip a in terminal.

Network protocols

By "protocol," we mean a set of rules or standards that define how to complete a task. In networking, a network protocol is a set of rules that devices must follow to send and receive data over the internet. These protocols ensure that data is transferred accurately and securely between devices.

There are many network protocols, such as FTP, HTTP/HTTPS, SMTP, SSH, ARP, PPP, TCP/IP, TELNET, and more.
For simplicity, we'll focus on TCP/IP, FTP, HTTP/HTTPS, and SMTP.

Key Network Protocols

TCP/IP (Transmission Control Protocol/Internet Protocol)

TCP/IP is the foundation of internet communication. It ensures that data sent over the network is broken into packets, transmitted, and reassembled correctly at the destination.
Example: When you load a webpage, TCP breaks the data into packets, IP routes them, and TCP reassembles them for your browser.

FTP (File Transfer Protocol)

FTP is used to transfer files between a client and a server over the internet.
Example: Web developers often use FTP to upload website files from their local computer to a web server.

HTTP/HTTPS (HyperText Transfer Protocol / HyperText Transfer Protocol Secure)

HTTP is the protocol for transferring web pages. HTTPS is the secure version, encrypting data to protect it from interception.
Example: When you visit a website, your browser uses HTTP or HTTPS to request and receive the page's content from the server.

SMTP (Simple Mail Transfer Protocol)

SMTP is used to send emails. It ensures that emails are correctly routed from the sender's server to the recipient's server.
Example: When you hit "send" on an email, SMTP handles the delivery of that message to the recipient's email server.

These few protocols are essential for the seamless operation of the internet, enabling everything from browsing websites to sending emails.

DNS(Domain Naming System)

When you visit a website by entering a domain name in your browser, like 'www.dev.to' or 'dev.to', how does the browser know where to go? The browser sends this request to a DNS server, which resolves the domain name to its corresponding IP address.

The DNS server uses a DNS map table to look up the IP address associated with the domain. Once it finds the correct IP address, it returns this information to the browser, which then uses the IP address to contact the website's server and load the webpage.

DNS is a complex system involving multiple layers, including root servers, TLD servers, and authoritative name servers. However, this overview provides a simplified explanation to help you grasp the basic concept. The full workings of DNS involve more detailed processes that ensure efficient and reliable domain name resolution.

If you liked reading consider upvoting, share and comment for more articles revolving around CS fundamentals ;-)