We’ll go step by step first understanding the concept, then looking at the Python code implementation

What is the Playfair Cipher?

The Playfair Cipher is a substitution cipher, but instead of replacing single letters like Caesar Cipher, it works with pairs of letters (digraphs).

This small change makes it much harder to break because:

• There are 26 letters, so a simple cipher has 26 possibilities.
• But with pairs, there are 26 × 26 = 676 possible combinations!

Playfair was a big upgrade back in the 1800s.

Step 1: Creating the Playfair Square

The Playfair Cipher uses a 5x5 grid of letters (25 slots total).
Since the English alphabet has 26 letters, the letters I and J are considered the same.

How the square is built:

1. Choose a secret key (word or phrase).
2. Write the key into the grid (ignoring duplicates).
3. Fill in the remaining letters of the alphabet.

👉 Example with key = “MONARCHY”

M O N A R
C H Y B D
E F G I K
L P Q S T
U V W X Z

• The key letters (M, O, N, A, R, C, H, Y) come first.
• Then we add the rest of the alphabet, skipping duplicates.
• I and J are merged (so only one appears).

This grid is the main part of the Playfair cipher. Both sender and receiver need the same key to encrypt and decrypt.

Step 2: Preparing the Message

Before encrypting, the plaintext must be cleaned and split into pairs of letters.

Rules:

1. Remove spaces, punctuation, and numbers.
2. Convert everything to uppercase
3. Replace J with I.
4. Split into pairs (digraphs).
5. If both letters in a pair are the same, insert an X in between.
6. If there’s an odd number of letters, add an X at the end.

Example 1:

👉 Example with plaintext = “ATTACK”

1. Clean: ATTACK → ATTACK
2. Pairs: AT TA CK
3. No duplicates inside pairs → valid
4. Length is even → no padding needed

Final digraphs: AT | TA | CK

Example 2:

Another example: plaintext = “BALLOON”

• Clean: BALLOON
• Pairs: BA LL OO N
• Adjust duplicates: BA LX LO ONX
  Final digraphs: BA | LX | LO | ON | X

Step 3: Encryption Rules

Now comes the fun part! Each pair of letters is encrypted using the Playfair Square.

Let’s say we’re encrypting the digraph (A, T).

There are three possible cases:

Rule 1: Same Row

If both letters are in the same row, replace each with the letter to its right (wrap around if needed).

Example: (A, R) in row 1:

M O N A R

• A → R (right of A)
• R → M (wrap around)
  Encrypted: RM

Rule 2: Same Column

If both letters are in the same column, replace each with the letter below it (wrap around if needed).

Example: (M, C) in column 1:

M
C
E
L
U

• M → C
• C → E
  Encrypted: CE

Rule 3: Rectangle Rule

If the letters form the corners of a rectangle, replace each with the letter in the same row but in the other column.

Example: (A, T)

M O N A R
L P Q S T

• A (row 1, col 4) → T (row 1, col 5)
• T (row 4, col 5) → S (row 4, col 4)
  Encrypted: TS

Step 4: Decryption Rules

Decryption is just the reverse:

1. Same row: Replace with the letter to the left.
2. Same column: Replace with the letter above.
3. Rectangle: Swap corners again.

Padding Xs are removed at the end if they were artificially added.

Python Implementation

Let’s now look at the code and understand it step by step.

1. Generating the Playfair Square

def generate_playfair_square(key):
    key = "".join([c.upper() for c in key if c.isalpha()])
    key = key.replace("J", "I")
    seen = set()
    square = []
    for c in key + string.ascii_uppercase:
        if c not in seen and c != "J":
            seen.add(c)
            square.append(c)
    return [square[i * 5 : (i + 1) * 5] for i in range(5)]

This function:

• Cleans the key (removes non-letters, converts to uppercase, replaces J with I).
• Fills a 5x5 matrix with unique letters.
• Returns the matrix (Playfair square).

2. Preparing the Text

def prepare_text(text, for_encrypt=True):
    text = "".join([c.upper() for c in text if c.isalpha()])
    text = text.replace("J", "I")
    result = ""
    i = 0
    while i < len(text):
        a = text[i]
        b = text[i + 1] if i + 1 < len(text) else "X"
        if a == b:
            result += a + "X"
            i += 1
        else:
            result += a + b
            i += 2
    if len(result) % 2 != 0:
        result += "X"
    return result

This ensures:

• Only letters are kept.
• Pairs are formed properly.
• Same letters in a pair are separated by X.
• Odd length words get padded with X.

Example:
ATTACK → AT TA CK (already valid)

3. Finding Letter Positions

def find_position(square, char):
    for i, row in enumerate(square):
        if char in row:
            return i, row.index(char)
    return None

👉 Returns the row and column of a character in the Playfair square.

4. Encrypting the Message

def playfair_encrypt(plaintext, key):
    square = generate_playfair_square(key)
    text = prepare_text(plaintext)
    result = ""
    for i in range(0, len(text), 2):
        a, b = text[i], text[i + 1]
        r1, c1 = find_position(square, a)
        r2, c2 = find_position(square, b)
        if r1 == r2:  # same row
            result += square[r1][(c1 + 1) % 5] + square[r2][(c2 + 1) % 5]
        elif c1 == c2:  # same column
            result += square[(r1 + 1) % 5][c1] + square[(r2 + 1) % 5][c2]
        else:  # rectangle rule
            result += square[r1][c2] + square[r2][c1]
    return result

👉 This applies the Playfair rules we discussed.

5. Decrypting the Message

def playfair_decrypt(ciphertext, key):
    square = generate_playfair_square(key)
    result = ""
    for i in range(0, len(ciphertext), 2):
        a, b = ciphertext[i], ciphertext[i + 1]
        r1, c1 = find_position(square, a)
        r2, c2 = find_position(square, b)
        if r1 == r2:  # same row
            result += square[r1][(c1 - 1) % 5] + square[r2][(c2 - 1) % 5]
        elif c1 == c2:  # same column
            result += square[(r1 - 1) % 5][c1] + square[(r2 - 1) % 5][c2]
        else:  # rectangle rule
            result += square[r1][c2] + square[r2][c1]
    return result

👉 Same logic, but reversed.

6. Running the Program

if __name__ == "__main__":
    key = "MONARCHY"
    plaintext = "ATTACK"

encrypted = playfair_encrypt(plaintext, key)
    decrypted = playfair_decrypt(encrypted, key)
    print(f"Key : {key}")
    print(f"Plaintext : {plaintext}")
    print("Encrypted:", encrypted)
    print("Decrypted:", decrypted)

💡 Example Output:

Key : MONARCHY
Plaintext : ATTACK
Encrypted: RRFVSZ
Decrypted: ATTACKX

Notice how the decrypted text has an extra X. That’s because of the padding rule we discussed.

Why Learn Playfair Today?

Even though the Playfair Cipher is not secure by modern standards, it’s still important because:

• It introduces concepts like substitution, digraphs, and key-based encryption.
• It shows how historical cryptography worked before computers.
• It’s a great way to practice coding algorithms step by step.

Previously in Our React Series . . .

• Learned JSX (like writing HTML in JavaScript) Created your first reusable components
• Passed props between components Handled user events (remember that clickable counter?)

Now, imagine this:

• What if the user is logged in?
• What if they have no notifications?
• What if they clicked a button?

You guessed it. This is where Conditional Rendering comes in. Let’s break it down, step-by-step.

What is Conditional Rendering?

Conditional rendering is how your app decides what to show and what not to show, based on certain conditions.

It’s like your app is asking: “Should I show this? Yes or no?”

Just like if statements in JavaScript — but now inside your React components.

Basic Example with if-else

function WelcomeMessage({ isLoggedIn }) {
    if (isLoggedIn) {
        return <h2>Welcome back, Pavan!</h2>;
    } else {
        return <h2>Please log in to continue.</h2>;
    }
}

What’s happening:

• We’re checking if the user is logged in.
• Based on that, we return different JSX.

Simple and clean, right?

Shorter Version: Ternary Operator

function WelcomeMessage({ isLoggedIn }) {
    return (
        <h2>{isLoggedIn ? "Welcome back!" : "Please log in."}</h2>
    );
}

Syntax:

condition ? show this : show that

It’s like a mini if-else on one line.

Show Only If True (Using &&)

Sometimes, you only want to show something if a condition is true, and hide it completely otherwise.

function Notification({ hasMessage }) {
    return (
        <div>
            {hasMessage && <p>You have a new message!</p>}
        </div>
    );
}

If hasMessage is false, React won’t render anything — not even empty space. That’s the magic of &&.

Pro Tip: Avoid Too Much Logic in JSX

// Not great for readability
{isLoggedIn && age > 18 && user.hasPermission && <SecretPanel />}

Better:

const canAccess = isLoggedIn && age > 18 && user.hasPermission;

return canAccess && <SecretPanel />;

Keep it clean. Your future self will thank you.

Mini Project: Show/Hide Password Feature

Let’s use everything we’ve learned to build a real feature — one you see in almost every login form.

What we’re building:

• A password input field
• A checkbox to toggle visibility of the password

Why It’s Cool:

• Uses state with useState
• Uses event handling
• Uses conditional rendering to switch input types

Final Code:

import React, { useState } from 'react';

function PasswordToggle() {
    const [showPassword, setShowPassword] = useState(false);
    const handleCheckboxChange = () => {
        setShowPassword(prev => !prev);
    };
    
return (
        <div style={{ maxWidth: '300px', margin: 'auto', padding: '20px', border: '1px solid #ccc', borderRadius: '8px' }}>
            <h2>Password Input</h2>
            <input 
                type={showPassword ? 'text' : 'password'} 
                placeholder="Enter your password"
                style={{ width: '100%', padding: '10px', fontSize: '16px', marginBottom: '10px' }}
            />
            <div>
                <label>
                    <input 
                        type="checkbox" 
                        checked={showPassword} 
                        onChange={handleCheckboxChange}
                    /> Show Password
                </label>
            </div>
        </div>
    );
}
export default PasswordToggle;

What’s Happening:

• We use useState(false) to track whether the password is shown or hidden.
• Based on that, we conditionally render the input type: text or password.
• The checkbox toggles the state.

You’ve just built a real, user-friendly feature.

Summary : Here’s what you learned today

• How to show/hide UI parts with:
• if-else
• Ternary (? :)
• &&
• How to cleanly organize your logic
• How to apply it all in a mini project

What’s Next?

Rendering Lists in React — Mapping Your Way to Dynamic UIs

Real apps deal with lots of data: to-do lists, messages, users, posts…
So let’s learn how to loop through arrays and render multiple components dynamically.

Thank you for being a part of the community

Before you go:

• Be sure to clap and follow the writer ️👏️️
• Follow us: X | LinkedIn | YouTube | Newsletter | Podcast | Twitch
• Start your own free AI-powered blog on Differ 🚀
• Join our content creators community on Discord 🧑🏻‍💻
• For more content, visit plainenglish.io + stackademic.com

Chapter 7 : Conditional Rendering Showing the Right Things at the Right Time was originally published in JavaScript in Plain English on Medium, where people are continuing the conversation by highlighting and responding to this story.

Previously, on React 101…

You learned how to create your first React component and how JSX works like magic — mixing HTML and JavaScript into one smooth experience.

Now let’s go one step further and learn how to pass data between components using props.

What Are Props?

Props (short for properties) are how components receive data from other components.

Think of it like this:
If a component is a function, props are the parameters you pass into it.

Analogy:

Imagine you’re giving a gift box (component) to a friend.
The items inside the box? Those are the props — the data you’re handing over.

A Real Example

Let’s say you have a component that displays a greeting.

Greeting.js:

function Greeting(props) {
    return <h1>Hello, {props.name}</h1>;
}

export default Greeting;

Here, props.name is the data we’re passing into the component.

Now in App.js:

import Greeting from './Greeting';

function App() {
    return (
        <div>
            <Greeting name="Pavan" />
            <Greeting name="Maya" />
        </div>
    );
}

When you run this, it shows:

Hello, Pavan  
Hello, Maya

Boom! Components are now talking to each other — and you’re passing dynamic data.

Let’s Break It Down

<Greeting name="Pavan" />

• This is how we pass a prop
• name="Pavan" is a prop being sent to the Greeting component

function Greeting(props) {

• This is how we receive the prop in the component

{props.name}

• This is how we use it inside JSX

Cleaner with Destructuring

Instead of writing props.name, we can use JavaScript destructuring to make it cleaner:

function Greeting({ name }) {
    return <h1>Hello, {name}</h1>;
}

Same output. Less typing. Win-win.

You Can Pass More Than Just Text

Props can be numbers, booleans, arrays, objects, or even functions!

Example:

function UserCard({ name, age }) {
    return (
        <div>
            <h2>{name}</h2>
            <p>Age: {age}</p>
        </div>
    );
}

function App() {
    return <UserCard name="Pavan" age={21} />;
}

Try This: Create a QuoteCard Component

QuoteCard.js:

function QuoteCard({ quote, author }) {
    return (
        <div className="quote">
            <p>"{quote}"</p>
            <small>- {author}</small>
        </div>
    );
}

export default QuoteCard;

Use it in App.js:

<QuoteCard
    quote="First, solve the problem. Then, write the code."
    author="John Johnson"
/>

This is how React lets you reuse components and change their behavior based on the props you pass.

A Few Props Gotchas

• Props are read-only. You can’t change them inside the child component.
• Props must be passed from parent → child, not the other way around.
• If you forget to pass a prop, React won’t crash — it’ll just show undefined.

Recap

• Props are how components talk to each other.
• You pass props like HTML attributes.
• Inside the component, you use props.propName (or destructure).
• Props make components reusable and dynamic.

Up Next: Make Your Components Smart with useState

Props let you pass data in. But what if you want components to store and manage their own data — like a counter or a to-do list?

That’s where useState comes in.

In the next blog: “React’s useState Hook: Giving Memory to Your Components”

Got Questions?

Drop them in the comments or hit me up — there’s no such thing as a silly question here!

Thank you for being a part of the community

Before you go:

• Be sure to clap and follow the writer ️👏️️
• Follow us: X | LinkedIn | YouTube | Newsletter | Podcast | Twitch
• Start your own free AI-powered blog on Differ 🚀
• Join our content creators community on Discord 🧑🏻‍💻
• For more content, visit plainenglish.io + stackademic.com

Chapter 4: Understanding Props and How Components Talk to Each Other was originally published in JavaScript in Plain English on Medium, where people are continuing the conversation by highlighting and responding to this story.

Previously, on this Course

So far in this series, we’ve:

• Learned what React is (spoiler: it’s awesome)
• Set up our environment with Create React App or Vite

Now it’s time to build something!

But before we do, let’s talk about JSX — the secret sauce that makes React so cool — and then write our very first React component together.

What is JSX?

JSX stands for JavaScript XML.

Sounds scary? Don’t worry — it’s actually pretty simple.

Here’s the deal:

JSX lets you write HTML-like code inside your JavaScript.

Yes, you read that right. In React, you can write this:

const element = <h1>Hello, React!</h1>;

Looks like HTML, right? But that’s actually JavaScript under the hood.

🤔 Why not just use HTML?

Because you want the power of JavaScript and the structure of HTML — in one place.

JSX combines both. It’s like the best of both worlds.

Let’s take a deeper look at how JSX works:

It looks like HTML

<h1>Hello, World!</h1>

But you can embed JavaScript inside it

const name = "Pavan";
<h1>Hello, {name}!</h1>

Yes, the curly braces {} let you run JavaScript inside your HTML-like JSX.

You can do things like:

const age = 21;
<p>I am {age >= 18 ? 'an adult' : 'a kid'}.</p>

Important JSX Rules

1. Return only one parent element
   This is wrong:

return (
  <h1>Hello</h1>
  <p>World</p>
);

This is right:

return (
  <div>
    <h1>Hello</h1>
    <p>World</p>
  </div>
);

Use a wrapper like <div> or React Fragment (<> </>) to group elements.

2. Use className instead of class
Why? Because class is a reserved word in JavaScript.

<div className="container">This works</div>

Let’s Build Your First React Component!

What’s a Component?

A component is a reusable block of UI.

Think of it like a LEGO piece. You build a few of them, and then piece them together to build your whole app.

Step-by-Step: Create a Simple Component

Open App.js inside your React project and replace its content with this:

import React from 'react';function Greeting() {
 
const name = "Pavan";

return (
    <div>
      <h1>Hello, {name} </h1>
      <p>Welcome to your first React component!</p>
    </div>
  );
}
export default Greeting;

Then update index.js to use it:

import React from 'react';
import ReactDOM from 'react-dom/client';
import Greeting from './App';  // importing the component

const root = ReactDOM.createRoot(document.getElementById('root'));
root.render(<Greeting />);

Open the browser :

Hello, Pavan
Welcome to your first React component!

Congrats you just built your first React component!

Let’s Break It Down

function Greeting() {

}

This is a functional component — the most common type in modern React.

const name = "Pavan";

Regular JavaScript variable.

<h1>Hello, {name} </h1>

This is JSX in action. We’re mixing JavaScript inside what looks like HTML.

export default Greeting;

This lets us use the component elsewhere in our app — like a puzzle piece.

Try This Mini Challenge

Want to practice?

Add another component called Quote that displays a quote of the day.

function Quote() {
  return (
    <blockquote>
      “First, solve the problem. Then, write the code.” – John Johnson
    </blockquote>
  );
}

Then import and use it inside your Greeting component like this:

<Quote />

That’s component composition — building UIs like stacking bricks!

In a Nutshell

• JSX lets you write HTML inside JavaScript
• Curly braces {} let you use variables and logic inside JSX
• Components are the heart of every React app
• You just built your first real component!

Congrats! You now understand what JSX is and how to build your first React component the building blocks of every React app. With this foundation, you’re ready to start passing data between components and making your UI truly dynamic

Next Up -

Let’s Dive Into Props: How React Components Talk to Each Other and Share Data

Thank you for being a part of the community

Before you go:

• Be sure to clap and follow the writer ️👏️️
• Follow us: X | LinkedIn | YouTube | Newsletter | Podcast | Twitch
• Start your own free AI-powered blog on Differ 🚀
• Join our content creators community on Discord 🧑🏻‍💻
• For more content, visit plainenglish.io + stackademic.com

Chapter 3 : Understanding JSX & Building Your First React Component was originally published in JavaScript in Plain English on Medium, where people are continuing the conversation by highlighting and responding to this story.

You’ve heard the hype about React. You know it’s powering big names like Netflix and Instagram. Now it’s time to build something yourself.

But wait… where do you even start?

Don’t worry this post is your step-by-step guide to setting up your very first React project.

No experience? No problem. Let’s do this together.

1. Before We Begin What Do You Need?

To build React apps, you’ll need two things:

Node.js

Think of it as the engine that runs your JavaScript code outside the browser.

npm (Node Package Manager)

It helps you install useful tools and libraries like React!

2. Install Node.js and npm (One-Time Setup)

Follow these steps:

1. Go to https://nodejs.org
2. Download the LTS version (it’s the stable one)
3. Install it just like any other app

To make sure it worked:

Open your terminal or Command Prompt and run:

node -v
npm -v

If you see version numbers, you’re good to go!

3. Creating Your First React App (Using CRA)

React gives you a tool called Create React App (CRA) that sets up everything for you.

It’s like ordering a pizza with all toppings no need to make the dough from scratch.

Steps:

1. Open your terminal
2. Run:

npx create-react-app my-first-app

npx runs the command without installing it globally
create-react-app sets up your entire React project
my-first-app is the folder name for your project

This may take a couple of minutes grab a chai or coffee.

Start the app:

Once it’s done, run:

cd my-first-app
npm start

Your default browser should open up with a page that says:

“Edit src/App.js and save to reload."

Boom. You’ve just created your first React app!

4. Understanding the Project Structure

Let’s peek inside the project folder.

Here are the 3 files you’ll touch the most as a beginner:

my-first-app/
├── public/
│   └── index.html     Main HTML file
├── src/
│   ├── index.js       Entry point of the app
│   └── App.js         Your main component

What these files do:

• index.html — The only HTML file. React injects everything here.
• index.js — Starts the React app and connects it to index.html
• App.js — Your main React component (you’ll write most code here for now)

5. A Faster, Modern Way with Vite

Create React App is beginner-friendly, but it can be a bit slow to start.

Meet Vite a modern tool that’s super fast and better for new projects.

To use Vite:

npm create vite@latest my-vite-app

Then follow the prompts:

• Choose a framework: React
• Choose a variant: JavaScript

Then run:

cd my-vite-app
npm install
npm run dev

That’s it your Vite-powered React app is live in seconds!

Pro Tip: Which One Should You Use?

Which tool should you use?

• Create React App (CRA): Perfect for simplicity and first-time learners. If you want a straightforward setup and don’t want to worry about extra configuration, start here.
• Vite: Great for a faster development experience and modern features. Once you’re comfortable with React basics, try Vite for speedier builds and a more modern workflow.

If you’re just starting out, CRA is perfect. Once you’re confident, try Vite.

Recap

• Installed Node.js and npm
• Created a React app using CRA
• Learned what each file does
• Bonus: Discovered Vite

You’re now officially set up to start building with React.

Up Next: Let’s Build Something Cool

In the next blog, we’ll dive into:

React Components: Your First LEGO Block of UI

You’ll learn how to create your first custom component and make your app do something!

Got Stuck?

If something didn’t work, don’t worry it happens to all of us.
Leave a comment and I’ll help you out. Or Google it that’s what real devs do anyway.

See You in the Next Lesson!

Give yourself a pat on the back you’ve set up your first React project.
Ready to dive deeper? Blog 3 is coming up: “Understanding JSX & Building Your First Component”

Thank you for being a part of the community

Before you go:

• Be sure to clap and follow the writer ️👏️️
• Follow us: X | LinkedIn | YouTube | Newsletter | Podcast | Twitch
• Start your own free AI-powered blog on Differ 🚀
• Join our content creators community on Discord 🧑🏻‍💻
• For more content, visit plainenglish.io + stackademic.com

Chapter 2 : Setting Up React the Easy Way, No Headaches, Just Code was originally published in JavaScript in Plain English on Medium, where people are continuing the conversation by highlighting and responding to this story.

Imagine this: You’re using Instagram. You like a photo, post a comment, and scroll endlessly all without the page ever reloading. Kinda magical, right?

That’s React working behind the scenes.

In this blog, we’ll break down what React is, why it’s so popular, and how it’s different from other ways of building websites all in plain English. No fancy jargon. Just simple, beginner-friendly explanations.

So, What is React?

React is a tool or more technically, a JavaScript library that helps developers build the parts of a website that users interact with.

Think of things like buttons, text, images, forms basically, everything you see and click on a website. That’s the UI, or User Interface. React makes building these interfaces super smooth.

But here’s where it gets cooler: React is especially good for building Single Page Applications (SPAs).

Wait… What’s a Single Page Application?

A SPA is a website where the page doesn’t reload every time you click something. Only the part that changed gets updated. That’s why Instagram or Gmail feel so fast — they’re using React (or something like it).

In simple terms:
React helps build websites that are fast, interactive, and don’t reload the whole page every time something changes.

A Quick History Lesson

Let’s keep it short and sweet:

• Created By: Jordan Walke (engineer at Facebook)
• Released: 2013
• Used By: Facebook, Instagram, Netflix, WhatsApp Web — yeah, all the big names.

React was created to solve a problem: building complex, dynamic websites without losing your mind.

Why Developers Love React (And You Might Too)

Here are the top features that make React super beginner-friendly:

1. Component-Based

React lets you break your UI into tiny reusable pieces — like LEGO blocks. Build once, use everywhere.

2. Reusable

Create a button once, use it on 10 different pages. Less code, fewer bugs.

3. Virtual DOM

Instead of changing the whole page every time, React uses a virtual DOM (more on this next) to update only what changed. It’s fast. Like, really fast.

4. Super Efficient

Your app stays speedy, even as it grows. That’s why big apps like Facebook use it.

Let’s Talk About the Virtual DOM (Without Getting Bored)

Okay, “Virtual DOM” sounds super techy, but it’s actually a genius idea and surprisingly easy to get.

Here’s an analogy:

Imagine your website is a painting.
If you smudge one corner, do you repaint the whole thing?
Of course not you fix just the smudge.

That’s exactly what React does.

Real Explanation:

• The DOM (Document Object Model) is like a tree structure of your webpage.
• React creates a virtual copy of this tree in memory — the Virtual DOM.
• When something changes (like a button click), React compares the new virtual DOM to the old one, sees what changed, and only updates that part of the real DOM.

This is called “diffing and reconciling” and it makes React fast and efficient.

React vs Vanilla JavaScript vs Other Frameworks

Here’s how React stacks up against the old-school way (vanilla JS) and other frameworks like Angular:
React

• Speed: Very fast, thanks to the virtual DOM.
• Structure: Component-based, making code organized and reusable.
• DOM Updates: Smart updates — only changes what’s needed.
• Reusability: High; build once, use everywhere.
• Learning Curve: Easy to medium for most beginners.

Vanilla JavaScript

• Speed: Fast, but reloads the whole page for changes.
• Structure: No built-in structure; code can get messy.
• DOM Updates: Full page reloads, less efficient.
• Reusability: Low; lots of repeated code.
• Learning Curve: Easy to start, but harder to manage big projects.

Angular / Other Frameworks

• Speed: Fast, with smart updates and optimizations.
• Structure: Very structured; lots of rules and patterns.
• DOM Updates: Smart or virtual DOM for efficient changes.
• Reusability: Medium to high, depending on the framework.
• Learning Curve: Medium to hard; more concepts to learn.

TL;DR: React is faster and more organized than vanilla JavaScript, and much easier to learn than frameworks like Angular.

Try React Right Now (No Setup Needed)

Here’s a quick React example you can try in CodeSandbox or in your local setup:

function App() {
  const [count, setCount] = React.useState(0);

return (
    <div
      <h1You clicked {count} times</h1
      <button onClick={() = setCount(count + 1)}
        Click me!
      </button
    </div
  );
}

Every time you click the button, the number increases. But notice: the page doesn’t reload!
Just the number changes. That’s React doing its thing.

In a Nutshell

• React is a tool for building modern, fast, user-friendly websites.
• It uses components and a virtual DOM to make your life easier.
• It’s used by all the cool companies.
• It’s beginner-friendly and growing like crazy.

What’s Next?

In the next post, we’ll set up your first React project (the easiest way) and write your first component together.

You’ll go from “What is React?” to “Look ma, I built a thing!” — in no time.

Stay Tuned

Follow me for more posts in this React for Beginners series. Next up:

“Setting Up React the Easy Way: No Headaches, Just Code”

Thank you for being a part of the community

Before you go:

• Be sure to clap and follow the writer ️👏️️
• Follow us: X | LinkedIn | YouTube | Newsletter | Podcast | Twitch
• Start your own free AI-powered blog on Differ 🚀
• Join our content creators community on Discord 🧑🏻‍💻
• For more content, visit plainenglish.io + stackademic.com

Chapter 1 : React 101 What It Is, Why It’s Cool, and Why You Should Care was originally published in JavaScript in Plain English on Medium, where people are continuing the conversation by highlighting and responding to this story.

Typing www.google.com into a browser and pressing Enter kicks off a complex and coordinated series of steps involving the browser, operating system, DNS, networking stack, and remote servers.

This process can be logically broken down with the OSI model and system internals.

🔸 Step 0: User Interaction Begins

You open a browser (e.g., Chrome) and type www.google.com in the address bar and hit Enter.

🔹 Layer 7: Application Layer (Browser, HTTP/HTTPS)

🔸 Browser Pre-checks:

• Browser checks if the page is in the HTTP cache (memory/disk).
• If not, it begins preparing an HTTP GET request for https://www.google.com/.

🔸 DNS Resolution:

1. Browser/OS first checks:

• DNS cache in the browser
• OS-level DNS cache
• /etc/hosts file (Linux/macOS)

2. If not found:

• A DNS query is sent to a recursive resolver (usually provided by the ISP or 8.8.8.8 for Google DNS).
• If the resolver doesn’t have the answer:
• It queries the root server → finds .com TLD server
• TLD server → finds google.com nameserver
• Authoritative nameserver → replies with A/AAAA record (IPv4/IPv6)
• Response: www.google.com → 142.250.195.100

🔹 Layer 6: Presentation Layer (Encoding, Encryption)

🔸 Role:

• Handles formatting and translation: e.g., converting character sets (ASCII, UTF-8), compression (gzip), and encryption.
• Because HTTPS is used, data will be encrypted via TLS.

🔸 TLS Handshake:

• Key Exchange:
• Typically uses Elliptic Curve Diffie-Hellman (ECDHE) to securely generate a shared secret.
• Both sides derive a symmetric session key to encrypt further communication.

At this point, communication is secure.

🔹 Layer 5: Session Layer (TLS Session)

• The session layer maintains this secure connection (TLS session).
• If you revisit Google soon, the browser may reuse the TLS session using a session ticket or session ID, skipping the full handshake.

🔹 Layer 4: Transport Layer (TCP)

🔸 TCP 3-Way Handshake (before TLS):

1. SYN: Client sends a TCP segment with SYN flag to open a connection.
2. SYN-ACK: Server replies with SYN + ACK.
3. ACK: Client sends ACK.

• Source port: Random ephemeral port (e.g., 49500)
• Destination port: 443 (HTTPS)

TCP handles:

• Segmentation: Splitting HTTP data into segments.
• Reliability: Retransmission, ordering, error-checking via checksums.
• Flow control: via window size.
• Congestion control: via slow start, congestion avoidance, etc.

🔹 Layer 3: Network Layer (IP, Routing)

🔸 IP Packet:

• Now the client builds an IP packet:
• Source IP: Client’s public IP (assigned by ISP/NAT)
• Destination IP: Google’s server IP
• Protocol: TCP
• TTL, Checksum, and Fragment Offset are set

🔹 Layer 2: Data Link Layer (Ethernet, MAC Addressing)

🔸 Framing:

• IP packets are encapsulated into Ethernet frames.
• Ethernet frame includes:
• Source MAC: Client NIC
• Destination MAC: Router’s MAC
• Payload: IP packet

🔸 ARP (if needed):

• If the MAC of the router (default gateway) isn’t known, ARP is used:
• Broadcast: “Who has IP 192.168.1.1?”
• Router replies with its MAC.

🔹 Layer 1: Physical Layer (Bits, Transmission Media)

🔸 Signal Transmission:

• Ethernet: Bits converted into electrical pulses
• Wi-Fi: Radio signals transmitted through antenna
• Fiber optics: Light pulses for long-distance communication

🔸 Journey:

• Bits → NIC → Router → Modem → ISP → Undersea cables → Backbone routers → Google Data Center

🏢 On Google’s Server

1. Load balancer directs traffic to a nearby server (using Anycast).
2. Google’s edge server terminates TLS connection.
3. Processes the HTTP request via HTTP server (e.g., gws).
4. Returns:

• HTML page
• CSS, JS, fonts, etc.

All assets may come from Google’s CDN (Content Delivery Network), such as fonts.googleapis.com.

🔁 Reverse Path

The response travels back to the client:

• Same TCP connection (persistent)
• IP packet → Ethernet frame → Wi-Fi signal → Laptop

🖥️ Browser Rendering Engine

1. HTML Parsing → DOM tree
2. CSS Parsing → CSSOM tree
3. Combine → Render Tree
4. Layout → calculate positions
5. Painting → draw pixels
6. Compositing → display on screen

✅ TL;DR

• Browser checks DNS (via system or resolver).
• DNS gives IP → TCP handshake → TLS handshake.
• Encrypted HTTP request sent to Google.
• Google’s server responds with the homepage HTML.
• Browser parses and renders the page.
• All of this follows the OSI model from Application to Physical layer.

“It’s a beautiful example of how abstraction layers, distributed systems, encryption, networking, and client rendering all come together seamlessly to serve a single web page in milliseconds.”

You build a React app. You store a value like a username or a theme in the App component. But you need that value way down in a tiny component — maybe a button, inside a card, inside a list, inside a dashboard…

So you do the thing we all do at first:

<App username="Harry">
  <Dashboard username="Harry">
    <Sidebar username="Harry">
      <UserButton username="Harry" />
    </Sidebar>
  </Dashboard>
</App>

That, my friend, is called prop drilling.

It Works, But It Hurts

It’s like passing a secret note in class by handing it through 4 desks. What if there was a way to broadcast the note so only the person who cares gets it?

That’s where useContext walks in — like a walkie-talkie in a sea of handwritten notes.

What is useContext?

useContext is a hook that lets your components listen in to a shared value, without it being manually passed down through props.

In other words:

• You create a context, a kind of shared room.
• You provide a value into that room.
• Any component inside that room can grab the value directly, no prop chain needed.

Let’s Build It Together

Step 1: Create the Context

This is like setting up the walkie-talkie channel.

import { createContext } from "react"

const UserContext = createContext();

Step 2: Provide the Value

We wrap our component tree and pass the data.

<UserContext.Provider value={"Harry Potter"}>
  <Dashboard />
</UserContext.Provider>

Now anything inside <Dashboard /> (and its children) can access "Harry Potter" directly.

Step 3: Consume the Value

Anywhere inside that tree, we grab the value like this:

import { useContext } from "react";

const username = useContext(UserContext);
console.log(username); // "Harry Potter"

No props. No stress. Just vibes. ✨

A Real-World Analogy

Imagine you’re in an office.

• With props: You give the message to your manager, who passes it to their manager, who passes it down to you. So many layers!
• With context: There’s a bulletin board in the kitchen. You just walk in and read what you need.

That’s useContext.

Real-World Use Cases

You’ll typically use useContext for:

• Authenticated user info
• Theme toggles (light/dark)
• Language settings (i18n)
• Shopping cart items
• Global app config (API base URL, feature flags)

Mini Project: A Simple “Sign In and Greet” App

Goal:

• You’ll build a basic sign-in interface.
• Once the user signs in, show a personalized greeting on any nested component.
• All without prop drilling — thanks to useContext.

File Structure:

/src
  ├── App.js
  ├── UserContext.js
  ├── SignIn.js
  ├── Dashboard.js
  └── WelcomeBanner.js

1️. UserContext.js — Create Your Context

import { createContext } from "react";

export const UserContext = createContext(null);

2️. App.js — Provide the User State

import React, { useState } from "react";
import { UserContext } from "./UserContext";
import SignIn from "./SignIn";
import Dashboard from "./Dashboard";

function App() {
  const [user, setUser] = useState(null);
  return (
    <UserContext.Provider value={{ user, setUser }}>
      {!user ? <SignIn /> : <Dashboard />}
    </UserContext.Provider>
  );
}
export default App;

3️. SignIn.js — Let User “Sign In”

import React, { useContext, useState } from "react";

import { UserContext } from "./UserContext";

function SignIn() {
  const { setUser } = useContext(UserContext);
  const [username, setUsername] = useState("");
  const handleSignIn = () => {
    if (username.trim() !== "") {
      setUser(username);
    }
  };

  return (
    <div style={{ textAlign: "center", marginTop: "50px" }}>
      <h2>Sign In</h2>
      <input
        type="text"
        placeholder="Enter your name"
        value={username}
        onChange={(e) => setUsername(e.target.value)}
      />
      <button onClick={handleSignIn}>Sign In</button>
    </div>
  );
}

export default SignIn;

4️. Dashboard.js — Protected After Sign In

import React from "react";
import WelcomeBanner from "./WelcomeBanner";

function Dashboard() {
  return (
    <div style={{ padding: "20px" }}>
      <h2>Dashboard</h2>
      <WelcomeBanner />
    </div>
  );
}
export default Dashboard;

5. WelcomeBanner.js — Access User Without Props

import React, { useContext } from "react";

import { UserContext } from "./UserContext";

function WelcomeBanner() {
  const { user } = useContext(UserContext);
  return <h3>Welcome, {user}!</h3>;
}

export default WelcomeBanner;

Final Output:

When you run this app:

• You’ll see a sign-in input and button.
• After entering your name and clicking Sign In, it takes you to the dashboard.
• Deep inside the dashboard, the WelcomeBanner shows your name — without it ever being passed down manually.

TL;DR — Summery

• useContext stops the madness of prop drilling.
• Think of it like a shared channel all components can tune into.
• Simple to set up, even more satisfying to use.

What You Just Learned

• How to store shared user data in React.
• How to let any component access or update it using useContext.
• How to keep things cleaner and DRY (Don’t Repeat Yourself) in your component tree.

Thank you for being a part of the community

Before you go:

• Be sure to clap and follow the writer ️👏️️
• Follow us: X | LinkedIn | YouTube | Newsletter | Podcast | Twitch
• Start your own free AI-powered blog on Differ 🚀
• Join our content creators community on Discord 🧑🏻‍💻
• For more content, visit plainenglish.io + stackademic.com

The Power of React useContext Hook was originally published in JavaScript in Plain English on Medium, where people are continuing the conversation by highlighting and responding to this story.

If you’ve taken your first steps into React and met useState, then you've probably crossed paths with its more mysterious sibling: useEffect

And it looked like this:

useEffect(() => {
  // something important?
}, []);

You paused. You stared. And then you muttered: “What the heck is this thing?” Don’t worry we’ve all been there.

useEffect looks cryptic at first, But I promise, it’s not as scary as it seems.

So let’s break it down not like a robot quoting documentation, but like a real human explaining it to another human… over a cup of chai or coffee.

What is useEffect?

Let’s imagine you built a cool component. It renders. Great. But now you want to:

• Fetch data from an API
• Update the document title
• Set a timer
• Listen events

Basically, you want to do something after React puts your UI on the screen.

That’s where useEffect comes in.

useEffect lets you run code after your component renders.

It’s like saying: “Hey React, once you're done showing stuff on screen , I’ve got some extra work to do.”

Basic Syntax

useEffect(() => {
  // do something here
}, [dependencies]);

Here’s how to read that:

• The first argument (a function) is what you want to run.
• The second argument (an array) tells React when to run it.

Example 1: Hello, Console!

import { useEffect, useState } from 'react';

function App() {
  const [count, setCount] = useState(0);
  useEffect(() => {
    console.log("Component rendered!");
  });
  return (
    <button onClick={() => setCount(count + 1)}>
      Clicked {count} times
    </button>
  );
}

What happens here?

• You click the button → count changes → component re-renders
• useEffect runs after every render

Neat. But what if we only want it to run once?

Example 2: Run Only on Mount (Just Once)

useEffect(() => {
  console.log("Runs only once ");
}, []);

That empty array means:

“Only run this effect on the first render, and never again.”

Perfect for:

• Fetching API data when the page loads
• Connecting to a WebSocket
• Setting up a listener

Example 3: Fetching Data on Load

useEffect(() => {
  fetch("https://jsonplaceholder.typicode.com/users")
    .then(res => res.json())
    .then(data => console.log(data));
}, []);

Boom. You’ve got yourself an API call that runs when the component appears.

Example 4: Reacting to Changes

useEffect(() => {
  console.log(`Count changed to: ${count}`);
}, [count]);

Now, this only runs when count changes. Not on every render. Just when that specific piece of state updates.

That’s what we mean when we say “dependencies.” You’re telling React: “Run this code only if these things change.”

Example 5 : Cleanup

Sometimes your effect creates something that needs to be cleaned up like a timer or event listener.

Use return inside your useEffect to define the cleanup function

useEffect(() => {
  const timer = setInterval(() => {
    console.log("Tick...");
  }, 1000);

return () => {
    clearInterval(timer);
    console.log("Cleanup done!");
  };
}, []);

This:

• Starts the timer on mount
• Clears it when the component unmounts

This avoids memory leaks.

TL;DR : When Does useEffect Run?

• No array at all?
  That means useEffect runs after every single render. Initial load, state updates, props changes — boom, it runs every time.
• Empty array []?
  This tells React: “Hey, just run this effect once, when the component mounts.”
• Array with dependencies like [count]?
  Now you’re saying: “Run this effect when count changes.”
  So it’ll run once on the first render, and again only when count changes in the future.

Final Practice

Let’s wrap up with a fun little project

Lets build a textarea where

• Users can type freely.
• A character count updates as they type.
• The message gets “autosaved” to local storage every few seconds.

import React, { useState, useEffect } from 'react';

function AutoSaveNote() {
  const [text, setText] = useState('');
  const [saved, setSaved] = useState(false);

  // Load saved text from local storage on first render
  useEffect(() => {
    const savedNote = localStorage.getItem('autosave-note');
    if (savedNote) {
      setText(savedNote);
    }
  }, []);

  // Autosave effect (every 3 seconds)
  useEffect(() => {
    const interval = setInterval(() => {
      localStorage.setItem('autosave-note', text);
      setSaved(true);
      setTimeout(() => setSaved(false), 1000); // Show "Saved!" briefly
    }, 3000);

    return () => clearInterval(interval); // Cleanup
  }, [text]);

  return (
    <div style={{ maxWidth: '400px', margin: '0 auto', fontFamily: 'sans-serif' }}>
      <h2>AutoSave Note</h2>
      <textarea
        rows="6"
        cols="40"
        value={text}
        onChange={(e) => setText(e.target.value)}
        placeholder="Start typing..."
        style={{ width: '100%', padding: '10px', fontSize: '16px' }}
      />
      <p>Characters: {text.length}</p>
      {saved && <p style={{ color: 'green' }}>Saved!</p>}
    </div>
  );
}

export default AutoSaveNote;

Your Turn to Experiment!

Try building:

• A live clock that updates every second
• A scroll listener that hides the navbar on scroll down
• A search box that fetches suggestions as you type (with debouncing!)

Final Thoughts

The beauty of useEffect is that it brings life to your components it lets them do things, not just look a certain way.

If useState gives your component a memory

thenuseEffect gives it a brain.

Don’t be afraid to mess up. Don’t be afraid of the dependency array.
Try, break, fix, repeat. That’s the dev life.

Thank you for being a part of the community

Before you go:

• Be sure to clap and follow the writer ️👏️️
• Follow us: X | LinkedIn | YouTube | Newsletter | Podcast | Twitch
• Start your own free AI-powered blog on Differ 🚀
• Join our content creators community on Discord 🧑🏻‍💻
• For more content, visit plainenglish.io + stackademic.com

React useEffect: The Side Effect Awakens was originally published in JavaScript in Plain English on Medium, where people are continuing the conversation by highlighting and responding to this story.

Let’s be honest when you first start learning React and come across this magical thing called useState it feels... weird.

In the past, you had to use class components with this.state and this.setState(). But with the introduction of React Hooks, managing state in functional components became super clean and straightforward.

const [count, setCount] = useState(0);

So What Even Is State?

Imagine your app is like a whiteboard. You write some stuff on it — like a number or name — and when the user interacts, that stuff might change.

That stuff = state.
It’s just data that your component needs to keep track of.

Examples:

• A counter that goes up when you click a button
• A form where you type your name
• A theme toggle (light/dark)

You need to remember those values. That’s what state does.

Lets Meet useState hook

In React, you use useState to create and update state in functional components. Here’s the magical line:

const [something, setSomething] = useState(initialValue);

Let’s break that down like friends over coffee ☕:

• something is the current value (like a note you’re keeping).
• setSomething is a function that updates it (like a pencil to rewrite your note).
• useState(initialValue) gives it a starting value.

Lets Look into a Classic UseState() Example : A Counter Component

import React, { useState } from 'react';
function Counter() {
  const [count, setCount] = useState(0); // we start at 0
  return (
    <div>
      <p>Count: {count}</p>
      <button onClick={() => setCount(count + 1)}>
        Click Me
      </button>
    </div>
  );
}

What’s happening here?

• We say useState(0) — which means “start at 0”
• React gives us count (the value) and setCount (the changer)
• Every time we click the button, setCount(count + 1) increases the number
• React sees the state changed, and automatically updates the UI 💥

Simple Analogy

Let’s pretend you’re carrying a notebook.

• You write down: count = 0
• Every time you click a button, you erase it and write a new number.

You Can Have Multiple useState Hooks Example :

function Profile() {
  const [name, setName] = useState('');
  const [age, setAge] = useState(20);

return (
    <div>
      <input
        placeholder="Enter your name"
        value={name}
        onChange={(e) => setName(e.target.value)}
      />
      <p>Hello, {name || 'stranger'}!</p>
      <button onClick={() => setAge(age + 1)}>
        Increase Age ({age})
      </button>
    </div>
  );
}

Now your component remembers both name and age.

Warnings — Don’t update state directly

count = count + 1; // ← Bad idea

React won’t know you changed the value. Always use the setCount() function.

State Updates Can Be Delayed

If you’re doing multiple updates back-to-back, React might batch them.

So instead of:

setCount(count + 1);
setCount(count + 1);

Do this instead:

setCount(prev => prev + 1);
setCount(prev => prev + 1); // This will actually add 2!

Using useState( ) with Arrays and Objects

const [todos, setTodos] = useState([]);
setTodos(prev => [...prev, { text: 'Learn useState', done: false }]);

You can store anything — just remember to copy the old state first before updating it (React doesn’t like it when you mutate things directly).

Example Project : Light/Dark Mode Toggle

function ThemeToggle() {
  const [dark, setDark] = useState(false);

  return (
    <div style={{
      background: dark ? '#222' : '#fff',
      color: dark ? '#fff' : '#000',
      padding: '2rem'
    }}>
      <p>{dark ? '🌙 Dark' : '☀️ Light'} Mode</p>
      <button onClick={() => setDark(prev => !prev)}>
        Toggle Theme
      </button>
    </div>
  );
}

What’s Next?

After useState, the next most important Hook is useEffect. That’s what lets you run code when your component loads, updates, or disappears.

Let’s Wrap It Up

So here’s what we’ve learned:

• useState lets you remember stuff in your component.
• It returns a value + a function to change it.
• You can use it as many times as you want.
• It works with numbers, strings, objects, arrays — anything.
• Always use the setter function (setSomething) to update.

Remember This:

State = memory
useState() = a way to make React remember things
Updating state = React redraws the screen with new info

If this helped make things click, share it with someone who’s just starting out — and if you want me to break down useEffect next, drop a comment. 💬

Until then:
Keep coding. Keep learning. React on.

Thank you for being a part of the community

Before you go:

• Be sure to clap and follow the writer ️👏️️
• Follow us: X | LinkedIn | YouTube | Newsletter | Podcast | Twitch
• Start your own free AI-powered blog on Differ 🚀
• Join our content creators community on Discord 🧑🏻‍💻
• For more content, visit plainenglish.io + stackademic.com

React useState() and the Art of State Maintenance was originally published in JavaScript in Plain English on Medium, where people are continuing the conversation by highlighting and responding to this story.