Hey there! Welcome to the first part of our exciting series on building a neural network from scratch using Go. If you’re new to machine learning or Go, don’t worry—we’re going to take this step by step, starting with the foundation: the data. In this article, we’ll dive into the MNIST dataset, a classic collection of handwritten digits that’s perfect for learning the ropes of neural networks. Our goal today is to get the dataset, understand its structure, and write some Go code to read it. Plus, we’ll unpack some key concepts like big and little endian and one-hot encoding along the way.

Here’s what we’ll cover:

• What is the MNIST Dataset? A quick intro to this famous dataset.

• How to Get the MNIST Dataset Where and how to download it.

• The Structure of MNIST Breaking down its binary format.

• Reading MNIST in Go Walking through the code to load the data.

• Key Concepts Explaining big and little endian, one-hot encoding, and alternatives.

• Conclusion Wrapping up and looking ahead.

Let’s get started!

What is the MNIST Dataset?

Imagine you’re teaching a kid to recognize numbers. You’d show them lots of examples of handwritten digits, right? That’s exactly what the MNIST dataset does for machines. MNIST stands for Modified National Institute of Standards and Technology dataset, and it’s a collection of 70,000 grayscale images of handwritten digits (0 through 9). Each image is a tidy 28x28 pixels, and it comes with a label telling us which digit it is.

The dataset is split into two parts:

• Training Set: 60,000 images to teach our neural network.

• Test Set: 10,000 images to check how well it learned.

MNIST is like the "Hello World" of machine learning—simple, well-organized, and widely used. It’s perfect for our first adventure into building a neural network from scratch.

How to Get the MNIST Dataset

Ready to grab the data? Head over to Yann LeCun’s MNIST page. You’ll find four files to download:

• train-images-idx3-ubyte.gz: The 60,000 training images.

• train-labels-idx1-ubyte.gz: The labels for the training images.

• t10k-images-idx3-ubyte.gz: The 10,000 test images.

• t10k-labels-idx1-ubyte.gz: The labels for the test images.

These files are compressed with gzip, so after downloading, you’ll need to unzip them. On a Mac or Linux, you can run gunzip filename.gz in the terminal. On Windows, tools like 7-Zip or WinRAR work great. Once unzipped, you’ll have four binary files with extensions like .idx3-ubyte and .idx1-ubyte. Place them in a folder called mnist/ in your project directory, and we’re good to go!

The Structure of MNIST

Before we jump into coding, let’s peek under the hood of these binary files. MNIST uses a custom format called IDX, and it’s pretty straightforward once you get the hang of it.

Image Files

The image files (train-images-idx3-ubyte and t10k-images-idx3-ubyte) start with a 16-byte header:

• Magic Number (4 bytes): A special number (2051) that identifies the file type.

• Number of Images (4 bytes): 60,000 for training, 10,000 for testing.

• Rows (4 bytes): Always 28.

• Columns (4 bytes): Also 28.

After the header, the pixel data follows: 784 bytes per image (28 × 28), with each byte representing a pixel’s grayscale value from 0 (black) to 255 (white). Picture it as one long row of pixels for each image, like a flattened version of a 28x28 grid.

Label Files

The label files (train-labels-idx1-ubyte and t10k-labels-idx1-ubyte) are simpler, with an 8-byte header:

• Magic Number (4 bytes): 2049 this time.

• Number of Labels (4 bytes): Matches the number of images (60,000 or 10,000).

Then, it’s just one byte per label, giving us the digit (0–9) for each corresponding image.

One catch: all these multi-byte numbers (like the magic number or number of images) are stored in big-endian byte order. Don’t worry if that sounds unfamiliar—we’ll explain it soon!

Reading MNIST in Go

Now for the fun part: let’s write some Go code to read this data. We’ll create functions to load the images and labels, making sure they’re ready for our neural network. The code below is an improved version of what you provided, with better error handling and a cleaner structure.

Create a file called reader.go in a reader package:

package reader

import (
    "encoding/binary"
    "errors"
    "fmt"
    "log"
    "os"
)

const (
    trainingImagesPath = "mnist/train-images.idx3-ubyte"
    trainingLabelsPath = "mnist/train-labels.idx1-ubyte"
    testImagesPath     = "mnist/t10k-images.idx3-ubyte"
    testLabelsPath     = "mnist/t10k-labels.idx1-ubyte"
)

// ReadImages reads both training and test images from MNIST dataset
func ReadImages() (trainingImages [][]float64, testImages [][]float64, err error) {
    trainingImages, err = readMnistImages(trainingImagesPath, 60000)
    if err != nil {
        return nil, nil, err
    }

    testImages, err = readMnistImages(testImagesPath, 10000)
    if err != nil {
        return nil, nil, err
    }

    return trainingImages, testImages, nil
}

// ReadLabels reads both training and test labels from MNIST dataset
func ReadLabels() (trainingLabels [][]float64, testLabels [][]float64, err error) {
    trainingLabels, err = readMnistLabels(trainingLabelsPath, 60000)
    if err != nil {
        return nil, nil, err
    }

    testLabels, err = readMnistLabels(testLabelsPath, 10000)
    if err != nil {
        return nil, nil, err
    }

    return trainingLabels, testLabels, nil
}

// Generic function to read image data from a file
func readMnistImages(filepath string, expectedImages uint32) ([][]float64, error) {
    // Open the file
    file, err := os.Open(filepath)
    if err != nil {
        log.Fatal(err)
    }
    defer file.Close()

    // Read the header
    header := make([]byte, 16)
    _, err = file.Read(header)
    if err != nil {
        return nil, err
    }

    // Parse header information
    magicNumber := binary.BigEndian.Uint32(header[0:4])
    numImages := binary.BigEndian.Uint32(header[4:8])
    numRows := binary.BigEndian.Uint32(header[8:12])
    numCols := binary.BigEndian.Uint32(header[12:16])

    fmt.Println("Image file:", filepath)
    fmt.Println("Magic number:", magicNumber, "Images:", numImages, "Rows:", numRows, "Columns:", numCols)

    // Validate header
    if magicNumber != 2051 {
        return nil, errors.New("invalid magic number for image file")
    }

    if numImages != expectedImages {
        return nil, fmt.Errorf("expected %d images, but found %d", expectedImages, numImages)
    }

    // Read image data
    images := make([][]float64, numImages)
    for i := range images {
        images[i] = make([]float64, numRows*numCols)
        tempImage := make([]byte, numRows*numCols)
        _, err := file.Read(tempImage)
        if err != nil {
            return nil, err
        }

        // Normalize pixel values to [0,1]
        for j := range tempImage {
            images[i][j] = float64(tempImage[j]) / 255.0
        }
    }

    return images, nil
}

// Generic function to read label data from a file
func readMnistLabels(filepath string, expectedLabels uint32) ([][]float64, error) {
    // Open the file
    file, err := os.Open(filepath)
    if err != nil {
        log.Fatal(err)
    }
    defer file.Close()

    // Read the header
    header := make([]byte, 8)
    _, err = file.Read(header)
    if err != nil {
        return nil, err
    }

    // Parse header information
    magicNumber := binary.BigEndian.Uint32(header[0:4])
    numLabels := binary.BigEndian.Uint32(header[4:8])

    fmt.Println("Label file:", filepath)
    fmt.Println("Magic number:", magicNumber, "Labels:", numLabels)

    // Validate header
    if magicNumber != 2049 {
        return nil, errors.New("invalid magic number for label file")
    }

    if numLabels != expectedLabels {
        return nil, fmt.Errorf("expected %d labels, but found %d", expectedLabels, numLabels)
    }

    // Read label data
    labels := make([][]float64, numLabels)
    for i := range labels {
        // One-hot encoding for digits 0-9
        labels[i] = make([]float64, 10)
        var label uint8
        err := binary.Read(file, binary.BigEndian, &label)
        if err != nil {
            return nil, err
        }
        labels[i][label] = 1.0
    }

    return labels, nil
}

// ReadData is the original function for backward compatibility
// It reads both images and labels from MNIST dataset
func ReadData() (trainingImages [][]float64, trainingLabels [][]float64,
    testImages [][]float64, testLabels [][]float64, err error) {

    trainingImages, testImages, err = ReadImages()
    if err != nil {
        return nil, nil, nil, nil, err
    }

    trainingLabels, testLabels, err = ReadLabels()
    if err != nil {
        return nil, nil, nil, nil, err
    }

    return trainingImages, trainingLabels, testImages, testLabels, nil
}

How It Works

Let’s break this down:

1. readMNISTImages:

   • Opens the image file and reads the 16-byte header.

   • Checks the magic number (2051) and ensures we have the expected number of images and dimensions (28x28).

   • Reads 784 bytes per image, normalizes each pixel to a value between 0 and 1 (by dividing by 255), and stores them in a 2D slice.

2. readMNISTLabels:

   • Opens the label file and reads the 8-byte header.

   • Verifies the magic number (2049) and number of labels.

   • Reads one byte per label and converts each into a 10-element one-hot encoded vector (e.g., digit 3 becomes [0, 0, 0, 1, 0, 0, 0, 0, 0, 0]).

3. ReadData:

   • Ties it all together by calling the above functions with the correct file paths and parameters.

Pro Tip: Notice the defer file.Close()? In Go, this ensures the file closes when the function exits, even if an error occurs. Also, we’ve replaced log.Fatal with proper error returns so the caller can decide what to do—much friendlier for reusable code!

Key Concepts

Big and Little Endian

Ever wondered how computers store numbers bigger than a single byte? It’s all about byte order, and there are two flavors:

• Big-Endian: The "big" end (most significant byte) comes first. For example, the number 2051 is stored as 00 00 08 03. It’s like reading a number from left to right in some cultures.

• Little-Endian: The "little" end (least significant byte) comes first, so 2051 would be 03 08 00 00. Think of it as right-to-left.

MNIST uses big-endian, which is why we use binary.BigEndian in our Go code to read those 4-byte integers correctly. Your computer might be little-endian (most modern PCs are), so this conversion is crucial.

One-Hot Encoding

Our labels are digits from 0 to 9, but neural networks like to work with probabilities. One-hot encoding turns each label into a 10-element vector where only one position is 1, and the rest are 0s. For example:

• Label 2 becomes [0, 0, 1, 0, 0, 0, 0, 0, 0, 0].

• Label 7 becomes [0, 0, 0, 0, 0, 0, 0, 1, 0, 0].

It’s like flipping on one light switch out of ten to signal the digit. This matches our network’s output layer, making it easier to compute errors during training.

Alternatives to One-Hot Encoding

One-hot encoding isn’t the only game in town. Here are some other options:

• Label Encoding: Just use the integer itself (e.g., 0 for 0, 1 for 1, etc.). Simple, but it implies an order (like 9 is "greater" than 0), which can confuse neural networks for classification tasks.

• Binary Encoding: Represent digits in binary (e.g., 3 as 011, 9 as 1001). Uses fewer dimensions but still assumes some structure.

• Embeddings: Fancy learned vectors that capture relationships between categories. Great for complex data like words, less so for our simple digits.

For MNIST, one-hot encoding is the go-to because it’s clear and works seamlessly with our network’s output.

Conclusion

Phew, we did it! In this first part, we’ve grabbed the MNIST dataset, decoded its binary structure, and written Go code to read it into memory. We’ve got our images normalized and our labels one-hot encoded, ready for action. Plus, we’ve demystified big and little endian and explored why one-hot encoding is our friend.

Next time, we’ll start building the neural network itself—layers, weights, and all that jazz. So stick around, keep coding, and let’s see where this journey takes us. Have questions or ideas? Drop them below—let’s learn together!

What is Bcrypt?

Bcrypt is a password hashing function designed by Niels Provos and David Mazières, based on the Blowfish cipher. Its primary goal? To protect passwords in storage against offline attacks. Here's why bcrypt isn't just another algorithm:

• Adaptive Hashing: bcrypt allows for variable computational cost, meaning you can increase its security over time as computing power advances.

• Built-in Salt: Each password hash includes a unique salt, reducing the effectiveness of rainbow tables and ensuring that identical passwords have different hashes.

The Structure of a Bcrypt Hash

$2a$10$N9qo8uLOickgx2ZMRZoMyeIjZAgcfl7p92ldGxad68LJZdL17lhWy

• 2a : This is the version of bcrypt. Think of it as the type of bread for your sandwich.

• 10: Represents the cost factor. It's like deciding how much effort goes into making the sandwich. A higher number means more rounds of hashing, making it tougher for someone to crack.

• Salt: N9qo8uLOickgx2ZMRZoMye - This is the unique seasoning. Each password gets its own special blend, ensuring no two sandwiches taste the same.

• Hash: IjZAgcfl7p92ldGxad68LJZdL17lhWy - This is the actual hashed password, the main ingredient after being processed with the salt.

How Does Bcrypt Work?

Here's a step-by-step breakdown:

1. Password Input: When you type in your password, it's like ordering a custom sandwich.

    password := []byte("yourpassword")
   

2. Hashing with Salt: bcrypt generates a salt for each password. This is like the chef adding a secret ingredient.

    hashedPassword, err := bcrypt.GenerateFromPassword(password, bcrypt.DefaultCost)
    if err != nil {
        log.Fatal(err)
    }
   

3. Storing the Hash: The hash, including the salt, is stored in your database. When someone tries to log in:

    storedHash := bcryptHashFromDatabase // This would be read from your storage
   

4. Password Verification:

   • The salt from storedHash is extracted (like reading the recipe).

   • The provided password is hashed using this salt.

   • The two hashes are compared in constant time to prevent timing attacks.

    err := bcrypt.CompareHashAndPassword(storedHash, providedPassword)
    if err == nil {
        fmt.Println("Login successful")
    } else {
        fmt.Println("Login failed")
    }

Engaging with Bcrypt

To make this more visual, think of bcrypt like cooking:

• Salting: Just like adding spices to a dish, bcrypt adds a unique flavor (salt) to each password, making each hash unique.

• Slow Cooking: bcrypt intentionally takes time to hash (the cost factor). This slow cooking process is a security feature, making brute-force attacks less feasible.

• Taste Test: When you try to log in, bcrypt isn't just checking if the password is right; it's ensuring the dish (hash) matches the original recipe (stored hash), including the secret ingredient (salt).

Why Not Just Store Passwords Plainly?

Storing passwords in plain text is like leaving your front door unlocked. Here are a few reasons why bcrypt is better:

• Salting: Prevents pre-computed hash attacks.

• Adaptive Difficulty: As hardware improves, you can increase the cost factor to stay ahead of computational advances.

• Secure Against Timing Attacks: Constant-time comparison prevents hackers from deducing information from how long comparisons take.

Conclusion

Bcrypt turns the simple act of password hashing into an art form, ensuring that even if someone gets their hands on your database, cracking those passwords would be like trying to reverse-engineer a gourmet recipe from a single bite of a dish.

Next time you type in your password, give a nod to bcrypt for keeping your digital life secure. And remember, always use strong, unique passwords for each service, because even the best seasoning can't protect a poorly chosen ingredient.

Exploring the Chomsky Hierarchy of Grammars

Computer languages and grammar studies are pretty cozy with each other, and we can thank Noam Chomsky for that. Chomsky came up with a way to look at grammar mathematically, and it's been a big deal in computational linguistics and computer science. He divided grammars into four types, each with its own complexity and what's needed to process them. This breakdown is super helpful for making programming languages and understanding languages in general.

Type-0 Grammars: Unrestricted Grammar Type-0 grammars are like the Wild West of grammars in Chomsky's world. They don't have any rules holding them back. The languages they create are called recursively enumerable languages. To handle these, you need a Turing machine, which is like the Swiss Army knife of computational models. Anything you can compute, you can express in a Type-0 language. It's the full monty of computing power.

Type-1 Grammars: Context-Sensitive Grammar Next up are Type-1 grammars or context-sensitive ones. These are a bit more reined in than Type-0. They're behind context-sensitive languages, which need a linear bounded automaton to be recognized. Think of it as a Turing machine on a leash, its space directly tied to the input size. These grammars aren't the go-to for programming, but they're key in understanding complex computer languages and even natural languages.

Type-2 Grammars: Context-Free Grammar Then there's Type-2, the context-free grammars. These guys are all about rules that don't care about context. They're recognized by pushdown automata, essentially Turing machines with a memory cap. Most programming languages fall here since they hit that sweet spot of being complex enough for nifty parsing algorithms but not too wild to handle.

Type-3 Grammars: Regular Grammar Finally, at the simpler end, we have Type-3 or regular grammar. These are the most straightforward and limited bunch. They birth regular languages, which a finite state automaton can recognize – basically, the simplest kind of computational model. Regular grammars are the stars in text processing and setting up the groundwork in compilers.

So What is Grammar?

A Grammar can be formally defined as

A Grammar G can be formally described using four tuples a G = ( V, T, S, P) where,

V = set of Variables or Non-Terminal Symbols.
T = Set of Terminal Symbols
S = Start Symbols
P = Production rules for Terminal and non-Terminals

A production rule has the form a -> ß where a and ß are strings on V U T and at least one symbol belongs to V.

Regular Grammar

Regular Grammar can be divided into two types:

1. Right Linear Grammar

A Grammar is said to be Right Linear if all productions are of the form

$$A \rightarrow xB$$

$$\ A \rightarrow x$$

$$where \ A,B \in V \ and \ x \in T$$

In simple terms, a Non-terminal symbol (B) lies on the right side of the terminal Symbol.

1. Left Linear Grammar

A Grammar is said to be Left Linear if all productions are of the form

$$A \rightarrow Bx$$

$$\ A \rightarrow x$$

$$where \ A,B \in V \ and \ x \in T$$

In simple terms, a Non-terminal symbol (B) lies on the right side of the terminal Symbol.

Derivations from Grammar

The set of all strings that can be derived from a Grammar is said to be the Language Generated from that Grammar.

For Example:

$$G1 = (\{S,A,B\}),\{a.b\},S,\{S \rightarrow AB, A \rightarrow\ a, B \rightarrow\ b \}) \\a$$

Context Free Grammar

In formal language theory, a Context-free language is a language generated by some context-free Grammar.

The set of all Context-free languages is identical to the set of languages accepted by Pushdown Automata.

Context Free Grammar is defined by 4 tuples as G = { V, ∑, S, P } where

V = Set of Variable or Non-Terminal Symbols
∑ = Set of Terminal Symbols
S = Start Symbols
P = Production Rule

$$\text{Context free Grammar has Production Rule of the form } \ A \rightarrow a \ where, a = \{V \ \cup \ ∑ \ \}* \ and \ A \in V$$

Context-Sensitive Grammar

Checking if a certain String Belongs to Grammar or not

Steps

1) Start with the start symbol and choose the closest production that matches to the given string.

2) Replace the variables with their most appropriate production. Repeat the process until the string is generated or until no other productions are left.

Derivation Tree or Parse Tree

A Derivation Tree or Parse Tree is an ordered rooted tree that Graphically represents the semantic information of strings derived from a Context-Free Grammar.

Root Vertex: Must be labeled by the Start Symbol
Vertex: Labelled by Non-Terminal Symbols
Leaves: Labelled by Terminal Symbols or ∈

Types of Derivation Tree.

1. Left Derivation Tree: A left Derivation tree is obtained by applying production to the leftmost variable in each step.

2. Right Derivation Tree: A Right Derivation Tree is obtained by applying production to the rightmost variable in each step.

Ambiguous Grammar

Grammar is said to be ambiguous if there exist two or more derivatives trees for a string w ( that means two or more left derivation trees)

TL;DR

In this article, we explore the concept of grammar in computer languages, inspired by Noam Chomsky's hierarchy of grammars. Chomsky categorized grammars into four types, each with varying complexity and applications in computational linguistics and computer science:

1. Type-0 Grammars: Unrestricted grammars with no rules, capable of expressing anything computable.

2. Type-1 Grammars: Context-sensitive grammars that require linear bounded automata for recognition, useful for understanding complex computer and natural languages.

3. Type-2 Grammars: Context-free grammars recognized by pushdown automata, commonly used in programming languages.

4. Type-3 Grammars: Regular grammars recognized by finite state automata, fundamental in text processing and compiler development.

The article also provides formal definitions and explanations for different grammar types, including regular grammar, context-free grammar, and context-sensitive grammar. Additionally, it discusses the concept of derivation trees and ambiguity in grammar.

Conclusion

In summary, grammars play a crucial role in defining the rules of computer languages. Noam Chomsky's hierarchy of grammars categorizes them into four types, each with distinct complexity levels and applications. Understanding these grammar types is essential for programming, computational linguistics, and language processing tasks. Regular grammars are the simplest, while context-sensitive grammars offer a deeper level of complexity, bridging the gap between language theory and practical applications in computer science. Context-free grammars, on the other hand, are widely used in programming languages, making it a critical topic for developers and language designers. Lastly, the article touches on derivation trees and the potential for ambiguity in grammar, highlighting the importance of clarity and precision in language definitions.

In the vast landscape of computer science, languages are not just confined to human communication; they also extend into the realm of formal languages, classified into regular and non-regular categories. Understanding these languages is crucial in various areas of computer science, from compiler design to the analysis of algorithms. In this blog post, we will explore the concepts of regular and non-regular languages, provide examples for better comprehension, and delve into the operations performed on these languages.

Regular and Non-Regular Languages

Regular Languages

Regular languages are a subset of formal languages that can be recognized and generated by finite automata. These languages follow the rules of regular expressions, which are powerful tools for pattern matching and text processing. Regular languages exhibit simple and predictable behaviour, making them fundamental in various areas of computer science.

Non-Regular Languages

On the other hand, non-regular languages do not adhere to the restrictions imposed by regular languages. These languages often require more complex computational models, such as pushdown automata or Turing machines, for recognition and generation. Non-regular languages pose challenges in terms of analysis and computation due to their inherent complexity.

Examples of Regular and Non-Regular Languages

Regular Language Example

Consider the language of all strings over the alphabet {0, 1} that represent binary numbers divisible by 3. This language can be recognized by a finite automaton, showcasing its regularity.

Non-Regular Language Example

An example of a non-regular language is the set of all strings of the form {0^n1^n | n ≥ 0}, which represents the language of balanced parentheses. This language requires a stack-based computational model, as it cannot be recognized by a finite automaton.

Operations on Regular and Non-Regular Languages

Regular Languages Operations

1. Union (|): Given two regular languages L1 and L2, their union L1 | L2 is also a regular language.

2. Concatenation (⋅): If L1 and L2 are regular languages, then their concatenation L1 ⋅ L2 is a regular language.

3. Kleene Star (*): For a regular language L, its Kleene closure L* is also a regular language.

Non-Regular Languages Operations

1. Intersection (∩): The intersection of two non-regular languages may not necessarily be non-regular. It depends on the specific languages and their characteristics.

2. Complement (¬): The complement of a non-regular language is not guaranteed to be non-regular.

Conclusion

In conclusion, regular and non-regular languages are foundational concepts in formal language theory and computer science. Understanding their properties, examples, and operations is crucial for designing efficient algorithms, building compilers, and solving computational problems. As we continue to explore the vast world of languages, these distinctions become essential for navigating the complexities of computation and communication in the digital age.

But before we even start building anything let's learn about Server-Side Events (SSE)

Server-Side Event

A Server-Sent Event (SSE) is a simple and efficient mechanism for sending real-time updates from the server to the client over HTTP. It is a standard web technology that enables servers to push data to web clients over a single, long-lived HTTP connection in real time.

In simple words, you can send push events from the backend to the frontend. Below is a small explanation to understand it better.

Here's a basic overview of how Server-Sent Events work:

1. Connection Establishment: The client initiates a request to the server, and the server responds with a special media type called text/event-stream. This indicates that the server will be sending events in a specific format.

    HTTP/1.1 200 OK
    Content-Type: text/event-stream
    Cache-Control: no-cache
    Connection: keep-alive
   

2. Event Format: The server sends events to the client in a specific text-based format. Each event is a plain text message with a series of fields, such as "event," "data," and "id." For example:

    plaintextCopy codeevent: eventName
    data: This is the event data
    id: 123
   

3. Handling Events on the Client: The client receives these events and can handle them using JavaScript. The EventSource API is commonly used for this purpose. The client can define event listeners to process specific types of events.

    const eventSource = new EventSource('/events');
   
    eventSource.onmessage = function(event) {
      console.log(event.data);
    };
   
    eventSource.onerror = function(error) {
      console.error('EventSource failed:', error);
    };
   

4. Connection Persistence: The SSE connection remains open, allowing the server to push new events to the client whenever necessary. This is different from traditional request-response mechanisms where the client initiates each request.

Creating a simple Golang App

I will keep the implementation simple here. In this section, we just create a simple Server Sent Event in Golang. Which listens to /stream route.

package main

import (
    "fmt"
    "log"
    "net/http"
    "time"
)

func main() {
    fmt.Printf("starting server on 8000\n")
    http.HandleFunc("/stream", func(w http.ResponseWriter, r *http.Request) {
        // Set headers
        w.Header().Set("Content-Type", "text/event-stream")
        w.Header().Set("Cache-Control", "no-cache")
        w.Header().Set("Connection", "Keep-alive")

        // Send an Intial Connection Response

        fmt.Fprint(w, "data: Connection")
        flusher, ok := w.(http.Flusher)
        if !ok {
            http.Error(w, "Streaming not supported", http.StatusInternalServerError)
            return
        }

        // Simulates sending event every second

        for {
            fmt.Fprintf(w, "data: %s\n\n", time.Now().Format("15:04:05"))
            flusher.Flush()
            time.Sleep(1 * time.Second)
        }

    })
    err := http.ListenAndServe(":8000", nil)
    if err != nil {
        log.Fatal(err)
    }

}

This is it for the development of the server. Let's look at the React app in the next section.

Creating a React app

In this section we will create a React app, For this tutorial we will be using Remix. Remix is a framework built for React.

npx create-remix

Once that is done, just add a useEffect with the below code.

useEffect(() => {
    const eventSource = new EventSource('http://localhost:8000/stream');

    eventSource.onmessage = (event) => {
      setSSEData(event.data);
    };

    eventSource.onerror = (error) => {
      console.error('EventSource failed:', error);
      eventSource.close();
    };

    return () => {
      // Clean up the event source when the component is unmounted
      eventSource.close();
    };
  }, []); // Empty dependency array ensures the effect runs only once

Let me explain what is happening above, Once we create a new EventSource on the route we are streaming the data and storing it into eventSource. then we listen to onMessage and set the setSSEData to the new data we get from the event.

Now, it's up to you, what you want to do with this data now. What I did was simply display the data like below.

TL;DR:

This tutorial covers Server-Sent Events (SSE) with a Golang server and a React app using Remix. SSE allows real-time updates from the server to the client over HTTP. The Golang server listens to the /stream route, sending periodic events. The React app, created with Remix, uses EventSource to receive and display the streaming data. The server's SSE implementation and React's useEffect for handling events is explained step by step.

Brainstorming

After a couple of ideas, I thought of creating a map with all the ids mapped to their current path, which was a good idea. But after thinking it harder I found that the update path ( which is basically update Name) would be harder and can't be achieved easily by using one map only, as if we update a folder we need to update all the child component's path also. To do so I also needed a reference to all the paths and a way to easily access them.

Bidirectional Map

I thought of building a bidirectional Map where one map's key are id and the other map's key is the path. Well, this was a very good solution and optimal in my case. Below is a mental picture of it.

API for bidirectional Map

After building a basic mental idea about this, I needed to build APIs for this datastructure which can be used and can be easily extended. I was pretty sure we would need operations like add(), get() , update(), delete() . But apart from these, we can also have, getall() other operations depending upon the need.

below is the code of how the finished structure looks in Typescript.

/**
 * @template K - The type of keys.
 * @template V - The type of values.
 *
 * @class
 * @classdesc A simple bidirectional map for mapping between keys and values.
 *   Provides methods to add mappings and retrieve values by key or value.
 *
 * @example
 * // Example usage:
 * const bidirectionalMap = new BidirectionalMap<string, number>();
 * bidirectionalMap.addMapping('apple', 1);
 * bidirectionalMap.addMapping('orange', 2);
 *
 * // Using key to get value
 * console.log(bidirectionalMap.getValue('apple')); // Output: 1
 *
 * // Using value to get key
 * console.log(bidirectionalMap.getValue(2)); // Output: orange
 */
class BidirectionalMap<K, V> {
  /**
   * @private
   * @type {Map<K, V>} - The forward mapping from keys to values.
   */
  private forwardMap: Map<K, V>;

  /**
   * @private
   * @type {Map<V, K>} - The reverse mapping from values to keys.
   */
  private reverseMap: Map<V, K>;

  /**
   * Creates a new instance of BidirectionalMap.
   * @constructor
   */
  constructor() {
    this.forwardMap = new Map<K, V>(); // used to map key ===> path
    this.reverseMap = new Map<V, K>(); // used to map path ====> key
  }

  /**
   * Adds a bidirectional mapping between a key and a value.
   *
   * @param {K} key - The key to be mapped.
   * @param {V} value - The value to be mapped.
   * @returns {void}
   * @memberof BidirectionalMap
   */
  addMapping(key: K, value: V): void {
    this.forwardMap.set(key, value);
    this.reverseMap.set(value, key);
  }

  /**
   * Retrieves the value associated with the provided key or value.
   *
   * @param {K | V} keyOrValue - The key or value for which to retrieve the associated value or key.
   * @returns {V | K | undefined} The associated value or key, or undefined if not found.
   * @memberof BidirectionalMap
   */
  getValue(keyOrValue: K | V): V | K | undefined {
    if (this.forwardMap.has(keyOrValue as K)) {
      return this.forwardMap.get(keyOrValue as K);
    } else if (this.reverseMap.has(keyOrValue as V)) {
      return this.reverseMap.get(keyOrValue as V);
    } else {
      return undefined;
    }
  }

  getAllKeysFromForwardMap() {
    return this.forwardMap.keys();
  }

  getAllKeysFromReverseMap() {
    return this.reverseMap.keys();
  }

  getAllValuesFromForwardMap() {
    return this.forwardMap.values();
  }

  getAllValuesFromReverseMap() {
    return this.reverseMap.values();
  }

  getValueFromForwardMap(key: K) {
    return this.forwardMap.get(key);
  }

  getValueFromReverseMap(key: V) {
    return this.reverseMap.get(key);
  }

  // TODO: This should update the the values in the both things

  updateValue(key: K, value: V) {
    // Update the value of key in forward Map and backward Map
    this.addMapping(key, value);
  }

  getMapping() {
    return {
      forwardMap: this.forwardMap,
      backwardMap: this.reverseMap,
    };
  }
}

the only thing that is missing is the delete() method, which you guys can create on your own.

Once this is gone the usage of this looks something like below.

Example Usage:

 @example
 // Example usage:
  const bidirectionalMap = new BidirectionalMap<string, number>();
  bidirectionalMap.addMapping('apple', 1);
  bidirectionalMap.addMapping('orange', 2);

  // Using key to get value
 console.log(bidirectionalMap.getValue('apple')); // Output: 1

 // Using value to get key
 console.log(bidirectionalMap.getValue(2)); // Output: orange

Thank you for reading so far. If you learned something new and liked the article please follow me and subscribe to my email newsletter.

By the way, during my college days, I found myself engrossed in numerous informational videos and lectures. Let me tell you, trying to take notes while absorbing all that knowledge was no walk in the park. The struggle was real! I often wished for a magical AI companion who could effortlessly jot down the key points for me. Can you imagine how incredible that would be? It would have saved me from the mindless consumption of content without any real progress. And when the opportunity came for this hackathon by 1Password and Hashnode I couldn't refuse to participate

The Genesis of Incredible Idea 💡

After the launch of ChatAI, I wanted to get my hands dirty and try out a bunch of AI mini SAAS tools for my productivity. And a way to jot down the notes from youtube was first on my priority list. And when OpenAI launched the GPT-3 API I jumped at the opportunity to build something cool.

The concept behind Video-notes is to provide a convenient SaaS tool that allows users to simply paste a YouTube link and automatically generate comprehensive notes while watching the video. However, why limit ourselves to just note generation? Let's think bigger! Why not expand the capabilities of the tool to include generating blog posts, summaries, transcripts, and even language translation? With such a versatile tool, the possibilities for enhancing productivity and content creation become truly endless.

That's what Video-Notes is, It's not a boring transcriber for your youtube video but auto-formatting the Transcription to your desired Output using the power of AI.
Doesn't it seem amazing?

Video Preview

The Journey 🛣️

The journey to create this was pretty tiring it was hard to come up with a good architectural design that can be cost-effective as well as fast. Even though below is what I can come up with.

The Architecture ⚒️

1. Passage by 1Password

   Passage feels very intuitive to me as it provides a native way to log in to any application and you don't need to remember the password at all. How cool is it?
   Also, the Implementation was pretty simple and straightforward, You can say probably one of the best ways to authenticate your users.

2. YTDL

   To get the Audio file from the URL of the youtube link I used the YTDL library. In the beginning, I was fetching the audio from Youtube using the YTDL API, and once the audio was received, I streamed and saved it to my in-memory state ( basically state if you use React).

   The Problem with this approach was I was streaming a big file back to my react app and not only that I needed to send this file back to the Whisper to get the Transcription.

3. Whisper API

   In the beginning, I transcribed the Video from youtube using, OpenAI's product whisper. This worked perfectly for smaller videos but not for larger files as it has a file limit of 25MB (Roughly around ~25min high-quality videos). But any good lecture video or educational video generally exceeds more than 200 MB or more. So I initially thought of chunking the audio into 25 MB chunks and getting the transcription one by one.
   This solution was possible but the problem was that it was not very fast in real-world scenarios. No user wants to keep waiting for half an hour ( Yes it took this long) and also the cost to use the whisper API was quite a lot which was not sustainable in the long run.
   This was the main reason why I moved away from the whisper API. This did the job accurately but also had a very high cost associated with it.

4. ChatGPT

   I don't really think you haven't heard of chatGPT, if you haven't let me tell you it's an amazing generative AI by OpenAI. Now this could solve a ton of my problem like, like converting the transcripts to the Blog, Summaries, and Notes, or even translating it into another language. Basically, it's the Brain of the whole application. and very essential part of the whole architecture.

5. Cloud (Firebase)

   I used the Firebase product Firestore to save the data like user details and notes details and other stuff. Which I might need to show users in the future.

The Improvision

After looking at the above implementation I knew it was not going to sustain itself, even users would think it was an overpriced application if I ever decide to monetize it. Now I needed to search for a solution that can reduce the cost that was associated with Whisper API also the circus I had to go through only to fetch the transcription of the Youtube video.

Youtube does it for free.

I told this problem to my friend he was like dude youtube does that for free. Don't you know? And I was like yes I agree but is it that accurate? I don't think so, and then he mentioned "You don't need accuracy you need Transcription" As we were already using the ChatGPT we can post-process the data using it, so any issue with the transcription will be solved automatically.

Using Youtube's auto-cc as Transcription.

I used the YTDL library to do that. Here is a snippet of what I did, I used Nestjs API to do that as YTDL uses fs to run so it was throwing an error in the client so to workaround this used the Next API.

import ytdl from "ytdl-core";
import { NextApiRequest, NextApiResponse } from "next";
import { parseString } from "xml2js";

const lang = "en";
const format = "xml";

// eslint-disable-next-line import/no-anonymous-default-export
export default async (req: NextApiRequest, res: NextApiResponse) => {
  const { url } = req.query;
  ytdl.getInfo(url as string).then((info: any) => {
    const tracks =
      info.player_response.captions.playerCaptionsTracklistRenderer
        .captionTracks;
    if (tracks && tracks.length) {
      const track = tracks.find(
        (t: { languageCode: string }) => t.languageCode === lang
      );
      if (track) {
        fetch(`${track.baseUrl}&fmt=${format !== "xml" ? format : ""}`)
          .then((response) => response.text())
          .then((xmlData) => {
            // Parse XML to JSON
            parseString(xmlData, (err, result) => {
              if (err) {
                console.error("Error parsing XML:", err);
                res.status(500).send("Error parsing XML");
                return;
              }

              // Convert JSON to plain text
              const plainText = result.transcript.text;
              const response = {
                transcript: plainText,
                simpleText: convertToSimpletText(plainText),
              };

              res.send(response);
            });
          })
          .catch((error) => {
            res.status(500).send("Error fetching captions");
          });
      } else {
        res.status(400).send("Could not find captions for " + lang);
      }
    } else {
      res.status(400).send("No captions found for this video");
    }
  });
};
function convertToSimpletText(transcriptData: any) {
  let text = "";
  for (const { _: line } of transcriptData) {
    // Remove unnecessary data (e.g., speaker names)
    const cleanedLine = line.replace(/\[[^\]]+\]/g, "").trim();
    text += cleanedLine + " ";
  }
  return text.trim();
}

Let me quickly explain to you what is happening in the above code. So first we are using YTDL to fetch the video info from the URL our user has given, once we have that we are making another nested api call to the other API which basically fetches the CC in xml format.

 fetch(`${track.baseUrl}&fmt=${format !== "xml" ? format : ""}`)

The Response is received it looked like the below and we need some pre-processing to send this data to the GPT-3.

/**
 * Notes : Result 
 * Transcript: [
  {
    _: '[Herb, YouTuber]\nThis video demonstrates closed captions.',
    '$': { start: '6.5', dur: '1.7' }
  },
  {
    _: 'To turn on captions, click on the icon over here.',  
    '$': { start: '8.3', dur: '2.7' }
  },
  {
    _: '[Greg, Deaf Singer]\n' +
      'Back when the Internet was first established, deaf people had a\n' +
      'great time with it.',
    '$': { start: '12.5', dur: '3.9' }
  },
  {
    _: 'Everything was readable.\nThen ...',
    '$': { start: '16.5', dur: '2' }
  },
  {
    _: '[Ken, Deaf Listener]\n' +
      'Movies started showing up.\n' +
      'We couldn't understand them...',
    '$': { start: '19', dur: '3.2' }
  },
  { _: 'there were no captions!', '$': { start: '22.5', dur: '1.5' } },
  {
    _: 'Fortunately, Google Video added support for captions.',
    '$': { start: '24.5', dur: '2.5' }
  },
  { _: 'Thank you, Ken!', '$': { start: '27.5', dur: '1' } },
  {
    _: 'Now, we've added that to YouTube.',
    '$': { start: '28.5', dur: '3' }
  },
  {
    _: 'But the first thing he did with\nthat was RickRoll me!',
    '$': { start: '32', dur: '3' }
  },
  {
    _: '♪ Never gonna give you up, ♪\n♪ never gonna let you down...',
    '$': { start: '35.5', dur: '3.5' }
  },
  {
    _: '[Franck, Icone de Mode]\nCaptions and subtitles are also helpful',
    '$': { start: '41.3', dur: '2.7' }
  },
  {
    _: 'for people who speak other languages, like myself.', 
    '$': { start: '44.2', dur: '2' }
  },
  {
    _: 'With subtitles, I can enjoy US Comedy, or news stories from Russia,',
    '$': { start: '46.8', dur: '3.2' }
  },
  { _: 'in my own language. ', '$': { start: '50.1', dur: '1.4' } },
  {
    _: 'As a video uploader, this means you can reach\n' +   
      'to people all over the world, ',
    '$': { start: '52', dur: '4' }
  },
  {
    _: 'irrespective of language.',
    '$': { start: '56.8', dur: '1.7' }
  },
  {
    _: '[Hiroto, Bedhead]\n' +
      'You can upload multiple tracks like English and French, ',
    '$': { start: '59.5', dur: '2.5' }
  },
  {
    _: 'and viewers can choose the track they like.',        
    '$': { start: '62.5', dur: '3.5' }
  },
  {
    _: '[Toliver, Japanese Learner]\n' +
      'For example, if you enjoy using YouTube in French,',  
    '$': { start: '67.5', dur: '4' }
  },
  {
    _: 'French captions will automatically appear.',
    '$': { start: '72', dur: '5' }
  },
  { _: 'With just a single video,', '$': { start: '77.5', dur: '3' } },
  {
    _: 'you can now reach people all around the globe!',     
    '$': { start: '81', dur: '5' }
  },
  {
    _: 'The captioning capability at YouTube was just launched this summer,',
    '$': { start: '88', dur: '3' }
  },
  {
    _: 'and we're planning to add more features to this.',
    '$': { start: '91.3', dur: '2.7' }
  },
  {
    _: 'If you have any feedback, please let us know!',      
    '$': { start: '94.2', dur: '2.3' }
  }
]
 * 
 */

It has duration as relevant data which I m thinking to use but for now we just simple data string which we can send to the GPT-3 API.

Pre-Processing

function convertToSimpletText(transcriptData: any) {
  let text = "";
  for (const { _: line } of transcriptData) {
    // Remove unnecessary data (e.g., speaker names)
    const cleanedLine = line.replace(/\[[^\]]+\]/g, "").trim();
    text += cleanedLine + " ";
  }
  return text.trim();
}

Once this data is saved to the state, I make the call to GPT-3 API using the data we got in Step 1.

We use a simple GPT-3 completion API Read about it HERE.

export const getGptResponse = async (
  text: string,
  contentType: string
): Promise<string | undefined> => {
  if (!text) return;

  return new Promise((resolve, reject) => {
    fetch("https://api.openai.com/v1/chat/completions", {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        Authorization: `Bearer ${getApiKey()}`,
      },
      body: JSON.stringify({
        model: "gpt-3.5-turbo",
        messages: [
          {
            role: "system",
            content: contentType,
          },
          {
            role: "assistant",
            content:
              "Supported Markdown: #, ##, ###, ####, #####, ######, ![](url), >, *, 1. , ```code```,",
          },
          {
            role: "user",
            content: text,
          },
        ],
      }),
    })
      .then((response) => {
        if (!response.ok) {
          throw new Error("Network response was not ok");
        }
        return response.json();
      })
      .then((json) => {
        console.log(json.choices[0].message.content);
        resolve(json.choices[0].message.content);
      })
      .catch((error) => {
        console.log(error);
        reject(new Error("GPT-3 failed"));
      });
  });
};

In this, I fetch the key From the local storage and then make the API call with the transcription data in the first Step.

Once that is done I need to do an extra step to convert the markdown to the Blocks data. which my editor understands. Why Markdown? Surprisingly CHAT GPT is very good at handling markdown than the data is needed.

Once the Editor is populated with the data user wants just SImply saves it and can easily access it from any device anytime.

So where does the Passage Come In?

Well as we are saving the notes and making API calls to OpenAI which is expensive, we do want some kind of user management. There are a ton of ways to handle it, including the Firebase auths, but what Passage gave seems very intuitive and native to having an application experience. It simply uses the native way of the device to authenticate users and login them.
Just not that also the implementation was pretty simple and I was blown away by how easy the implementation was, Barely a couple of lines of code. you can read about it in their official doc.

Application Flow

1. Visit Us.

   Go to https://video-notes-pi.vercel.app/ and Click on Get Started.

   

2. Login Using Passage

   If you are already login you can continue normally using your native way or you can register.

   

3. Enter the URL of your youtube Video.

   

4. Select the format You want.

   Select the format you like to have your output in, In this example, I used Summary as my desired format, you can choose others too, We currently support Notes, Blogs, and Summary though planning to have others and a custom option too. Where you can write your own prompts.

   

5. Click and Wait for it...

   Once you clicked on Convert, you kind of need to wait for this process to finish, once that is done you will have a screen like below.

   

6. Save the Note to the Database.

   You can click Save to save to Firebase or you can edit it, it's up to you.

   

7. Revisit it.
   You can revisit your saved notes by clicking on the Notebook and then selecting the note you wanna revisit.

Results

What's Next

1. A Better Player: I Intent to add a better player for playing and navigating the youtube video in sync with the notes or blogs.

2. A Better Editor: I intended to add better features to the editor, like code preview, automatic screenshots, etc.

3. Timestamp-based Notes: I also planning to add a feature in which we can add timestamps to our notes or transcript so that it's easily navigated.

4. Better Prompts and Custom Prompts: Better support for custom prompts and increasing the quality of the existing prompts.

5. Translation: A way to get the videos that are not native and transcribe them.

Technology Used 🧑‍💻

Frontend

1. Editor.js
   Free block-style editor with a universal JSON output.

2. Nextjs

3. Passage by 1 Password

Backend and API

1. Firebase Firestore

2. GPT-3 API

3. YTDL-Core

Resources and links

1. Live Link: https://video-notes-pi.vercel.app/

2. GitHub Link: https://github.com/theashishmaurya/videoNotes

TLDR

• Video-Notes is a SaaS tool that generates notes from informational videos.

• It offers features like blog post generation, summaries, transcripts, and language translation.

• Technical implementation includes:

  • Authentication using Passage.

  • Fetching audio from YouTube using YTDL.

  • Transcription using YouTube's auto-cc (switched from Whisper API).

  • ChatGPT as the core language model.

  • Data storage using Firebase.

• Code snippets for fetching auto-cc from YouTube and using the GPT-3 API were shared.

• Improvements were made to reduce costs and enhance transcription accuracy.

• Live version: Live Video-Notes

• GitHub repository: Video-Notes on GitHub

• If you liked it follow me on Twitter or LinkedIn

Well if you already don't know it there are famously two ways people handle authentication in their products nowadays.

1. JWT tokens

2. OAuth

Well, you can learn about them on the internet there are 100s of blogs and videos for them.

Now let me explain to you guys how to use the first method in React.

JWT Token

JSON Web Tokens also commonly known as JWT are used to authenticate a client to the server. It can be used for login or other things.

JSON Web Tokens are an open, industry-standard RFC 7519 method for representing claims securely between two parties.

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

above is an example JWT web token it can be decoded in the below format

Header

{
  "alg": "HS256",
  "typ": "JWT"
}

Payload

{
  "sub": "1234567890",
  "name": "John Doe",
  "iat": 1516239022
}

Verify Signature

HMACSHA256(
  base64UrlEncode(header) + "." +
  base64UrlEncode(payload),

your-256-bit-secret

)

JWT Auth Token and JWT Refresh Token

A JWT architecture usually has two parts one is authToken and others are refreshToken. Where authToken is responsible for authenticating the user and refreshToken is responsible for getting the new authToken from the backend without asking for username and password from the user.
Yes! authTokens expires. Well for security purposes we set up our authToken in such as way that it expires in a while and uses the refresh token to fetch the authToken back.

Understanding the flow of JWT.

1. User Logins: User logins with username (email) and password which then goes back to the server to create a new JWT token. A simple JWT token contains JWT authToken and JWT refreshToken both tokens have an expiry generally and refreshToken should always have a greater expiry date than authToken.

2. Token Received: Once the JWT token is received by the front end they can save that JWT token into local storage or to an in-memory store like Redux. Depends on preferences but there are some standard ways to do that.

3. Making Calls: Once the JWT token is saved, all calls which use authentication/authorisation ( Yes mate both are different concepts) uses this JWT token to successfully validate the request.

4. Token expiry: Once the JWT token is expired which as we already know going to happen the JWT refresh token is used to authenticate the API call and used to fetch the new JWT tokens. (Note: Refresh token can only authenticate the API route which is used to get the new tokens)

5. Using the new Auth Tokens: Once you get the new JWT tokens you can use the authTokens to make the API calls to the server.

6. Repeat the Process: Keep repeating the process to get the new authTokens and making the API call.

Handling JWT Token in React.

Well, you might be working on just the front end and you might have an API endpoint to get the JWT authToken and JWT refreshToken.

let's create a new component to get the auth token. We will call it login.jsx and write the login-related logic here.

In this file, we will have the signup method which takes username and password as payload and gets the authToken and RefreshToken

Below is the code for the login component which is responsible for handling the login functionality

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

const Login = () => {
  const [credentials, setCredentials] = useState({
    email: '',
    password: ''
  });

  const handleChange = (e) => {
    setCredentials({
      ...credentials,
      [e.target.name]: e.target.value
    });
  };

  const handleSubmit = async (e) => {
    e.preventDefault();

    try {
      const response = await axios.post('/api/login', credentials);
      const { token, refreshToken } = response.data;

      // Store the tokens in localStorage or secure cookie for later use
      localStorage.setItem('token', token);
      localStorage.setItem('refreshToken', refreshToken);

      // Redirect or perform other actions upon successful login
    } catch (error) {
      // Handle login error
    }
  };

  return (
    <form onSubmit={handleSubmit}>
      <input
        type="email"
        name="email"
        value={credentials.email}
        onChange={handleChange}
      />
      <input
        type="password"
        name="password"
        value={credentials.password}
        onChange={handleChange}
      />
      <button type="submit">Login</button>
    </form>
  );
};

export default Login;

Let me explain what is happening in the above code.

1. First, we are asking users to get the username and password in a form component. We use handleChange function to handle the changes to form.

2. OnSubmit we are making an API call to the backend on /api/login endpoint, which is responsible for handling the authentication and login of the user.

3. On successful login, we will be having the JWT authToken and JWTrefreshToken which we set in the local store for future use. (Note: Saving JWT tokens to the local storage is not secure but for simplicity purposes, we will use this method.)

Setting Up Axios Interceptor for the JWT tokens.

In this step, we set up Axios Interceptor so that in every API call Axios automatically append the header with the bearer ${authToken}, which is used to authenticate and authorize the API calls to the backend.

import axios from 'axios';

const api = axios.create({
  baseURL: '/api',
});

// Add a request interceptor
api.interceptors.request.use(
  (config) => {
    const token = localStorage.getItem('token');
    if (token) {
      config.headers.Authorization = `Bearer ${token}`;
    }
    return config;
  },
  (error) => Promise.reject(error)
);

export default api

The above code solves the problem of authenticating each request but what about the JWT token expiration? What will we do when the JWT authToken expires? Now we can ask users to log in again but that is not a good UX, a better way is to automatically fetch the new JWT authToken if the JWT refreshToken exists.

To do that we will again use Axios interceptor but not at request but at response.

// Add a response interceptor
api.interceptors.response.use(
  (response) => response,
  async (error) => {
    const originalRequest = error.config;

    // If the error status is 401 and there is no originalRequest._retry flag,
    // it means the token has expired and we need to refresh it
    if (error.response.status === 401 && !originalRequest._retry) {
      originalRequest._retry = true;

      try {
        const refreshToken = localStorage.getItem('refreshToken');
        const response = await axios.post('/api/refresh-token', { refreshToken });
        const { token } = response.data;

        localStorage.setItem('token', token);

        // Retry the original request with the new token
        originalRequest.headers.Authorization = `Bearer ${token}`;
        return axios(originalRequest);
      } catch (error) {
        // Handle refresh token error or redirect to login
      }
    }

    return Promise.reject(error);
  }
);

So let me explain the code above so that we understand why we need interceptors and how the above code is working.

On each response error with the status code 401 which is the status code for Unauthorized and no retryFlag means that the JWT token has expired. Hence we need to fetch the new token using the JWTrefreshToken and then we set the newly generated JWT authToken and send the request again for the failed request.
In case of any JWT refreshToken error we can redirect to log in so that we can fetch new JWT authToken and JWTrefreshToken.

Using the above solution in our Application.

Now, you can use the api instance from the api.js files in your components to make authenticated requests. Here's an example of usage:

import React, { useEffect, useState } from 'react';
import api from './api';

const Profile = () => {
  const [user, setUser] = useState(null);

  useEffect(() => {
    const fetchProfile = async () => {
      try {
        const response = await api.get('/profile');
        setUser(response.data);
      } catch (error) {
        // Handle error or redirect to login
      }
    };

    fetchProfile();
  }, []);

  if (!user) {
    return <div>Loading...</div>;
  }

  return (
    <div>
      <h2>Welcome, {user.name}!</h2>
      <p>Email: {user.email}</p>
      {/* Render other user details */}
    </div>
  );
};

export default Profile;

TL;DR:

To implement authentication in a React application, one popular approach is to use JSON Web Tokens (JWT). Here's a summary of the steps involved:

1. Create a Login component that handles the login form and makes an API call to authenticate the user. Store the received JWT authToken and JWT refreshToken in localStorage.

2. Set up an Axios instance with interceptors to automatically include the JWT authToken in the headers of authenticated API requests.

3. Add a response interceptor to handle JWT token expiration. If a request receives a 401 error (Unauthorized) and there is a JWT refreshToken available, use it to fetch a new JWT authToken and update it in localStorage. Then retry the original request with the new authToken.

4. Use the configured Axios instance in your components to make authenticated API calls.

Remember to handle errors, redirect to login on refreshToken failure, and consider security aspects when storing tokens.

By implementing JWT authentication with refresh tokens and using Axios interceptors, you can create a secure and efficient authentication system in your React application.

The creation of Bitcoin can be traced back to a whitepaper published in 2008 by an unknown person or group of people under the pseudonym Satoshi Nakamoto. The whitepaper, titled "Bitcoin: A Peer-to-Peer Electronic Cash System," proposed a decentralized digital currency that would allow for secure, anonymous transactions without the need for intermediaries like banks or payment processors.

To bring this vision to life, Nakamoto developed the first implementation of the Bitcoin software and released it in January 2009. The software, which is open-source and freely available, allows users to send and receive bitcoins over the internet.

The creation of new bitcoins is achieved through a process known as mining. Mining is the process of using computational power to solve complex mathematical problems, and when a miner solves a problem, they are rewarded with a certain amount of bitcoins. This process is designed to be resource-intensive and difficult, so it is not possible for any single person or group to control the creation of new bitcoins.

The total number of bitcoins that can be created is limited to 21 million, with the final bitcoin set to be mined in the year 2140. This fixed limit on the supply of bitcoins is intended to prevent inflation and ensure that the currency retains its value over time

Transactions and double spending

Transactions in Blockchain are building blocks of Blockchain ( I mean literally). Each Blockchain is made up of several transactions.

LifeCycle of transactions

Let's Imagine you need to send some Bitcoin to your friend Alice, once you click on the send money than that transaction is got broadcasted to all the Miners out there and miners validate the transaction through several methods(We will talk about them later in this article) on successfully validating the transaction, if more than 50% agrees that block is added to the Blockchain.

Now, let's assume Buyer wants to send some money to Alice and Bob not that he only has 15$ worth of Bitcoin. He made two transactions one for 11$ and one for 6$ if a miner validates and tries to validate it, both can see the current balance in Buyer is 15$ hence in this case if transactions are approved Buyer will be sending more money than it originally had. This is called the Double spending Problem.

The Solution to Double Spending.

When a transaction is made on the Bitcoin network, it is broadcast to all nodes in the network. Each node verifies that the transaction is valid by checking that the sender has sufficient funds and that the transaction has not already been spent.

Once the transaction is verified, it is bundled together with other transactions into a block. Miners compete to solve a cryptographic puzzle related to the block, and the first miner to solve the puzzle and add the block to the blockchain is rewarded with newly minted bitcoins.

Once a block is added to the blockchain, it cannot be altered, so any double-spending attempts would be rejected by the network. In order for an attacker to successfully double-spend, they would need to control the majority of the computing power on the network, which is extremely difficult and expensive to do in practice.

BitCoin Scripts

If I have to explain this in simple words "Bitcoin scripts are language Bitcoin uses to do everything it can. from sending funds from a wallet to allowing the creation of multi-user accounts."

Bitcoin Script is not a fully fledge programming language meaning it has some limitations and runs in a specific environment, However, this limitation is intentional as this prevents infinite or endless looping and error execution. Where malicious parts of the program can be free to create complicated operations to consume the rate of hash and slow down the Bitcoin system through infinite loops.

A Bitcoin script uses the LIFO pattern to read the instruction, it runs from Left to Right executing commands/instruction one by one. To implement this kind of functionality a popular data structure Stack is used.

To learn more about Bitcoin Script you can refer to this amazing article here.

BitCoin Peer-to-Peer Network

Before I explain to you how BitCoin Peer to Peer Network works let me first explain what Peer to Peer network is.

A Peer to Peer network does not need a server to send data to other members of the network. Let's take an example you want to send a movie from your local device to your friend's device. Now there is one way to establish a server from which both you and your friend connect so that you can upload the movie to the server and your friend can download it from the server itself. Now another way is to directly send the movie to your friend without the intervention of any server, this can be achieved using a peer-to-peer model where you and your friend both are peers. And once you invite a couple of your friends, it becomes a network of peers.

If I have to define it goes something like this, A peer-to-peer network is one in which two or more PCs share files and access devices such as printers without requiring a separate server computer or server software.

Now, that we are clear about the Peer-to-Peer network let's look at how blockchain uses this to establish a secure and decentralized network.

A Blockchain has nodes that are peers in the Peer-to-Peer network, each node in the blockchain are miner which has the capability to add a new block to the chain. So, every time transaction happens in Blockchain it gets broadcasted to these nodes, now each node races to validate this transaction, and then once the transaction is validated, this transaction then added to Blockchain. After 51% of nodes agree on this is considered as the Main Blockchain. In this manner, Blockchain achieved pure decentralization and security.

Transaction in Bitcoin Network

Let's again take Alice and Bob's example and understand the transaction in-depth and how every transaction is protected.

But before that let us look at the concept of asymmetric encryption.

Asymmetric encryption and how it works in Blockchain.

Now, to understand this let's first understand how symmetric encryption works. Suppose Bob wants to send some data to Alice but the data is sensitive and Bob wants to send this in a way that only Alice can read it. Alice will send her the box so that Bob can put the data in the box and close it. Once the box is closed only Alice can open the Box with her key, let's call this key Alice's Private key.

Now in cryptography, the same concept is happening, to send a message to Alice Bob encrypts the data using the Hash function such that only Alice's private key can Hash it back to the original data.

The problem with the above method was for every time Alice wants to receive a message Alice have to create numerous keys and boxes to receive messages from numerous people. This can be really problematic and hence the concept of the Asymmetric key was introduced.

Now in the Asymmetric Encryption key, Alice has two keys one is called Alice's private key, and the other is called Alice's Public key. Now the public key is shareable and the private key must not be disclosed.

Now, every time someone wants to send a message to Alice they can use Alice's public key and send it to Alice now that message can only be decrypted by Alice's private key.

The math behind is quite long so we will discuss it in later articles, but for now, we understood the private and public key concepts. Let's see how it is implied in Blockchain

In Blockchain when Alice wants to send money to BOB that data will be sent to the miner where they verify some conditions like the following.

• Does Alice have enough money?

• Does Alice is the one who sent the money to Bob or is it someone else?

For checking the available balance in the wallet BTC uses something called UTXO. An overview on UTXO will be that it is a set of all the previous transaction done by Alice and after adding and subtracting everything if the balance matches then the miner approve the transaction.

And to verify if the transaction came from Alice something called a Digital signature is used where Alice signs with her private key and sends it to the miner with other data. Well, you have to understand that those logics are automatically implemented in the wallet and Alice doesn't actually sign anything. Moving on what kind of data is sent to the miner?

Well, the data might look something like this with other data of course

Once it is received the miner will validate the transaction and add it to the Blockchain. Once added to Blockchain the data becomes immutable.

Block Mining

Well, till now it's clear that the blockchain is made of a number of blocks. So what are these blocks and which kind of data do they contain?

Well if we see an overview block looks something like the below.

In this, we can see that a single block contain

• Previous Hash

• Nonce

• TimeStamp

• Merkel Root.

But in exactly a block look something like this with a lot of data

You can see all the transactions and blocks of the public Blockchain. Here I used Etherscan to get the block data but there are a lot of services out there.

So what happens is every time transactions are made they came to miners where miners validate the transactions and then try to add that block to the public Blockchain.

Why I used "try to add"? Instead of adding, well every miner is trying to add a new block to the Blockchain continuously all the time and it's like a race between every miner.

The way blockchain validates whether a block is valid or not is called Consensus Mechanism. There are different ways the Consensus Mechanism works one which is very popular is Proof of Work others are Proof of Stake***,*** Proof of Capacity***, and*** Proof of Activity.

In this article, we will only talk about the Proof of Work.

In Proof of Work, every miner has to compute a hash value for the block in some given condition.

Let's say you are a miner and you have to calculate a hash value that should start with 4 0's

for example 0000x147a9393258780beef7d

to calculate something like this takes a lot of trial and error and a lot of computational power. And also there is only one thing you can change in the block which is the value of Nonce.

So every time you want a new hash value, you keep incrementing the value of Nonce and by finding a valid hash you can add that hash to the block.

Well if any miner can add to the Blockchain isn't that make the Blockchain untrustable and unsafe?

Well here comes the power of Decentralization to save you. Every time a miner adds a block to the Blockchain other miners do a validation check on that block. If the block is valid and matches their own version of the Blockchain if everything is valid they add that Blockchain to their own version of the Blockchain and start mining the new block.

Say, if some malicious group tries to add an invalid block to the Blockchain for their own profile. After successfully mining the Blockchain their block will be rejected by other miners which can cost them a lot of money and computation power.

If another miner successfully mines a valid block the whole Blockchain will move to that version of the block and malicious manners have to sync up to mine the next block.

Well, for every successful mining, each miner is given some reward. For mining on BTC Blockchain, it's BTC coin and on mining on ethereum Blockchain, it's ethereum.

fun fact: It's the only time a new coin is created. (It's just an analogy)

Block propagation and block relay

Once a block has been mined, it must be propagated to the rest of the network to ensure that all nodes have a complete and up-to-date copy of the blockchain. This is done through a process called block relay, in which the newly mined block is broadcast to other nodes in the network. As explained above.

Working with Consensus in BitCoin

Consensus is the mechanism by which the Bitcoin network ensures that all transactions are valid and secure. This is done through a process called proof of work, which we will explore in more detail in the next section.

Distributed Consensus in open environments

Distributed consensus in open environments like Bitcoin refers to the process of reaching a common agreement among a network of independent nodes without the need for a centralized authority. In Bitcoin, this consensus mechanism is achieved through a process known as mining, in which nodes compete to solve a cryptographic puzzle and add a new block of transactions to the blockchain.

Each node in the Bitcoin network maintains a copy of the blockchain, which contains a record of all transactions that have ever taken place on the network. When a new transaction is initiated, it is broadcast to all nodes on the network. The nodes then verify the transaction by checking that the sender has sufficient funds and that the transaction meets all other necessary criteria. If the transaction is deemed valid, the node adds it to its copy of the blockchain and broadcasts the updated blockchain to the rest of the network.

In order for the network to reach a consensus on the validity of each transaction, all nodes must agree on the current state of the blockchain. This is achieved through the mining process, in which nodes compete to solve a cryptographic puzzle and add a new block of transactions to the blockchain. The first node to solve the puzzle and add a new block to the blockchain is rewarded with newly created bitcoins and transaction fees.

Once a new block has been added to the blockchain, all nodes on the network must update their copy of the blockchain to reflect the new state. This process is called block propagation and block relay, and it is essential for maintaining the consistency and integrity of the network.

The distributed consensus mechanism used in Bitcoin is designed to be resistant to attacks and manipulation. In order for an attacker to successfully manipulate the network, they would need to control a majority of the network's computational power, a scenario known as a 51% attack. This is difficult to achieve due to the high cost and computational resources required to successfully carry out such an attack.

Proof of Work (PoW)

Introduction

Proof of work is a consensus mechanism that was first introduced in Bitcoin and is now used by many other cryptocurrencies. The basic idea is that miners must solve a cryptographic puzzle to create a new block, and the first miner to do so is rewarded with newly created bitcoins. This incentivizes miners to secure the network and makes it difficult for any one entity to control the network.

Hash Cash PoW

HashCash, a proof-of-work algorithm, was designed by Adam Back in 1997 to prevent email spam and denial-of-service attacks. HashCash is now also being used in Bitcoin mining.

How HashCash Works

HashCash is a proof-of-work algorithm that requires a certain amount of computational work to compute. For email use, a textual encoding of a HashCash stamp is added to the header of an email. This stamp serves as proof that the sender has expended a modest amount of CPU time calculating the stamp prior to sending the email. The Hashcash stamp adds extra verification for emails and makes it unlikely that the email is being sent by a spammer. The receiver can verify the stamp at a negligible computational cost.

The Technical Details

The header contains the Hashcash format version, the number of partial preimage bits in the hashed code (known as the "bits"), the date that the message was sent, the resource data string being transmitted (such as an email or IP address), and a string of random characters encoded in base64 format. Additionally, the header contains information proving that the required computation has been performed. The recipient verifies the authenticity of the Hashcash stamp via checks including calculating the 160-bit SHA1 hash of the entire string and checking the date of the message to make sure it was sent recently. The recipient also ensures that the email address in the hash string matches any to which the recipient subscribes.

Implementation and Advantages/Disadvantages

HashCash is simple to implement and doesn't require real money, which is advantageous over micropayment proposals. However, it requires computational resources and is thus less accessible from low-end systems. As computers continue to get faster, the difficulty of the calculations required must be increased over time. HashCash can be incrementally deployed, so it can be adopted without a large upfront investment.

Applications

HashCash is used for false positives in automated spam filtering systems and as a means to slow down comment spam in blogs. It has also been implemented in the Mozilla Thunderbird email client and in Microsoft's Coordinated Spam Reduction initiative.

Overall, HashCash has been effective in combating email spam and denial-of-service attacks and continues to be a valuable tool in the fight against online threats.

Bitcoin PoW

Proof of Work (PoW) is a consensus mechanism used by the Bitcoin network to confirm transactions and add new blocks to the blockchain. It is a computationally intensive process that involves solving a complex mathematical problem called a cryptographic puzzle. The first node to solve the puzzle is rewarded with newly created bitcoins and transaction fees and is responsible for adding a new block of transactions to the blockchain.

The cryptographic puzzle used in Bitcoin's PoW mechanism is called the SHA-256 algorithm. The algorithm takes an input and produces a fixed-length output, known as a hash. The challenge for miners is to find a hash that meets a specific set of criteria, known as the target. This target is set by the network difficulty, which is adjusted every 2016 block to maintain a target block time of 10 minutes.

To solve the cryptographic puzzle, miners use specialized hardware, known as Application-Specific Integrated Circuits (ASICs), to perform billions of hash calculations per second. This process is known as mining, and it requires a significant amount of computational power and energy.

Once a miner solves the cryptographic puzzle and finds a hash that meets the target, they broadcast the new block to the network. Other nodes on the network then verify the block by checking that the transactions included in the block are valid and that the hash meets the target criteria. If the block is deemed valid, it is added to the blockchain, and the miner is rewarded with newly created bitcoins and transaction fees.

One of the benefits of Bitcoin's PoW mechanism is that it is designed to be decentralized, with no central authority controlling the mining process. Any node on the network can become a miner and participate in the mining process, provided they have the necessary hardware and energy resources.

However, there are also some drawbacks to Bitcoin's PoW mechanism. The energy-intensive nature of mining has led to concerns about the environmental impact of the Bitcoin network, with some estimates suggesting that the network consumes as much energy as a small country. Additionally, the increasing difficulty of mining and the centralization of mining pools have made it difficult for individual miners to compete and earn rewards.

Attacks on Pow and monopoly problems

While Bitcoin's Proof of Work (PoW) consensus mechanism is designed to be secure, it is still vulnerable to certain types of attacks. One such attack is known as a 51% attack, in which a single entity or group of entities controls more than 50% of the network's computational power. This would give the attacker the ability to manipulate the network by altering transactions, double-spending bitcoins, and blocking or censoring transactions.

A 51% attack is difficult to carry out in practice, as it requires a significant amount of computational power and energy resources. However, it is not impossible, and there have been several instances of smaller blockchains suffering from 51% attacks. In 2018, the cryptocurrency Verge suffered multiple 51% attacks, leading to losses of over $1 million.

Another issue with Bitcoin's PoW mechanism is the centralization of mining pools. Mining pools are groups of miners who combine their computational power and share the rewards of mining. While mining pools are beneficial for individual miners who may not have the resources to mine on their own, they can also lead to centralization and the potential for monopolies.

As mining becomes increasingly difficult and expensive, small-scale miners may drop out, leaving larger mining pools with a greater share of the computational power. This can lead to a situation where a small number of mining pools control the majority of the network's computational power, leading to concerns about centralization and the potential for monopolies.

To illustrate this issue, we can look at the distribution of Bitcoin's computational power, known as the Hashrate. As of March 2023, the top three mining pools control over 50% of the Hashrate, with the largest pool, F2Pool, controlling over 20%.

(Source: https://btc.com/stats/pool)

While this distribution is not necessarily a cause for concern, it does highlight the potential for centralization and the need for continued efforts to decentralize the mining process.

Proof of Stake:

Proof of stake is an alternative consensus mechanism that is gaining popularity in the cryptocurrency world. Rather than relying on computational power to secure the network, proof of stake requires users to hold a certain amount of the cryptocurrency to participate in the network's consensus process. This incentivizes users to hold and use the cryptocurrency, rather than simply mining it for profit.

Proof of Burn and Proof of Elapsed Time

Proof of burn and proof of elapsed time are two other alternative consensus mechanisms that have been proposed. Proof of burn involves burning or destroying coins to demonstrate commitment to the network, while proof of elapsed time involves randomly selecting a validator based on the amount of time they have been participating in the network.

The Life of a Bitcoin Miner

Bitcoin mining is a competitive and constantly evolving industry, with miners competing to earn newly created bitcoins and secure the network. To be successful, miners must have access to specialized hardware and software, as well as a reliable source of electricity to power their operations. The profitability of mining can fluctuate depending on a variety of factors, including the price of bitcoin, the difficulty of mining, and the cost of electricity.

Mining Difficulty

Mining difficulty is a measure of how difficult it is to find a valid hash for a new block in the Bitcoin network. As more miners join the network and more computational power is added, the difficulty of mining increases to maintain a consistent rate of block creation.

Mining Pool

Mining pools are groups of miners who pool their computational resources together to increase their chances of earning new bitcoins. Pools allow miners to share the rewards for mining new blocks, making it more accessible to smaller-scale miners who may not have the resources to mine on their own.

Conclusion

In conclusion, Bitcoin is a complex and constantly evolving network that relies on a variety of technologies and mechanisms to ensure its security and resilience. From the creation of coins through mining to the consensus mechanisms used to verify transactions, each aspect of the network plays an important role in its success. As the cryptocurrency industry continues to grow and evolve, it will be interesting to see how these technologies and mechanisms continue to develop and adapt to new challenges and opportunities.

Cross-Border Payments

One of the most promising applications of blockchain technology is cross-border payments. Traditional payment systems can be slow, expensive, and prone to errors. Blockchain technology can offer a faster, more secure, and cheaper way to send money across borders. By using blockchain, transactions can be processed in real-time, and intermediaries such as banks can be eliminated, reducing transaction costs.

For example, Ripple is a blockchain-based payment system that aims to facilitate cross-border payments. Ripple allows financial institutions to settle transactions in seconds, with end-to-end tracking and certainty. This technology has already been adopted by several financial institutions, including Santander and American Express.

Know Your Customer (KYC)

KYC is a process that financial institutions use to verify the identity of their customers. This process is crucial for preventing fraud, money laundering, and terrorism financing. However, the traditional KYC process can be time-consuming, expensive, and prone to errors. Blockchain technology can streamline the KYC process by creating a secure and immutable ledger of customer information.

For example, Deloitte has developed a blockchain-based KYC platform that allows financial institutions to share customer data securely and efficiently. This platform can reduce the time and cost of the KYC process, while also improving the accuracy of customer data.

Food Security

Food security is a major global challenge, with around 800 million people experiencing hunger or malnutrition. Blockchain technology can help improve food security by creating a transparent and traceable supply chain. By using blockchain, food producers, distributors, and retailers can track the movement of food products, ensuring that they are safe and meet regulatory standards.

For example, Walmart has implemented a blockchain-based system that allows the retailer to track the movement of food products from the farm to the store. This system can quickly identify the source of food contamination, allowing for a faster and more effective response to food safety issues.

Mortgage over Blockchain

Mortgage over the blockchain is an application of blockchain technology that aims to simplify the mortgage process. By using blockchain, mortgage lenders can create a secure and transparent ledger of mortgage transactions. This ledger can be used to track the ownership and transfer of mortgage assets, as well as to automate the payment and settlement process.

For example, Fannie Mae and Freddie Mac, two of the largest mortgage lenders in the US, are exploring the use of blockchain technology for mortgage transactions. This technology has the potential to reduce the time and cost of mortgage processing, while also improving the accuracy and security of mortgage transactions.

Blockchain-Enabled Trade

Blockchain-enabled trade is an application of blockchain technology that aims to improve the efficiency and security of global trade. By using blockchain, trade participants can create a secure and transparent ledger of trade transactions, reducing the risk of fraud and errors. This technology can also enable faster and more efficient trade finance, reducing the time and cost of trade transactions.

For example, Maersk and IBM have developed a blockchain-based trade platform that allows participants to track the movement of goods and documents across the supply chain. This platform can reduce the time and cost of trade transactions, while also improving the security and transparency of trade.

We Trade - Trade Finance Network

We Trade is a blockchain-based trade finance network that aims to simplify the trade finance process. By using blockchain, We Trade can create a secure and transparent ledger of trade finance transactions, reducing the time and cost of trade finance. This network also allows trade participants to access a range of trade finance services, including financing, insurance, and logistics.

We Trade was developed by a consortium of nine major banks, including HSBC, Deutsche Bank, and Societe Generale. The platform has already processed over $1 billion in trade finance transactions, demonstrating the potential of blockchain technology to transform the trade finance industry.

Supply Chain Financing

Supply chain financing is an application of blockchain technology that aims to improve the efficiency and transparency of supply chain finance. By using blockchain, suppliers can create a secure and transparent ledger of supply chain transactions, allowing them to access financing more easily and at a lower cost.

For example, Komgo is a blockchain-based platform that aims to streamline the financing of commodities trade. The platform allows suppliers to create a secure and transparent ledger of supply chain transactions, allowing them to access financing more easily and at a lower cost. Komgo has already been adopted by several major commodity trading companies, including Shell and Mercuria.

Identity on Blockchain

Identity on the blockchain is an application of blockchain technology that aims to create a secure and transparent system for managing identity information. By using blockchain, individuals can create a digital identity that is secure, private, and verifiable. This technology can help reduce identity theft, fraud, and other forms of cybercrime.

For example, Civic is a blockchain-based identity platform that allows individuals to create a secure and verifiable digital identity. Civic uses biometric authentication, such as fingerprint scanning, to ensure that the identity information is accurate and secure. This technology has already been adopted by several businesses, including BitGo and Brave.

Conclusion

Blockchain technology has the potential to transform many industries, from finance to supply chain management. By creating a secure and transparent ledger of transactions, blockchain technology can improve efficiency, reduce costs, and increase security. As these applications of blockchain technology continue to develop and evolve, we can expect to see even more innovative uses of this groundbreaking technology in the future.

Blockchain promises to fundamentally solve the issues of time and trust to address inefficiencies in industries such as financial, healthcare, supply chain, logistics, etc. Blockchain's key features include data immutability and a shared ledger where transactional updates are performed by a consensus-driven trust system.

With the blockchain system design, we are attempting to build a system that implied trust. This trust system leads to reduced risks, and various applied technology constructs sucha as cryptography, smart contracts, and concesus essentially create gates to not only reduce risk but to also infuse added security into the transaction system.

What are Public Ledgers

A public ledger is a way to keep all the transactions on a particular blockchain open and accessible to the public. This provides transparency and openness, though it is publically available and accessible to the general public this ledger is immutable i.e can't be modified.

Here are some of the examples from the Ethereum Blockchain

Business Logic with Smart Contact

Smart contracts are business logic that is stored on the blockchain (hence immutable) that runs when predetermined conditions are met. They typically are used to automate the execution of an agreement so that all participants can immediately be certain of the outcome, without any intermediary's involvement or time loss.

Some benefits of using a Smart Contract

• Speed, efficiency, and Accuracy: Once the conditions are met smart contracts are executed immediately as they are digital and automated, and there's no paperwork to process or filling/refilling documents which can lead to human errors.

• Trust and Transparency: Smart Contract establishes trust as there is no third party involved and once Smart Contracts are deployed it's immutable meaning no one can change the conditions of the contract.

• Security: Blockchain is immutable in nature hence anything deployed on the blockchain is also immutable. On top of the immutability, a Smart contract is highly encrypted and can't be hacked by using current technologies available to humankind.

• Savings: Smart contracts are fully automated and hence do not requires any intermediately to handle transactions, which automatically decreases the time and fees associated with them.

How Blockchain Works

I have already written an extensive blog about how blockchain works here. But In case you don't want to read it below is a point-by-point summary.

Blocks in Blockchain

A Blockchain is made of smaller chunks of transactions called Blocks. Each transaction creates a new block which is then added to the Blockchain. A block in the blockchain roughly looks like below and has some properties like pevHash, Timestamp, Merkle Root, etc like below. This creates an unbreakable chain of blocks that cannot be altered, ensuring the security and integrity of the data. We will look at Merkle Tree and Hash Pointer later in this article.

Transactions

A blockchain transaction is a transfer of value between two parties on a blockchain network. It is a fundamental concept of blockchain technology and is critical to the functioning of any blockchain-based system.

When a transaction occurs on the blockchain, it is validated, verified, and then recorded on the blockchain ledger. Each transaction is recorded as a block on the blockchain network, and these blocks are linked together in a chain using cryptographic hash functions.

This linkage is what makes blockchain immutable and increases security. If a Hacker wants to change the data in Blockchain they have to change the linkage of each block through out the Blockchain network.

Below is a representation of How Transactions work in Blockchain.

Distributed Consensus

With the rise of computers and the Internet, data started to be stored in a distributed way this solved a lot of problems but came with its challenges. One of the challenges we faced was the validation of the data which is added and this needed some consensus algorithms.

In Blockchain we also need a consensus mechanism/ algorithm to validate each transaction to be added to the distributed ledger i.e Blockchain. Famously Proof of Work (POW) is used in blockchains like bitcoin. Ethereum has moved to Proof of Stake (POS) for its consensus mechanism. There are other ways to validate the transaction and once the transaction is validated, it is added to the Blockchain.

Public Vs Private Blockchain

Private Blockchains are also known as permission network similarly Public Blockchain network is known as Permisionless Network. A blockchain supporting a cryptocurrency is public in the sense that anyone can participate without a specific identity. Such blockchains typically use a consensus protocol based on Proof of Work (PoW).

In contrast, permissioned blockchains have evolved as an alternative way to run a blockchain between a group of known, identified participants. A permissioned blockchain provides a way to secure interactions between a group of entities that share a mutual goal but don't fully trust each other, such as businesses that exchange funds, goods, or information. A permissioned blockchain relies on the identities of its peers, and in so doing can use the traditional Byzantine-fault tolerant (BFT) consensus.

To understand more about it you can watch the following video:

Understanding Crypto Currency to Blockchain

A cryptocurrency is a form of digital currency that is secured using cryptography, making it difficult to counterfeit or double-spend. Cryptocurrencies operate independently of a central bank and use a decentralized ledger called a blockchain to record transactions. Blockchain technology uses a distributed network of computers to maintain a secure and transparent record of transactions, which cannot be altered without consensus from the network.

Cryptocurrencies like Bitcoin, Ethereum, and Litecoin are among the most popular examples of cryptocurrencies. Bitcoin, the first cryptocurrency, was created in 2009 by an unknown person or group using the pseudonym Satoshi Nakamoto. Bitcoin and other cryptocurrencies have grown in popularity and are now widely accepted as payment by many merchants.

Permissioned Model of Blockchain

A permissioned blockchain is a type of blockchain that restricts access to authorized users. It is sometimes referred to as a private blockchain, as it is not open to the public. In a permissioned blockchain, participants must be granted permission to view or modify the blockchain data.

Permissioned blockchains are often used by businesses and organizations that require more control over their data. For example, a financial institution might use a permissioned blockchain to manage its records and transactions. This would allow the institution to maintain control over its data while still benefiting from the security and transparency of blockchain technology.

In a permissioned blockchain, the consensus is often achieved through a smaller group of nodes or validators, rather than a larger network of nodes as in a public blockchain. This allows permissioned blockchains to be more efficient, as consensus can be reached more quickly.

Overall, permissioned blockchains offer a way for businesses and organizations to benefit from the security and transparency of blockchain technology while still maintaining control over their data. This makes permissioned blockchains an attractive option for many industries, including finance, healthcare, and supply chain management.

Overview of security aspects of Blockchain

Security is a critical aspect of blockchain technology, as it involves the storage and management of sensitive data. Blockchain technology offers several security measures, including cryptography, consensus mechanisms, and immutability.

Basic Crypto Primitives

Cryptography is a central concept in blockchain technology. It is the science of secure communication in the presence of third parties. Some of the basic crypto primitives used in blockchain technology include:

1. Cryptographic Hash Function: A cryptographic hash function is a mathematical function that takes input data of arbitrary size and produces a fixed-size output known as a hash. The output is a unique representation of the input data, and even a slight change in the input data will result in a different hash output. This property makes cryptographic hash functions ideal for securing data integrity in blockchain technology.

2. Digital Signature: A digital signature is a mathematical scheme used to verify the authenticity of digital documents or messages. It is similar to a handwritten signature but uses digital keys instead of a pen. Digital signatures are used to verify the authenticity of blockchain transactions.

3. Public Key Cryptography: Public key cryptography, also known as asymmetric cryptography, uses a pair of keys (a public key and a private key) to encrypt and decrypt messages. The public key is used to encrypt the message, while the private key is used to decrypt it. Public key cryptography is used to secure blockchain transactions and ensure the privacy and confidentiality of data.

Cryptographic Hash Function

A cryptographic hash function is a mathematical function that takes input data of arbitrary size and produces a fixed-size output known as a hash. The output is a unique representation of the input data, and even a slight change in the input data will result in a different hash output. Cryptographic hash functions are used in blockchain technology to ensure data integrity and security.

Properties of the Hash Function:

The properties of the hash function include:

1. Deterministic: The same input data will always produce the same hash output.

2. One-Way: It is computationally infeasible to find the input data from the hash output.

3. Collision Resistance: It is computationally infeasible to find two different inputs that produce the same hash output.

4. Fixed Output Length: The hash output is always of a fixed length, regardless of the input data size.

Hash Pointer and Merkle Tree

A hash pointer is a pointer that contains the hash of the data it is pointing to. Hash pointers are used in blockchain technology to link blocks together in a chain. A Merkle tree is a data structure that uses hash pointers to efficiently verify the integrity of large amounts of data. In blockchain technology, Merkle trees are used to verify the integrity of transactions.

Digital Signature

A digital signature is a mathematical scheme used to verify the authenticity of digital documents or messages. It is similar to a handwritten signature but uses digital keys instead of a pen. Digital signatures are used to verify the authenticity of blockchain transactions.

Public Key Cryptography

Public key cryptography, also known as asymmetric cryptography, is a cryptographic technique that uses a pair of keys - a public key and a private key - to encrypt and decrypt messages. The keys are mathematically related, but it is computationally infeasible to derive the private key from the public key.

In public key cryptography, the public key is widely distributed and can be freely shared with anyone who wants to communicate with the owner of the private key. The private key, on the other hand, is kept secret and only known to the owner.

To encrypt a message, the sender uses the recipient's public key to scramble the message, making it unreadable to anyone who intercepts it. The recipient then uses their private key to decrypt the message, making it readable again.

To sign a message, the sender uses their private key to generate a unique digital signature for the message. The recipient can then use the sender's public key to verify the authenticity of the signature and the message.

Public key cryptography has several advantages over symmetric key cryptography, where the same key is used for both encryption and decryption. One of the main advantages is that public key cryptography does not require the exchange of secret keys, which can be a vulnerability in symmetric key cryptography. Another advantage is that public key cryptography allows for digital signatures, which can be used to verify the authenticity of messages and ensure that they have not been tampered with.

Public key cryptography is widely used in blockchain technology to secure transactions and ensure the privacy and confidentiality of data. In a blockchain network, each user has a unique public key and private key pair, which they use to sign and verify transactions. Transactions are broadcast to the network and verified by other nodes using the sender's public key. Once a transaction is verified, it is added to the blockchain and becomes part of the permanent record.

A basic Crypto Currency

A basic cryptocurrency is a digital currency that uses cryptography to secure and verify transactions. Bitcoin is the most well-known cryptocurrency, but there are many others, such as Ethereum, Litecoin, and Ripple. Cryptocurrencies use blockchain technology to create a decentralized, peer-to-peer payment network that is not controlled by any central authority. Cryptocurrencies offer several advantages over traditional currencies, including lower transaction fees, faster processing times, and greater transparency. However, they also present some risks, such as

TL;DR

The article provides an overview of blockchain technology, including its key features and benefits. It explains the concept of public ledgers, smart contracts, and how blockchain works, including blocks, transactions, and distributed consensus. The article also discusses the difference between public and private blockchains, as well as the security aspects of blockchain technology, including basic crypto primitives, cryptographic hash functions, digital signatures, and public key cryptography. Finally, the article provides a brief overview of cryptocurrencies and their advantages and risks.

Well, I don't belong to a Tier-1 college, and neither I have a pretty good mentor to guide me, I spent most of my college days stuck in my home (No Thanks to the Pandemic) without proper guidelines and structure and was still able to bag a first class job as Product Engineer by the end of my last sem of college.

If you are in a similar situation to me or a self-taught developer here is my 2 Penny advice you should listen to, READ.

Reading can excel your career more than any course can.

Here are my Top suggestion to Read some are biased toward web developers and others are Pretty generic.

Design Patterns and Advance Web dev stuff.

Web.dev

If you are obsessed with web performance and good practices this website is the go-to. Web.dev is all about writing cross-browser performant web applications. This is mostly written by the developer and other team members of chrome.

The website offers various resources for web developers, including blog articles, courses, code patterns, case studies, podcasts, and recordings of sessions with the Chrome team. The content covers different areas of web development and includes information on UI, performance, and cross-browser compatibility. The website emphasizes the importance of supporting multiple browsers, and many articles include data on browser compatibility from MDN's Browser Compat Data project.

Refactoring Guru

If you already haven't heard about it you should definitely check it out, this is number one website that can make you better at writing code. This website talks mostly about two things how to refactor code and the design patterns which you should use.
And if you are new, take my word for both are very important to understand while building large-scale systems.

News and Latest Updates.

If you are in the Tech world you need to be updated on what's hot in the market and what is happening and for that below is perfect.

DevBytes

In this busy world who has the type for reading long news? DevBytes fix this issue by crunching down the only important part of Tech news/ blogs in just 64 words. Sick Right?

Wait.. Wait that's not just it, DevBytes is a relatively new platform and understands your pain so not only 64 words sort blog DevBytes also have other options like Daily Digest, Code Snippet, Latest Jobs, Tech news, and whatnot.

If you are busy and juggling between multiple things you might want to try their app and get the most out of your time. Here is the link for the App.

HackerNews

HackerNews is a community-driven news aggregator website backed by Ycombinator where users submit and vote on technology-related stories. The site covers various topics, including web development, programming, startups, and tech industry news.

It has the most basic UI but it covers almost everything related to Tech, "If it's happening in Tech is in HN".

Personal Blogs

Now, this is totally biased, but here are some of my favorite Author blogs. Which I keep an 👀 on. (You get it right? Eyes on)

Josh W. Comeau

If you are a front-end developer and ever thought of building the sickest Blog ever build dude let me tell you, you have already lost to Josh. I mean look at all the personal customization and CSS.
Well it's true you might never build a sick blog like him but you can learn a ton from him. The blog covers front-end development, CSS, JavaScript, and design topics. It also features in-depth tutorials and code snippets.

Pro tip: He also runs a newsletter ✉️ so you don't miss anything from him.

There are tons of blogs out there but it's totally up to you if you find yourself reading this blog now. Mind giving me a follow?

Newsletters

Newsletters are my favorite, I mean getting the best blogs right into your email? What else do you want? Chill and Relax.
The pain point for Newsletters are they are mostly paid :( but good news mine is not. You can subscribe to my newsletter for free.

ByteByteGO

This newsletter is Run by Alex Xu a Teacher, A programmer, and A technical writer. He has been delivering amazing blogs and videos around System Design and Interview preparation. If you like looking at the depth of a system or are just curious about how something works definitely check him out.

The Pragmatic Engineer

Well, this is another newsletter I closely follow and Like, this has a pinch of knowledge that contains pure Technical topics, as well as business, build around tech and other General topics.
FUN FACT: While writing this I just received the latest edition to their newsletter, Fate? I don't think so.

Conclusion

So in conclusion! If you're a self-taught developer like me, or if you don't have a mentor to guide you, I've got some advice for you that has helped me become a better developer. My top suggestion is to read! Reading can help excel in your career more than any course can. In this article, I've shared some of my favorite resources for web developers, such as Web.dev and Refactoring Guru, as well as news and the latest updates sources like DevBytes and HackerNews. I've also recommended some personal blogs, like Josh W. Comeau's blog, and newsletters like ByteByteGO and The Pragmatic Engineer. By leveraging these resources, you can improve your skills and stay updated with the latest tech trends. So, start reading and enhancing your career prospects!

Hello 👋, I am Ashish Maurya a software developer and part-time freelance developer. Recently I was given a task to minimize the React bundle size and optimize the whole application as much as possible. Well, this might seem like an easy job but finding the right solution for your test case can be daunting. I am just gonna mention some of the tried and tested methods we used to reduce our React bundle size from 7 MB (main.js) to ~700kb (main.js) and reduced the Initial loading time from more than the 20s to ~1s in fast 3G.

Importance of fast loading times

A one-second delay in page load time has been shown to cause a 7 percent loss in conversion and 11 percent fewer page views. For an online store earning $50,000 a day, that one-second delay adds up to more than $1 million in lost sales each year .

You can understand how big of a change even 1s can make when it comes to loading time in a large-scale business.

Amazon found that every 100 milliseconds of latency cost them 1% in sales.

Below are some of the comparisons I found on Rush.com while researching this article.

• if your site loads in 5 seconds, it is faster than approximately 25% of the web

• if your site loads in 2.9 seconds, it is faster than approximately 50% of the web

• if your site loads in 1.7 seconds, it is faster than approximately 75% of the web

• if your site loads in 0.8 seconds, it is faster than approximately 94% of the web

We were able to achieve a very low loading time as of now using the following method and I am gonna show you how can you do that too.
Here is a BrowserStack speed lab report.

We are still working to get a better ranking and will update more optimization methods as we explore them.

React bundle size as a factor

Let's try to understand how the browser loads our React page. From the server, we ship the HTML file and if you clearly observe the HTML file you will see a script tag that is calling your main.js a chunk that is eventually responsible for everything in your React if you are not using SSR.

The bigger is the main.js chunk also main.css chunk the more time it will take to load and parse. Meaning reducing our React bundle size can eventually reduce the initial page loading time.

Analyzing the React bundle

Analyzing the react bundle should be the entry point in optimizing the website's load time. React bundle contains several components and it's important to identify them and pick out the largest bundle to optimize them.

Tools for analyzing the bundle

Several tools are available for analyzing the React bundle. Webpack Bundle Analyzer and Source Map Explorer are popular tools that can be used to analyze the bundle's components and their sizes.

In this article, we will be taking a glance at some tools, and then we will learn how to use them to Optimize our React bundle size.

Webpack bundle Analyzer

If you are using webpack as a bundler this should be your go-to point for getting a better look at your bundle. It is very easy to install and use.

# NPM
npm install --save-dev webpack-bundle-analyzer
# Yarn
yarn add -D webpack-bundle-analyzer

for Webpack config:

const BundleAnalyzerPlugin = require('webpack-bundle-analyzer').BundleAnalyzerPlugin;

module.exports = {
  // other webpack config options
  plugins: [
    // other plugins
    new BundleAnalyzerPlugin(),
  ],
};

You might be using Craco to extend the webpack plugins in that case you can use the below code.

const BundleAnalyzerPlugin = require('webpack-bundle-analyzer').BundleAnalyzerPlugin;

module.exports = {
  // other webpack config options
  plugins: [
    // other plugins
    new BundleAnalyzerPlugin(),
  ],
};

Source Map

Similarly, you can use a generated Source Map to analyze the bundle and I identify the big chunks in your javascript bundle.
Here is a good npm library to achieve that.

Strategies for minimizing React bundle size & Implementation

I have compiled a list of effective strategies that have proven successful for us and can benefit your business as well.

Using smaller libraries

As you already saw above the bigger bundle can drastically increase your React Bundle size and can negatively impact your loading time. Finding a better alternative is always recommended.

Let's see an example :

A popular library for formatting is Date's Momentjs which is approx 4 MB instead you can use another library that satisfies your needs and has a smaller size.

I understand there are gonna be times you don't have any option to change the library in our case we were using Monaco one whose uncompressed size is 82 MB and we don't have any other alternative to go with. The following methods will help you solve the issue.

Code splitting

Now if the above does not work for you or you want to reduce the React bundle size further you can do some Code Splitting. As the project grows the size of the application grows as well, especially when you are using third-party libraries. We can split that code into chunks and only load the chunk needed for the initial page load; the rest are loaded on a need basis. This doesn't reduce the size of your application but divides the React bundle size into chunks which can be lazy loaded as we need them.

If you are using React you can achieve it using React.lazy() but if you want you can use webpack to do this.

// webpack.config.js
module.exports = {
  entry: './app.js',
  output: {
    filename: 'bundle.js',
    path: __dirname + '/dist',
  },
  optimization: {
    splitChunks: {
      chunks: 'all',
      minSize: 10000,
      maxSize: 250000,
    },
  },
};

Additionally, we will explore how to utilize Code splitting and React's Lazy loading to diminish the overall size.

Lazy loading

Lazy loading is a strategy to identify resources as non-blocking (non-critical) and load these only when needed. It's a way to shorten the length of the critical rendering path, which translates into reduced page load times.

Once the code is split we need to asynchronously load them to the browser on a need basis. React has a method that does it out of the box hence we don't need to take the case or split the code and lazy load them.

For example :

import React, { lazy, Suspense } from 'react';

const MyLazyComponent = lazy(() => import('./MyLazyComponent'));

function MyComponent() {
  return (
    <div>
      <Suspense fallback={<div>Loading...</div>}>
        <MyLazyComponent />
      </Suspense>
    </div>
  );
}

export default MyComponent;

In the above example, we are Lazy Loading a component. Meaning the Lazy loaded component will not be bundled in the main chunk and will be served by the server when the MyComponent will render.
This significantly reduces the React bundle size and optimizes the overall behavior if done right. It's best to have a better insight into user behavior on your website to optimize better using this method.

In my opinion, it's best to start with Route-based splitting and then move on to Component-based splitting.

You can read more about them here.

Tree shaking

Tree shaking is a term commonly used within a JavaScript context to describe the removal of dead code.

It relies on the import and export statements to detect if code modules are exported and imported for use between JavaScript files.

In modern JavaScript applications, we use module bundlers (e.g., webpack or Rollup) to automatically remove dead code when bundling multiple JavaScript files into single files. This is important for preparing code that is production ready, for example with clean structures and minimal file size.

Minification

Minification is a process in which the bundlers try to minimize the code further by removing Whitespaces, and comments, or shortening the long variable names into smaller names.
This can be done easily in Webpack by including a minifier plugin called Terser.

You simply install the plugin

npm install terser-webpack-plugin --save-dev

or,

yarn add -D terser-webpack-plugin

or

pnpm add -D terser-webpack-plugin

Then add the plugin to your webpack config. For example:

const TerserPlugin = require("terser-webpack-plugin");

module.exports = {
  optimization: {
    minimize: true,
    minimizer: [new TerserPlugin()],
  },
};

You can read more about this plugin and its uses here. So that you can tweak it as per your need.

Compression

Compression is a technique that is used mostly by servers to compress the assets before serving them over to the network. This makes a whole lot of difference ass such as 70% of your React bundle size can be optimized using this method if your server already not doing them.

Widely accepted Algorithms are Gzip, Brotli, and Deflate. Where Gzip is accepted by all browsers nowadays.

This method is not related to React but it's standard practice, Below we will be using two examples below:

For express servers:

const express = require('express');
const compression = require('compression');
const path = require('path');

const app = express();

// add compression middleware
app.use(compression());

// serve static assets from the build folder
app.use(express.static(path.join(__dirname, 'build')));

// serve index.html for all remaining routes
app.get('*', (req, res) => {
  res.sendFile(path.join(__dirname, 'build', 'index.html'));
});

const port = process.env.PORT || 3000;
app.listen(port, () => {
  console.log(`Server is listening on port ${port}`);
});

For Nginx Server :

gzip on;
gzip_types text/plain text/css application/json application/javascript text/xml application/xml application/xml+rss text/javascript;

You can add the above code to Nginx.config to make all the requests Gziped.

Advance Concepts to minimize React bundle size

SSR

One of the most well-established methods for rendering web content is server-side rendering (SSR). When a user requests a page, SSR generates the complete HTML for the content, which may incorporate information from a datastore or external API.

Simply your React application gets rendered to HTML by the server and then sent to the Browser. By this method, we reduce the huge chunk of Javascript that is needed in the first place to initially load the website.

Once the content is loaded then by the method of hydration we add the javascript to the rendered HTML and the functionality can take place.

SSR has several benefits like better SEO, FP, FCP, TTI being shorter, and FCP = TTI. But it's a complicated process you can use NextJS which does it out of the box and saves a lot of time.

Server Component [ Experimental ]

Server components are the new talk in the town which is supposed to be Zero-bundled Size. Learn more about it here.

Testing and measuring results

Importance of testing

After all the optimization how are you gonna know if there's a performance boost or reduction in size or if all the work was in vain or if we really got the result we wanted?

Here are some ways you can check the performance of your react web app.

Tools for measuring load times

• Dev Tools: Almost every famous browser except Safari has this tool inbuilt into the browser itself. You can rich click right now and see inspect right now,

  

  this tool offers several tabs to have better insights but to see the decrease in our React bundle size you should head to the Network tab and filter to JS and CSS like below.

• Google Light House: This tool gives a full analysis of your web page and extra info like TTL, FCP, SEO, Performance, etc. This is only available in google chrome only.

  

• Mobile-Friendly Test: This is especially for mobile pages If your client base is mostly mobile users. You should definitely check it out. This is more used for SEO and how your page is seen by the crawlers.
  You can read more about SEO and SEO optimization in the below blog.

crack-the-code-of-search-engine-success

Comparing results before and after implementation

Here are some of the screenshots I took while debugging the speed and size of the main chunk.

Before Optimization and after code splitting.

After all the optimization.

The main chunk size is 740kb and the loading time is 2.50s which is in server cold start.

Conclusion

In conclusion, optimizing React bundle size is crucial for faster loading times, which can significantly impact a business's revenue and user experience. By analyzing the bundle, identifying the largest components, and implementing strategies such as using smaller libraries, code splitting, lazy loading, tree shaking, minification, and compression, developers can reduce React bundle size and improve performance. Additionally, advanced concepts such as server-side rendering and server components can further optimize React applications. Continuous monitoring and optimization are also essential to ensure sustained performance improvements. By implementing these strategies and continuously optimizing, developers can create fast and efficient React applications that provide an excellent user experience.

Recap of strategies

A recap of strategies mentioned in the article to minimize React bundle size for faster loading times are:

1. Analyzing the React bundle

2. Identifying the largest components

3. Using smaller libraries

4. Code splitting

5. Lazy loading

6. Tree shaking

7. Minification

8. Compression

9. SSR

10. Server Component (Experimental)

By implementing these strategies, developers can reduce the initial page loading time and provide a better user experience.

Final thoughts

React Bundle size should be kept as less as possible and we should always try to achieve it in a number of possible ways. In this article, I have given you generic strategies which are applicable to all React apps to reduce the React bundle Size.

However, if you have a huge codebase this might not solve all your problems in the next blog I will be talking about the Optimization you can do which is based on the user behavior and how they interact with your website.

If you read my blog so far and enjoyed it try following me on Twitter my handle is @theysaymaurya. Or if you need any consulting for your application feel free to reach out to me.

The Problem 😒

Well setting up one git account is easy setting up multiple accounts is not so much especially when you have to keep switching between the different git accounts. (As I mentioned part-time freelance developer)

Solution 👌

There is a way to set up multiple accounts in Git on the same machine using ssh keys. This article will show how to set up numerous git accounts on the same Machine.

Setting Up the SSH keys

Generating SSH keys.

• To generate SSH keys just open your favorite terminal or you can open Git bash and write the following command.

$ ssh-keygen -t ed25519 -C "your_email@example.com"

• Once that is done, you will be prompted to enter a file name. You can name it anything but in case you already have .ssh keys, don't name it the same or else it will be overwritten.

For this article, I will use test it as a dummy username but you can name it anything you like. In case you want to check for existing keys follow this Link.

• After this, you will be asked to enter a passphrase. You can read more about the passphrase here.

With SSH keys, if someone gains access to your computer, the attacker can gain access to every system that uses that key. To add an extra layer of security, you can add a passphrase to your SSH key. To avoid entering the passphrase every time you connect, you can securely save your passphrase in the SSH agent.

• You will see a key fingerprint will be generated.

Adding SSH key

• Once you are done with the above steps you will be needing to add the SSH key. For that, you can run the following command.

$ eval "$(ssh-agent -s)"
>> Agent pid 375

• Add your SSH private key to the ssh-agent. If you created your key with a different name, or if you are adding an existing key that has a different name, replace the test in the command with the name of your private key file.

$ ssh-add ~/.ssh/test
Identity added: /c/Users/Lenovo/.ssh/test (your_email@example.com)

Adding the above SSH key to GitHub

• Copy the above SSH public key to your clipboard.

    $ clip < ~/.ssh/test.pub
      # Copies the contents of the test.pub file to your clipboard
  

• Open the setting in your GitHub account.

• Open the SSH key & GPG keys from the sidebar.

• Click on add New Key and a prompt will open in that text area paste the keys and Add them.

• Once that is added you have added the key Successfully.

Adding more Accounts and Managing them.

Adding Account

Now repeat the same process for your work account or personal account. And once done.

Maintaining multiple Accounts

1. Edit/Create ssh config file (~/.ssh/config):

    # Default github account: personal
    Host github.com
       HostName github.com
       IdentityFile ~/.ssh/personal # your personal SSH key
       IdentitiesOnly yes
   
    # Other github account: test
    Host github-test
       HostName github.com
       IdentityFile ~/.ssh/test #Your test/ Organization key
       IdentitiesOnly yes
   

2. Adding SSH private key to your agent.

    $ ssh-add ~/.ssh/personal
    $ ssh-add ~/.ssh/test
   

3. Test the connection.

    $ ssh -T git@github.com
    $ ssh -T git@github-test
   

   you will get the following prompt with each command, you might see this kind of warning type yes in each case.

    The authenticity of host 'github.com (192.30.252.1)' can't be established.
    RSA key fingerprint is xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:
    Are you sure you want to continue connecting (yes/no)?
   

4. If everything is OK, you will see these messages:

    Hi personal! You've successfully authenticated, but GitHub does not provide shell access.
   

    Hi test! You've successfully authenticated, but GitHub does not provide shell access.
   

5. Now all are set, just clone your repositories

    $ git clone git@github-test:org2/project2.git /path/to/project2
    $ cd /path/to/project2
    $ git config user.email "test@org2.com"
    $ git config user.name  "Test"
   

Conclusion

In conclusion, setting up multiple Git accounts on the same machine can be tricky, but it is possible with the use of SSH keys. By following the steps outlined in this article, you can easily manage multiple Git accounts from the same machine. With SSH keys, you can securely access multiple accounts without having to constantly enter and store passwords.

References

https://github.com
https://gist.github.com/oanhnn/80a89405ab9023894df7
https://www.freecodecamp.org/news/manage-multiple-github-accounts-the-ssh-way-2dadc30ccaca/

Note: In javascript everything thing ( well almost everything! ) is an Object.

Meaning when I am talking about copying an object that includes, string, arrays, objects, functions, and other data types except null and undefined.

But why do we need to copy an Object in Javascript one may ask?

consider :

let obj1 = {
    a : "1234"
}

let obj2 = obj1 

obj1.a // "1234"
obj2.a // "1234"

Here, we already had an obj1 which has a property a we want to have this exact value to be stored in another object say obj2. Now the simplest thing to do is to an assignment operation obj2 = obj1 now obj2 also has a a property in it.

but, let's change the value obj1.a to something else and see how it affects the obj2.

consider :

let obj1 = {
    a : "1234"
}

let obj2 = obj1 

obj1.a // "1234"
obj2.a // "1234"

obj1.a = "something else"

Expected behavior :

obj1.a // "something else"
obj2.a // "1234"

Actual behavior :

obj1.a // "something else"
obje2.a // "something else"

That's might seem like a weird side-effect to you but it just means you don't yet understand how javascript stores the values in Input. Let's understand it in the further article.

Understanding Javascript Object Mechanisms

To understand the above behavior you need to understand how Javascript Objects work and how the values are stored in the Javascript. Well, Javascript does not store the exact value but instead, it contains a reference to the memory where the value is stored.

Does it make sense? If not below illustration may help you to understand better.

As in Above Diagram you can see in MyObject.a and MyObject.b have a value stored where values are Object1 and arr1 . But In actuality, the value is not stored instead the reference to memory is saved.

So in our previous example when we changed the value of obj1.a to something else the value is changed but obj2 still referred to obj1 hence it changes with it.

DeepCopy VS ShallowCopy

Let's understand these two ways to fully understand how we can finally be able to understand how to copy an object in Javascript.

1. Shallow Copy

   A shallow copy of an object only creates a new reference to the same object, not a completely new object. This means that if you modify a property of the shallow copy, the original object will also be modified because both objects reference the same underlying object.

   Example:

let originalObj = {a: 1, b: {c: 2}};
let shallowCopy = Object.assign({}, originalObj);
console.log(originalObj.b === shallowCopy.b) // outputs: true
shallowCopy.b.c = 3;
console.log(originalObj.b.c) // outputs: 3

1. Deep Copy

   A deep copy, on the other hand, is a copy of an object that is completely independent of the original object. Changes made to the properties of the deep copy will not affect the properties of the original object.

   Example:

let originalObj = {a: 1, b: {c: 2}};
let deepCopy = JSON.parse(JSON.stringify(originalObj));
console.log(originalObj.b === deepCopy.b) // outputs: false
deepCopy.b.c = 3;
console.log(originalObj.b.c) // outputs: 2

Note: Using the above method may cause some problems with Date Object as it's a Javascript Object.

Hence while deep copying it is advised to use the popular OSS library's lodash `_.cloneDeep()` method or write a program that recursively does copy in each level of a nested Javascript Object.

Methods to copy Objects.

In JavaScript, there are several methods to copy an object:

1. Shallow copy using the spread operator ...

goCopy codeconst original = { a: 1, b: 2 };
const copy = { ...original };

Pros:

• Easy to use

• Works with all enumerable properties, including arrays and objects

Cons:

• Only creates a shallow copy, meaning that any nested objects or arrays are still referenced and not copied.

1. Shallow copy using Object.assign()

javascriptCopy codeconst original = { a: 1, b: 2 };
const copy = Object.assign({}, original);

Pros:

• Easy to use

• Works with all enumerable properties, including arrays and objects

Cons:

• Only creates a shallow copy, meaning that any nested objects or arrays are still referenced and not copied

1. Deep copy using JSON.parse(JSON.stringify(obj))

javascriptCopy codeconst original = { a: 1, b: 2, c: { d: 3 } };
const copy = JSON.parse(JSON.stringify(original));

Pros:

• Easy to use

• Creates a deep copy, meaning that any nested objects or arrays are also copied

Cons:

• Will not work for objects with circular references or for non-JSON data types (e.g. functions, symbol properties)

• Can be slow for large objects

1. Deep copy using a custom function

scssCopy codefunction deepCopy(obj) {
  if (typeof obj !== 'object' || obj === null) {
    return obj;
  }

  let copy;
  if (Array.isArray(obj)) {
    copy = [];
    for (let i = 0; i < obj.length; i++) {
      copy[i] = deepCopy(obj[i]);
    }
  } else {
    copy = {};
    for (const key in obj) {
      if (obj.hasOwnProperty(key)) {
        copy[key] = deepCopy(obj[key]);
      }
    }
  }

  return copy;
}

Pros:

• Creates a deep copy, meaning that any nested objects or arrays are also copied

• Can handle objects with circular references or non-JSON data types

Cons:

• More complicated to implement

• Slower for large objects compared to JSON.parse(JSON.stringify(obj))

1. Deep copy using Lodash's _.cloneDeep() method

javascriptCopy codeconst _ = require('lodash');
const original = { a: 1, b: 2, c: { d: 3 } };
const copy = _.cloneDeep(original);

Pros:

• Easy to use

• Creates a deep copy, meaning that any nested objects or arrays are also copied

• Can handle objects with circular references or non-JSON data types

• Generally faster for large objects compared to a custom deep copy function

Cons:

• Requires the Lodash library to be installed

• Adds extra size to your codebase if you only need this single function.

1. Using Javascript's Native structuredClone() method

// Create an object with a value and a circular reference to itself.
const original = { name: "MDN" };
original.itself = original;

// Clone it
const clone = structuredClone(original);

console.assert(clone !== original); // the objects are not the same (not same identity)
console.assert(clone.name === "MDN"); // they do have the same values
console.assert(clone.itself === clone); // and the circular reference is preserved

Pros :

• Javascript Native Support hence no library is required.

Cons:

• This method is not a part of ECMAScript it was added to the platform-specific parts.

Conclusion

In conclusion, copying an object in JavaScript can be a complex task due to its nature of storing references instead of actual values. Shallow copy is created by methods such as spread operator (...), Object.assign(), and only creates a new reference to the same object, modifying the property in the shallow copy will affect the original object. On the other hand, a deep copy creates a completely independent copy of an object, and changes made to the properties of the deep copy will not affect the properties of the original object. It is advised to use popular libraries like lodash to create a deep copy or to write a program that recursively copies each level of a nested Javascript object.

I hope you all have seen the NEXTJS conference and all the new things that are shipped with the release of NEXTJS 13, NEXTJS 13 had breaking changes and it changes how we used to work with NEXTJS before and React in general

Introduction to NEXTJS 13

Here are some cool features which are launched with NEXTJS 13 launch.

1. Turbo Pack

Introducing Turbopack: Rust-based successor to Webpack

Turbo Pack is a bundler-like web pack but it's powered by Rust and It is said to be 700x faster than Webpack and 10x faster than the famous bundler Vite.

below is the comparison drawing for the turbo pack and other bundlers.

Though Turbo might feel amazing, webpack has a vast plugin ecosystem that turbopack lacks for now but Vercel Team is working hard to build those. This is also the reason we can't use preprocessor and Tailwind like we used to use in the Next 12 and earlier versions.

2. Nested Routes

Nested routes are the best and most awaited feature we developers were waiting for though it is already been used in several other frameworks like Remix and it's finally in NEXTJS 13 now.

You will be having a simple app directory that is still in beta where you can define the layout and nested routes easily.

there are other features like dynamic OG image generation, Image, Layout, server components, and so on.., but with new technology, there is some trade-off as well, and one is we can't use Tailwind like we used to but there is a workaround to do that.

In this article, we will be discussing that workout and will be implementing that too.

Installing TailwindCSS With NEXTJS 13

Let's get started with the TailwindCSS and NEXTJS 13 with turbo pack

Note: Tailwind works fine with the simple command npm run dev but with flag --turbo it won't work as the turbo pack doesn't support the tailwind yet.

Now that we know that let's start with the basic installation.

if you are liking this article till now let's connect on Twitter :).

Installing NEXTJS 13

Open your favorite terminal and let's get started with the installation of NEXTJS 13. The following command will also generate the app directory where you can perform nested routes and other new features.

npx create-next-app@latest --experimental-app

Once that you can cd into the my-app which is now created.

Installing tailwind CSS in NEXTJS 13

Now we will install Tailwind in NEXTJS 13.

npm install -D tailwindcss postcss autoprefixer
npx tailwindcss init

run the above code inside your terminal which will create a new tailwind.config.js file for you.

Setting Up Tailwind CSS in NEXTJS 13

Once the installation is done we need to set up the tailwind with PostCSS. Create a new file called postcss.config.js and paste the following content into that.

// postcss.config.js

module.exports = {
  plugins: {
    tailwindcss: {},
    autoprefixer: {},
  },
};

once that is done we will configure the tailwind.config.js as per NEXTJS 13 requirements. Here we will be adding an experimental app dir too.

// tailwind.config.js

/** @type {import('tailwindcss').Config} */
module.exports = {
  content: ["./pages/**/*.{js,ts,jsx,tsx}", "./app/**/*.{js,ts,jsx,tsx}"],
  theme: {
    extend: {},
  },
  plugins: [],
};

Add the Tailwind directives to your CSS

once that is done Add the Tailwind directives to your CSS, just open the ./app/global.css and paste the below code on top.

/* ./app/global.css */

@tailwind base;
@tailwind components;
@tailwind utilities;

Setting up the input and output CSS files for the postCSS process.

Now the trick is to concurrently compile our Tailwind CSS and add that to our file using the npm package called concurrently.

Go ahead and install concurrently by running the following command.

npm i concurrently

once that is done make a new file in the app directory and call it output.css after that open your package.json and make changes as follows

// package.json

"dev": "concurrently \"next dev\" \"tailwindcss --input ./app/globals.css --output ./app/output.css --watch\"",
"build": "tailwindcss ./app/globals.css --output ./app/output.css && next build",

Add Compiled CSS to layout.tsx

import Head from "next/head";
// import "./globals.css";
import "./output.css";

export default function RootLayout({
  children,
}: {
  children: React.ReactNode;
}) {
  return (
    <html lang='en'>
      <Head>
        <title>Create Next App</title>
        <meta name='description' content='Generated by create next app' />
        <link rel='icon' href='/favicon.ico' />
      </Head>
      <body>{children}</body>
    </html>
  );
}

as you can see that I have commented on the global.css and imported output.css.

Testing our Code

Open the page.tsx inside the app directory and add some TailwindCSS utility classes to your codebase and run npm run dev --turbo to see those changes.

Note: Make sure you are adding --turbo flag to use the turbo pack.

// page.tsx

import Image from "next/image";
import styles from "./page.module.css";

export default function Home() {
  return (
    <div className='w-full bg-black'>
      <main className='flex justify-center items-center m-auto h-screen flex-col'>
        <div className='text-8xl '>
          Welcome to <a href='https://nextjs.org'>Next.js 13!</a>
        </div>
        <div className='text-4xl my-10 '>
          This is a Tailwind Example with Next.js 13
        </div>
      </main>

      <footer className={styles.footer}>
        <a
          href='https://vercel.com?utm_source=create-next-app&utm_medium=default-template&utm_campaign=create-next-app'
          target='_blank'
          rel='noopener noreferrer'
        >
          Powered by{" "}
          <span className={styles.logo}>
            <Image src='/vercel.svg' alt='Vercel Logo' width={72} height={16} />
          </span>
        </a>
      </footer>
    </div>
  );
}

Preview

TL;DR

Use concurrently with postCSS so that each time it gets compiled the commands are as follows

// package.json

"dev": "concurrently \"next dev\" \"tailwindcss --input ./app/globals.css --output ./app/output.css --watch\"",
"build": "tailwindcss ./app/globals.css --output ./app/output.css && next build",

If you liked this post and got to learn something new give it a like and let's connect on Twitter. %[https://twitter.com/theysaymaurya/status/1438924150588915716?s=20&t=kyRt69Oek_pc86i07IReRg]

How are you? I decided to write small snippets of code and hacks I find while developing things that might help you guys too.

So Today I Will be showing a recursive way to flatten an array and object . This gonna be a short tutorial for you guys.

Accesing a nested object using Recursion.

We will be flattening the below Object using our custom-built recursive Function.

sample object

{
  "isbn": "123-456-222",
  "author":
  {
    "lastname": "Doe",
    "firstname": "Jane",
    "address": {
      "street":"3856 Pooz Street",
      "city":"South River",
      "state":"New Jersey",
      "counrty":"United State", 
    }
  },
  "title": "The Ultimate Database Study Guide",
  "category": ["Non-Fiction", "Technology"]
}

The source Code for the Recursive function

const flat_an_object =(object)=>{

  let result = {}

  const recursiveFunction = (obj)=>{
    for (const key in obj){
      if(typeof obj[key] === "object" && 
         Array.isArray(obj[key]) ===false){
        recursiveFunction(obj[key])
      }
      else{
        result ={...result, [key] : obj[key] }
      }
    }
  }
  recursiveFunction(object);
  return result; 
}

you might ask why I have used the Array.isArray() method in the condition, let's see what is the reason if we remove this method from the Array then what kind of nested object we will get and how that flatten the object will look like.

This is the result of the flattened Object.

{
  '0': 'Non-Fiction',
  '1': 'Technology',
  isbn: '123-456-222',
  lastname: 'Doe',
  firstname: 'Jane',
  street: '3856 Pooz Street',
  city: 'South River',
  state: 'New Jersey',
  counrty: 'United State',
  title: 'The Ultimate Database Study Guide'
}

Here you can see that the object contains an array and it's also getting flattened. I recently posted a tweet about this too and you can see it here to know more about this behavior in Javascript.

after using that Array.isArray() method we will be getting the flattened Object. Now the object is not a nested object anymore.

results:

{
  isbn: '123-456-222',
  lastname: 'Doe',
  firstname: 'Jane',
  street: '3856 Pooz Street',
  city: 'South River',
  state: 'New Jersey',
  counrty: 'United State',
  title: 'The Ultimate Database Study Guide',
  category: [ 'Non-Fiction', 'Technology' ]
}

Flattening An Array or Accessing a nested Array

The same method can be applied to flatten an Array to the thing we change is instead of saying typeof Object === "object" we will use Array.isArray(key).

Let's see the code.

sample array

const sampleArray = [1, 2, 3, [4, 5, 6, [7, 8]]]

to flatten this array we will just use our previous function and recursively traverse them.

const flatAnArray = (array) => {

  let result = []

  // Todo : Define a level 

  const recursiveFunction = (arr) => {
    for (const key in arr) {
      if (Array.isArray(arr[key])) {
        recursiveFunction(arr[key])
      }
      else {
        result.push(arr[key])
      }
    }
  }
  recursiveFunction(array);
  return result;
}

the output of our code is as follows, we flattened our nested Array.

[1, 2, 3, 4,5, 6, 7, 8]

Other ways of flattening an Array.

There are several ways to flatten a nested Array in javascript and some inbuild methods are Array.flat() method with a depth infinity.

const arr = [1, 2, 3, [4, 5, 6, [7, 8]]]

console.log(arr.flat(infinity))

output :

[1, 2, 3, 4,5, 6, 7, 8]

Flattening with a depth of 1

1 . using reduce()

let flatArray = arr.reduce((acc, curVal) => {
    return acc.concat(curVal)
}, []);

console.log(flatArray)

1. using concat() with apply()

let flatArray1  = [].concat.apply([], arr);

outputs:

[ 1, 2, 3, 4, 5, 6, [ 7, 8 ] ]

TL;DR

1. Use recursion to flat a nested object by looping over each property and checking if the typeof the property is of type object, then recursively loop over that object and keep adding the result to the result object.

2. Use Array.flat() method in case of flattening a nested Array.

After a couple of minutes, I quickly come up with a solution thanks to Github Copilot. Well, let's get started on this tutorial.

Reading writing to a CSV file using a Nodejs

Building a Node.js application

Let's go ahead and build a simple NodeJs application using npm. If you don't already have Nodejs installed in your system please go ahead and do that.

npm init --y

--y is an optional flag to start with the default configuration. Once that is done you can put any CSV file you want to read from or write to.

Reading from CSV file

First, of all let's look at how we can read the data and parse it in the way we want that, I will be trying only to parse the data in form of the object. Shall we get started?

1. Without Using a npm package and Creating your own CSV parser

// Importing fs module to read the file 
const fs = require("fs")
const data = fs.readFileSync("sample.csv", "utf8") // using 'utf8' encoding


// splitting the CSV by row as "\n" represents new row
let rows = data.split("\n") 

// Getting the attribute from the index 0 of the rows
const getAttribute = () => {
  return rows[0].split(',')
}

// Further splitting the Rows 
const getRowData = () => {
  let rowData = []
  for (let i = 1; i < rows.length; i++) {
    const row = rows[i].split(',')
    rowData.push(row)
  }
  return rowData;
}


//  The CSV parser 
const CSVToObject = () => {

  const attributes = getAttribute(data)
  const rowData = getRowData()

  let rowsObj = []
  for (let i = 0; i < rowData.length; i++) {

    let rowObj = {}

    for (let j = 0; j < rowData[i].length; j++) {
      rowObj[attributes[j]] = rowData[i][j]; // converting to object as attribute as key.
    }

    rowsObj.push(rowObj)
  }

  return rowsObj
}

let newData = CSVToObject()

console.log(newData) // Output of the data

In the above code, we are just taking a CSV file reading it, and then splitting it into rows by using the logic that each row is distinguished by "\n". Once that is done we are storing the first row or the 0th index of the array as attributed used in the CSV. Once that is done we are then splitting the rows further by , by using the fact each column in a row is split by ,.

here are the results,

2. Using 3rd Party Library Like Fast CSV.

Well, if you are not into much programming or you don't have much time to write the logic on your own you can use the npm library like Fast-CSV. It has all the features out of the box and can be easily used with Nodejs.

You can read more about it here.

npm install fast-csv

//or 

yarn add fast-csv

once done we will write further code which just consoles logs each row in a format of object

const csv = require("fast-csv") // Importing the Librabry 

// options which needed for the fast-csv
const options = { headers: true, trim: true } 

fs.createReadStream(path.resolve(__dirname, 'sample.csv'))
.pipe(csv.parse(options))
  .on('error', error => console.log(error))
  .on('data', row => console.log(row))
  .on('end', (rowCount) => console.log(`Parse ${rowCount} rows`))

further, you can save them as an array of objects by adding a small line of code.

Here are the result :)

Writing to a CSV file

In this, we will be simply writing a line into a CSV file, and then we will use fast-CSV to achieve the same, logic is similar.

1. Creating your method to write to file

const writeTofile = ()=>{

  let header = "id ,firstName, LastName,email \n";

  let data = "1 ,Ashish,Maurya,ashish.1999vns@gmail.com \n"
  let csv_data = header + data

  console.log(csv_data)
  fs.writeFileSync("output.csv" , csv_data , "utf-8")
}

writeTofile()

Output :

The End

I hope you learned something new and would love to use these. If you find this meaning full consider following me on Twitter.

You might as but why Peerlist and what's the need when platforms like Github, Linkedin even Hashnode is there to showcase our work? Well, let me tell the exact words of the founders and why they are building Peerlist.

Why Peerlist?

In a blog post, the co-founder mentioned what was the core problem they were facing so they come up with the idea of a single source of truth Peerlist, where all your blogs and links can be showcased. It's more like a portfolio but very to easy to update and create.

She (Yogini) had to update her resume and share her work links. EVERY BLOODY TIME. Her work was distributed on different platforms, like Github and DEV. And her LinkedIn profile was useless to showcase her work. Building a personal portfolio website was not feasible, as she was busy with coding assignments and interviews.

you can read more about this here why-are-we-building-peerlist

Now you might think but if that's the case there are other services like the famous platform LinkedIn. Well, I agree LinkedIn is such a great website to find work and connect with people but there are a lot of things are changed with LinkedIn and now it's not the same LinkedIn we used to remember.

The Expectations and Reality check from Linkedin

Expectation from LinkedIn

• Gain of Exposure and Job opportunity.
• Meeting Peers with the same goals.
• Gaining social proof of skills and work.
• Getting offered and visible to Recruiters.

Well, these might be working still same for a lot of people but you might also agree it's not the same as it used to be and had changed a lot in recent years.

The LinkedIn Reality check

• Too Much Motivation, If you are a dev like me you don't wanna see every post as some kind of random motivational story. A few numbers are kinda ok and they usually do motivate us but the sheer number of motivational posts I see these days are insanely a lot. That kinda ruined the purpose of scrolling and learning about something new or collaborating.

• Random Job Alerts Getting Radom job updates from in your feed asking you to mention your email in the comment. Well, it's probably fake no recruiter gonna go through the post comment and mail you about your work and establish contact with you. It's mostly as a way of tricking the algorithm into making their post viral and gaining followers.

• Scams Idk if you come up with these posts or not but a lot of people are scamming by getting your data and portraying themselves as recruiters and posting jobs.

The list goes on .... Well I m not saying LinkedIn is bad but Trust me as a developer you need something which is specially tweaked as per your need.

The Modern Professional Network for Developers: Peerlist

Peerlist for developers

Peerlist is not just a portfolio website but has much to offer to developers. Let's see what Peerlist has that makes it unique from other platforms.

1. Portfolio for developers

Well, It has an amazing portfolio for developers with Integration with other famous platforms such as Hashnode, Github, Dribble, etc.

Here is a funny meme I just created :). Hope it cracks a laugh for you

But, seriously guys it's this easy now to share everything about your dev work with a single work just like as a portfolio but better.

well doesn't this look good, everything a recruiter might want to see it's there to see?

2. Job's for you

Recently Peerlist's new feature is also a Job portal and Applying to them is just one click away. Well, don't believe me go and check out your self it has plenty of jobs for you and the good thing is the recruiter profile is inviting only so getting scammed is out of the box.

3. Scroll

It's a simple feed like most social networking website but there is fewer motivational speaker and more developers. So if you are a developer you might wanna go through this to learn a ton lot of stuff as people are sharing their blogs and repositories or dribble shots to get reviewed and showcased. Personally speaking, it's a great place to get inspired and motivated.

4. Analytics

Well, they also have good analytics inbuilt to give you an idea of how much you are growing on their website and how many people are noticing you.

Peerlist for Recruiters

This website has hidden gems to offer to recruiters which make their life easy and that is Proof of Work. No recruiter wanna hire someone who bluffs their resume so proof of work is the best way to hire talent from the talent pool.

Recruiters have transparent access to the work a candidate has done in their repository, their project, and blog post ever the candidate has shared in one glance which can be very beneficial for recruiters to judge a candidate in the first round itself.

If that's not something that excites you so let me again mention there is a job portal where you can post jobs and easily filter candidates.

If you are a recruiter go and check out the Peerlist.

I hope you got a sense of what Peerlist is and what they are doing if you like their Idea and want a portfolio or a job. Go check them out and make a profile on their website.

TL;DR

Peerlist is awesome if you haven't joined do join them Join Peerlist

Here is the original tweet 👇

Setting Up a CRA and creating a form

I am just gonna get ahead and create a simple form, the basic barebone and structure using JSX

import "./styles.css";

export default function App() {

  return (
    <div className="App">
      <form className="form" onSubmit={handleSubmit}>
        <div>
          <label for="firstName"> First name : </label>
          <input
            id="firstName"
            name="firstName"
            type="text"
            placeholder="John"
          />
        </div>
        <div>
          <label for="lastName"> last name : </label>
          <input name="lastName" type="text" placeholder="Doe" />
        </div>
        <div>
          <label htmlFor="email"> email : </label>
          <input
            id="email"
            name="email"
            type="email"
            placeholder="john@email.com"
          />
        </div>
        <div>
          <label for="password"> Password : </label>

          <input name="password" type="password" placeholder="********" />
        </div>
        <div>
          <label for="confirm password"> Confirm Password : </label>

          <input
            name="confirmPassword"
            type="password"
            placeholder="********"
          />
        </div>
        <button>Submit</button>
      </form>
    </div>
  );
}

Preview :

Once this is done your basic non-styled form will look something like this and all you need is to get the user data from the From.

let's create a handle submit function now, if you know react this will be very easy for you but here it goes.

const handleSubmit = (e) => {
    e.preventDefault();
    const formData = new FormData(e.target);
    const data = Object.fromEntries(formData);
    console.log(data);
  };

so what is happening here is we are getting the form element and creating a new Form Data once that is done we are converting it into Objects using the javascript method Object.fromEntries(formData)

Once that is done let's test our App so far.

Installing and Validating Zod

npm i zod

  // or

yarn add zod

once Zod is installed let's define our schema for the form inputs and then we will try to validate it. In my use case, we will be adding only for firstName, lastName, email, password and confirmPassword.

const validateSchema = z
    .object({
      firstName: z.string().min(3),
      lastName: z.string(),
      email: z.string().email(),
      password: z.string().min(6),
      confirmPassword: z.string().min(6)
    })
    .refine((data) => data.password === data.confirmPassword, {
      message: "Password doesn't match",
      path: ["confirmpassword"]
    });

this is a schema on that basis we will be validating our form like below and our new handle submit will look something like this. Now you can add different validation and show the user error message and handle logic of what to do after submitting.

const handleSubmit = (e) => {
    e.preventDefault();
    const formData = new FormData(e.target);
    const data = Object.fromEntries(formData);
    try {
      const validatedForm = validateSchema.parse(data);
      console.log(validatedForm);
    } catch (err) {
      console.log(err);
    }
    // console.log(data);
  };

Here is our completed App

Try this out :P