In this post, we’ll dive deep into the importance of indexes, how to create better indexes, and the long-term impact on performance, using a social media application that manages posts as an example.

What Are Indexes?

An index is a data structure that improves the speed of data retrieval operations on a database table at the cost of additional storage and maintenance overhead. Think of it like an index in a book—it helps you find the information you need without flipping through every page.

While indexes can speed up read operations (queries), they can slow down write operations (inserts, updates, and deletes) because the index must be updated whenever the data in the table changes.

How Indexes Impact Long-Term Performance

As your data grows, simple queries that once ran quickly can become painfully slow. This is where indexing comes into play—by organizing your data in a way that allows the database to find it quickly, you avoid full table scans, which can take exponentially longer as the dataset grows.

In the long run, well-designed indexes ensure:

• Faster query execution: Even with millions or billions of rows, the database can fetch the required data efficiently.

• Reduced server load: Indexes reduce CPU and I/O operations, meaning the database can serve more queries with the same hardware.

• Scalability: As your application grows, properly indexed databases can handle more users and larger datasets without performance degradation.

However, over-indexing or creating unnecessary indexes can result in:

• Increased storage: Indexes consume disk space, so it’s important to only index the necessary columns.

• Slower writes: Every time data is written to the table, all relevant indexes must be updated, which can lead to slower inserts and updates.

Now, let's go through an example of designing efficient indexes using a social media posts database.

Example: Indexing a Social Media Posts Table

Note: Using postgres compatible SQL here.

Imagine you’re building a social media platform where users can post content, and the system tracks likes, comments, and shares for each post. You have a table for posts that looks like this:

CREATE TABLE posts (
    id SERIAL PRIMARY KEY,
    user_id IN,
    content TEXT,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    like_count INT DEFAULT 0,
    comment_count INT DEFAULT 0,
    share_count INT DEFAULT 0
);

Users typically perform the following operations:

1. Retrieve posts made in the last 24 hours, ordered by the number of likes.

2. Find all posts by a specific user, ordered by the most recent.

3. Fetch the most popular posts based on likes, comments, or shares, regardless of when they were posted.

Let's walk through how you can index this table for these operations.

1. Retrieving Recent Posts, Ordered by Likes

SELECT * FROM posts 
WHERE created_at > NOW() - INTERVAL '1 day' 
ORDER BY like_count DESC;

Without an index, this query will require a full table scan, which means the database has to check every row in the posts table to find the relevant records. As your table grows, this becomes inefficient.

Solution: Create a composite index on created_at and like_count.

CREATE INDEX idx_posts_created_at_like_count 
ON posts (created_at, like_count DESC);

• Why this index works: The index allows the database to first filter the rows by created_at (to get posts from the last 24 hours) and then order them by like_count in descending order.

• Impact: This index speeds up retrieval of posts based on recent activity, which is a common query pattern in social media applications.

2. Finding Posts by a Specific User

SELECT * FROM posts 
WHERE user_id = 123 
ORDER BY created_at DESC;

If you don’t index user_id, the database will need to scan the entire table to find the posts for user 123. Again, this becomes slower as the table grows.

Solution: Create an index on user_id and created_at.

CREATE INDEX idx_posts_user_id_created_at 
ON posts (user_id, created_at DESC);

• Why this index works: The index will help the database quickly find all posts by the specified user and then sort them by created_at in descending order.

• Impact: Querying for posts by specific users becomes fast, which is a common use case in most social media apps.

3. Fetching Popular Posts Based on Likes, Comments, or Shares

SELECT * FROM posts 
ORDER BY like_count DESC, comment_count DESC, share_count DESC;

Without an index, this query could potentially scan and sort all rows in the table, which becomes very slow for large datasets.

Solution: Create a composite index on like_count, comment_count, and share_count.

CREATE INDEX idx_posts_popularity 
ON posts (like_count DESC, comment_count DESC, share_count DESC);

• Why this index works: The index allows the database to directly retrieve posts ordered by their popularity metrics (likes, comments, and shares) without scanning the whole table.

• Impact: This index improves the performance of retrieving posts based on engagement, which is crucial for highlighting popular content.

Best Practices for Creating Indexes

1. Index Columns You Query Frequently: Only index columns that are frequently used in WHERE, ORDER BY, or JOIN clauses. Indexing unnecessary columns wastes storage and increases write overhead.

2. Use Composite Indexes for Multiple Columns: If your queries filter by multiple columns or need data ordered by multiple columns, consider composite indexes. However, the order of columns in the index matters—always put the most selective column first.

3. Monitor and Remove Unused Indexes: Unused indexes take up space and slow down INSERT and UPDATE operations. Regularly monitor index usage and remove any that are no longer needed.

4. Understand Indexing Overhead: Indexes make read operations faster but slow down write operations. Always consider this trade-off when adding an index.

5. Leverage Partial Indexes for Large Tables: For very large tables, consider using partial indexes that only index a subset of rows. For example, you could index only the most recent posts:

    CREATE INDEX idx_recent_posts
    ON posts (like_count DESC)
    WHERE created_at > NOW() - INTERVAL '1 month';
   

   This index only applies to posts from the last month, making it much smaller and more efficient for certain queries.

Long-Term Impact of Good Indexing

Efficient indexing ensures your application can handle:

• Scalability: As your user base grows and data accumulates, well-indexed tables maintain high performance.

• Faster Read Operations: Queries that previously took minutes (or more) on large datasets can be reduced to milliseconds with the right indexes.

• Better User Experience: Users expect real-time or near-instantaneous results, and efficient indexing is key to delivering a responsive experience.

On the flip side, poorly indexed databases can lead to:

• Slow Queries: Without the right indexes, queries that scan large tables become bottlenecks.

• Increased Server Costs: Slow queries put unnecessary load on the database server, leading to higher cloud costs or the need for expensive hardware upgrades.

Conclusion

Indexes are a powerful tool to ensure the long-term scalability and performance of your application. However, creating efficient indexes requires careful consideration of your query patterns and the trade-offs between read and write performance.

By following best practices and regularly reviewing your indexing strategy, you can build an application that scales gracefully and delivers a great experience to users, even as the underlying data grows.

The Magic Behind Real-Time Messaging

Imagine you’re in a heated conversation with a friend on a chat app. Suddenly, you see "Sarah is typing..." appear above the text input box. It's a small but powerful feature that enhances the chat experience by providing real-time feedback. But how is this magic achieved?

In this blog, we’ll build a simplified version of this feature using Node.js for our backend and React for our frontend. We’ll leverage Socket.IO, a popular library that enables real-time, bidirectional, and event-based communication between the client and the server.

When building real-time applications like chat platforms or collaborative tools, efficiency and relevance in communication are key. You don’t want every user receiving every notification. For instance, in a messaging app, you wouldn’t want a user from one chat room receiving typing notifications from another chat. This is where Socket.IO rooms come into play.

Setting the Scene

Before we dive into the code, let’s set up our environment:

1. Node.js - A powerful JavaScript runtime for server-side programming.

2. React - A popular JavaScript library for building user interfaces.

3. Socket.IO - A library that enables real-time communication.

Our goal is to create a basic chat interface where users can type messages, and the application will display a "User is typing..." indicator whenever a user is actively typing.

What Are Socket.IO Rooms?

In simple terms, rooms in Socket.IO allow you to create isolated groups of clients that can communicate with each other without broadcasting to every connected user. When a client joins a room, they are essentially telling the server, “I’m interested in events related to this room.” This way, the server can emit events to a particular group of users without affecting others.

Step 1: Setting Up the Backend (Node.js + Socket.IO)

1.1 Install Dependencies

First, create a new Node.js project and install the necessary dependencies.

Follow my previous article to setup a typescript + nodejs server or follow the steps below for a JS one.

mkdir typing-feature
cd typing-feature
npm init -y

Install the socket.io package

npm install express socket.io

1.2 Create the Server

Create a file called server.js and set up a basic Express server with Socket.IO:

const express = require('express');
const { createServer } = require('http');
const { Server } = require('socket.io');

const app = express();
const PORT = process.env.PORT || 3001;

const server = createServer(app);
const io = new Server(server, {
  cors: {
    origin: '*',
    methods: ['GET', 'POST'],
  },
});

// Handle socket events
io.on('connection', (socket) => {
  console.log('A user connected', socket.id);

  // Join a room for typing events
  socket.on('join-room', (roomId) => {
    socket.join(roomId);
  });

  // Handle typing events
  socket.on('typing', (data) => {
    console.log(`${data.roomId} - user with id ${data.user.id} and ${data.user.username} is typing`);
    socket.to(data.roomId).emit('typing', data.user);
  });

  socket.on('stopped-typing', (data) => {
    console.log(`${data.roomId} - user with id ${data.user.id} and ${data.user.username} stopped typing`);
    socket.to(data.roomId).emit('stopped-typing', data.user);
  });

  // Handle disconnection
  socket.on('disconnect', () => {
    console.log('User disconnected:', socket.id);
  });
});

server.listen(PORT, () => {
  console.log(`Server is running on port ${PORT}`);
});

Explanation:

• socket.join(roomId): The user joins a room specified in the data, this can be a group or a personal chat in our chat application.

• socket.on('typing'): Listens for a typing event and broadcasts it to everyone in the specified room.

• socket.on('stopped-typing'): Listens for when the user stops typing and emits the event to the room specified.

Now run the server:

node server.js

Step 2: Setting Up the Frontend (React + Socket.IO)

2.1 Install Dependencies

In a new React project (or an existing one), install socket.io-client to communicate with the backend:

npm install socket.io-client

2.2 Create a Socket Context

Create a SocketContext.tsx file in src/context to manage the Socket.IO connection globally using React Context:

import React, { createContext, useContext, useEffect, useState, ReactNode } from "react";
import io, { Socket } from "socket.io-client";

const SocketContext = createContext(undefined);

export const useSocket = () => {
  const context = useContext(SocketContext);
  if (!context) {
    throw new Error("useSocket must be used within a SocketProvider");
  }
  return context;
};


export const SocketProvider = ({ children })=> {
  const [socket, setSocket] = useState(null);

  useEffect(() => {
    const newSocket = io("http://localhost:3001"); // Connect to the server
    setSocket(newSocket);

    return () => {
      newSocket.close(); // Cleanup when component unmounts
    };
  }, []);

  return (
    <SocketContext.Provider value={{ socket }}>
      {children}
    </SocketContext.Provider>
  );
};

This creates a SocketProvider that connects to the backend server and provides the socket instance throughout the app.

2.3 Integrate Context in the App

In your App.tsx file, wrap the entire application in the SocketProvider so that all components can access the socket connection:

import React from "react";
import { SocketProvider } from "./context/SocketContext";
import Chat from "./components/Chat";

function App() {
  return (
    <SocketProvider>
      <Chat />
    </SocketProvider>
  );
}

export default App;

2.4 Building the Chat Component

Create a Chat.tsx component that handles sending typing events and displays when a user is typing:

import React, { useState, useEffect } from "react";
import { useSocket } from "../context/SocketContext";

const Chat = () => {
  const { socket } = useSocket();
  const [message, setMessage] = useState("");
  const [isTyping, setIsTyping] = useState(false);
  const [typingUser, setTypingUser] = useState("");

  const userId = 10; // Current user ID
  const username = "starlight"; // Current user ID
  const roomId = "The Lounge"; // Room name

  // Emit typing event when user types
  const handleInputChange = (e) => {
    setMessage(e.target.value);
    socket?.emit("typing", { roomId: roomId, user: { id: userId, username: username } , typing: true });
  };

  // Emit stop typing event after 2 seconds of inactivity
  useEffect(() => {
    let typingTimer;
    if (message) {
      typingTimer = setTimeout(() => {
        socket?.emit("stopped-typing", { roomId: roomId, user: { id: userId, username: username }, typing: false });
      }, 2000);
    }
    return () => clearTimeout(typingTimer);
  }, [message, socket, roomId, userId, username]);

  // Listen for typing events
  useEffect(() => {
    if (!socket) {
      console.log("socket not availble");
      return;
    }
    socket?.emit("join-room", roomId);

    socket?.on("typing", (data) => {
      setTypingUser(data.username);
      setIsTyping(true);
    });

    socket?.on("stopped-typing", () => {
      setTypingUser("");
      setIsTyping(false);
    });

    return () => {
      socket?.off("typing");
      socket?.off("stopped-typing");
    };
  }, [socket]);

  return (
    <div>
      <div>
        <input
          type="text"
          placeholder="Type your message..."
          value={message}
          onChange={handleInputChange}
        />
      </div>
      {isTyping && <p>{typingUser} is typing...</p>}
    </div>
  );
};

export default Chat;

Explanation:

• When the user types in the input field, we emit a typing event.

• After 2 seconds of inactivity, a stopped-typing event is emitted.

• We display username is typing... when receiving typing events from other users.

Step 3: Testing the Feature

1. Run the backend server using node server.js.

2. Start the React frontend by running npm start in your React project.

3. Open the chat application in multiple browser tabs to see real-time typing notifications when a user is typing.

Step 4: Connecting to sockets with dynamic data (optional)

To make the React Chat component more interactive and flexible, we can modify it to accept user inputs for joining a specific room and entering a username before starting to type. This way, users will be able to choose a room and provide their display name, adding a personalized touch to the chat experience.

Here’s how we can modify the original Chat component:

Steps to Modify the Chat Component:

1. Set Up Inputs for Username and Room:

We'll add input fields for the username and room ID. These inputs will be used to customize the room the user joins and the name they use in the chat.

2. Use State for User Inputs:

We’ll manage the username and room ID using useState so that the user can set them before joining the chat room.

3. Trigger Room Join on Submit:

Once the user inputs their name and room, the chat will connect them to the selected room, allowing real-time typing notifications between users in the same room.

// src/components/Chat.tsx

import React, { useState, useEffect } from "react";
import { useSocket } from "./context/SocketContext";

const Chat = () => {
  const { socket } = useSocket(); // Get the socket from context
  const [message, setMessage] = useState<string>("");
  const [isTyping, setIsTyping] = useState<boolean>(false);
  const [typingUser, setTypingUser] = useState<string>("");

  const [roomId, setRoomId] = useState<string>(""); // Input for room
  const [username, setUsername] = useState<string>(""); // Input for username
  const [userId] = useState<number>(Math.floor(Math.random() * 10000)); // Generate random user ID
  const [hasJoined, setHasJoined] = useState<boolean>(false); // Track if user has joined the room

  // Emit typing event when user types
  const handleInputChange = (e: React.ChangeEvent<HTMLInputElement>) => {
    setMessage(e.target.value);
    if (socket && hasJoined) {
      socket.emit("typing", {
        roomId,
        user: {
          id: userId,
          username,
          typing: true,
        },
      });
    }
  };

  // Emit stop typing after a delay
  useEffect(() => {
    let typingTimer: ReturnType<typeof setTimeout>;
    if (message) {
      typingTimer = setTimeout(() => {
        if (socket && hasJoined) {
          socket.emit("stopped-typing", {
            roomId,
            user: {
              id: userId,
              username,
              typing: false,
            },
          });
        }
      }, 2000); // Stop typing after 2 seconds
    }
    return () => clearTimeout(typingTimer);
  }, [message, socket, roomId, username, userId, hasJoined]);

  useEffect(() => {
    if (!socket) {
      console.log("Socket not available");
      return;
    }

    if (hasJoined) {
      console.log("Socket available, joining room:", roomId);
      socket.emit("join-room", roomId);

      // Listen for typing events
      socket.on("typing", (data) => {
        console.log("caught event typing:", data);
        setTypingUser(data.username);
        setIsTyping(true);
      });

      // Listen for stop typing events
      socket.on("stopped-typing", (data) => {
        console.log("caught event stopped-typing:", data);
        setTypingUser("");
        setIsTyping(false);
      });

      // Cleanup listeners when component unmounts
      return () => {
        console.log("closing sockets");
        socket.off("typing");
        socket.off("stopped-typing");
      };
    }
  }, [socket, hasJoined, roomId]);

  const handleJoin = () => {
    if (username && roomId) {
      setHasJoined(true);
    } else {
      alert("Please enter a valid username and room.");
    }
  };

  return (
    <div>
      {!hasJoined ? (
        <div>
          <input
            type="text"
            placeholder="Enter username"
            value={username}
            onChange={(e) => setUsername(e.target.value)}
          />
          <br />
          <br />

          <input
            type="text"
            placeholder="Enter room to join"
            value={roomId}
            onChange={(e) => setRoomId(e.target.value)}
          />

          <br />
          <br />

          <button onClick={handleJoin}>Join Chat</button>
        </div>
      ) : (
        <div>
          <p>
            Joined room <strong>{roomId}</strong> as <strong>{username}</strong>
          </p>
          <input
            type="text"
            placeholder="Type your message..."
            value={message}
            onChange={handleInputChange}
            disabled={!hasJoined}
          />
          {isTyping && <p>{typingUser} is typing...</p>}
        </div>
      )}
    </div>
  );
};

export default Chat;

Testing

1. Enter username and room to join and click on join chat.

   

2. Do the same from another browser tab

3. Check result after you start typing in one tab.

   

Final Thoughts

With this setup, you've implemented a real-time "user is typing" feature using Node.js, Socket.IO, and React. This feature creates an interactive chat experience and can be further expanded with more room functionality or personalized notifications for better user interaction.

Happy coding! 🎉

But what is Node.js exactly? How does it power so many applications, from chat services to full-blown server-side apps? Let’s dive into the intriguing mechanics that make Node.js such a revolutionary runtime.

JavaScript Beyond the Browser

Historically, JavaScript was confined to browsers, giving life to dynamic web pages. But developers wanted more—JavaScript everywhere! Enter Node.js, a runtime that enables JavaScript to run on servers, beyond just browsers. It is cross-platform (built for various operating systems), and open-source. Suddenly, you could use the same language for both the front and back ends of your application. But what makes Node.js different from other server-side technologies like Python, PHP, or Ruby?

Event-Driven Architecture: The Heartbeat of Node.js

The magic behind this asynchronous nature lies in its event-driven architecture. Think of it like a restaurant kitchen: chefs (the event loop) prepare dishes (tasks) when ingredients (data) arrive. If a dish takes time to cook, they don’t just wait—they start another dish. Once the slow-cooking dish is done, they pick up right where they left off.

In Node.js, this is managed by the Event Loop, which handles incoming requests, assigns tasks to the appropriate workers (like reading from a file system or fetching data from a database), and then waits for their completion while continuing to handle other incoming requests.

Understanding the Core: V8 Engine and the Power of Asynchronous I/O

Node.js has three critical components that work together to execute JavaScript code efficiently on the server:

1. V8 Engine

At its core, Node.js uses Google’s V8 engine, the same engine that powers Chrome, to execute JavaScript. But Node.js does more than just provide a space for running JavaScript—it brings a game-changing feature: asynchronous, non-blocking I/O.

In simpler terms, Node.js doesn’t wait. While other programming languages often pause (or "block") when performing actions like accessing a database or reading files, Node.js keeps moving, handling multiple tasks simultaneously. This feature allows it to handle thousands of concurrent connections with minimal overhead, making it perfect for high-traffic apps like streaming platforms or real-time chat services.

Developed by Google for Chrome, V8 compiles JavaScript to machine code, ensuring it runs at lightning speed. It consists of two main parts:

• Memory Heap: A large, unstructured region of memory where objects, variables, and functions are stored. This heap helps manage dynamic memory allocation during runtime.

• Call Stack: A structured data stack that keeps track of the execution order of functions. Whenever a function is invoked, it gets added to the top of the stack. Once the function is executed, it gets removed, maintaining a clear order of execution.

Since JavaScript is single-threaded, there is only one call stack, meaning the code executes sequentially, one function at a time. So, how does Node.js handle concurrent requests efficiently without getting blocked by slow operations like file reading or database access?

2. Libuv

Libuv is a C-based library that provides Node.js with its asynchronous, non-blocking I/O capabilities. Bindings are created to connect JavaScript functions to their actual implementations in Libuv, allowing JavaScript to interface with lower-level system operations. While JavaScript is single-threaded, Node.js can handle multiple operations simultaneously due to Libuv.

While JavaScript itself is single-threaded, Libuv delegates long-running tasks (like file system access or networking) to a pool of background threads. These threads work independently, allowing the Node.js main thread (the event loop) to continue processing other requests without waiting for blocking operations to complete. Once the task in the thread pool finishes, the result is passed back to the event loop for further processing.

3. Event Loop

The Event Loop is Node.js’s core mechanism that enables asynchronous programming, and it starts running as soon as Node.js begins executing a program. For asynchronous functions, once they start processing, they usually have instructions that need to be executed after they finish. These instructions are placed in a callback queue, which operates in a First In, First Out (FIFO) manner.

The Event Loop continuously monitors the call stack to determine what function to execute next. When the call stack is empty, the event loop picks up tasks from the callback queue, such as I/O operations or timers, and pushes them onto the stack for execution.

This combination of single-threaded execution with non-blocking, asynchronous operations allows Node.js to efficiently handle concurrent requests with high scalability, ensuring that tasks are processed without blocking the main thread.

If you have arrived here in search of TypeScript setup for your nodejs project, this comprehensive guide should help you get started on your journey to building robust and maintainable Node.js applications with TypeScript.

Step 0: Installing NodeJS

Download or upgrade to the latest version of Node.

Step 1: Initialize Your Project

To get started, create a new Node.js project by running the following command:

yarn init -y

This command generates a package.json file with default settings.

{
  "name": "nodejs-api",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
      "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
}

We will make some adjustments to it later.

Step 2: Use CommonJS Modules

CommonJS and ES modules are two different ways of importing and exporting modules in JavaScript. CommonJS, historically used in Node.js, relies on the require function for importing modules and module.exports for exporting them. In contrast, ES modules, introduced in ES6, use import and export statements. This distinction impacts how code is structured and dependencies are handled in their respective environments. CommonJS has been the standard in Node.js for a long time, while ES modules (ECMAScript modules) offer native support for modules in JavaScript.

Since we are using TypeScript, which compiles to CommonJS by default, we do not need to enable "type: module" in our package.json file. This allows us to continue using CommonJS syntax without changing the module system. The package.json file looks like this until now:

{
  "name": "nodejs-api",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
       "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
}

Step 3: Install TypeScript

Install TypeScript as a development dependency using the following command:

yarn add -D typescript

Step 4: Configure TypeScript

Create a tsconfig.json file to configure TypeScript. This file specifies how TypeScript should transpile your code. Here's a breakdown of the key options in the tsconfig.json file:

• "type": "module": Specifies the module system used by Node.js.

• "esModuleInterop": true: Enables compatibility between CommonJS and ES Modules.

• "target": "es2021": Sets the ECMAScript version to target.

• "moduleResolution": "node": Configures how TypeScript resolves module imports.

• "sourceMap": true: Generates source maps for better debugging.

• "outDir": "dist": Specifies the output directory for transpiled code.

• "strict": true: Enforces strict type checking.

• "include" and "exclude": Define which files to include and exclude from TypeScript compilation.

• "lib": ["es2021"]: Specifies the libraries available in your TypeScript project.

Here's the tsconfig.json:

{
  "compilerOptions": {
    "module": "commonjs",
    "esModuleInterop": true,
    "target": "es2021",
    "moduleResolution": "node",
    "sourceMap": true,
    "outDir": "./dist",
    "strict": true,
    //"skipLibCheck": true,              
    //"noImplicitAny": true,  
    //"strictNullChecks": true,
    //"strictFunctionTypes": true,
    //"noImplicitReturns": true 
  },
  "include": ["src/**/*.ts", "index.ts"],
  "exclude": ["node_modules"],
  "lib": ["es2021"]
}

You can optionally create tsconfig.json using the command npx tsc --init which will create it with various options available and you can choose which to keep, like below:

Step 5: Install Express

You can use the popular Express.js framework to build your Node.js server. Install it using the following command:

yarn add express

Step 6: Create Your TypeScript Entry File

Create src directory and add an index.ts file it to serve as the entry point for your application:

import express from "express";

const app = express();
const port = 3000;

app.get("/", (req, res) => {
  res.send("Hello, TypeScript Node.js Server!");
});

app.listen(port, () => {
  console.log(`Server is running on port ${port}`);
});

Step 7: Install @types/express and @types/node

Since TypeScript needs type definitions for external packages, importing express will give an error so install @types/express:

yarn add -D @types/express @types/node

This package provides TypeScript type declarations for Express.js.

Step 8: Setting Up Development Scripts

For a smoother development experience, install nodemon as a global package.

Nodemon is a utility for Node.js that automatically restarts the server when changes are detected in the code. It's commonly used during development to streamline the development process by eliminating the need to manually restart the server after every code change. This tool significantly enhances the development workflow, allowing developers to focus on writing code without the interruption of restarting the server repeatedly. You will also need to install ts-node which is a Typescript execution engine.

yarn add nodemon ts-node -g

Then, update your package.json file to include scripts for starting your server in development mode:

"scripts": {
  "dev": "nodemon src/index.ts"
}

Now, you can run your server with yarn dev and it will automatically restart when you make changes to your TypeScript code.

Let's also add scripts to build and start our application, yarn build will compile all your typescript files into javascript and store in the 'dist' directory as specified in the tsconfig.json.

"scripts": {
  "build": "tsc",
  "start": "node dist/index.js",
}

After the build is succeeded, you can run yarn start to start your application.

Step 9: Adding ESLint for Code Quality

ESLint is a popular static code analysis tool for identifying problematic patterns found in JavaScript code. It helps ensure that your code follows best practices, conforms to coding standards, and avoids common errors.

Developers use ESLint to enforce coding styles and conventions within a project, making the codebase more consistent and readable. It can catch bugs, potential runtime errors, and even detect suspicious code that might lead to unexpected behaviors. Additionally, ESLint can be customized with various plugins and configurations to suit the specific needs and preferences of a project or development team.

Install ESLint and TypeScript-specific ESLint packages:

yarn add -D eslint @typescript-eslint/eslint-plugin @typescript-eslint/parser

Create an .eslintrc.json file in your project directory:

{
  "env": {
    "node": true,
    "es2021": true
  },
  "extends": [
    "eslint:recommended",
    "plugin:@typescript-eslint/recommended"
  ],
  "parser": "@typescript-eslint/parser",
  "parserOptions": {
    "ecmaVersion": 2021,
    "sourceType": "module"
  },
  "plugins": [
    "@typescript-eslint"
  ],
  "rules": {}
}

Add a lint script in the package.json,

"scripts": {
    "lint": "eslint index.ts && eslint src/**/*.ts",
}

Step 10: Adding Prettier for Code Formatting

Prettier is a code formatting tool that automatically adjusts the layout and style of your code to follow a consistent and predefined set of rules. It helps maintain a uniform code style across a project by automatically formatting the code according to the configured guidelines. Prettier is commonly used in development environments to ensure that code is easy to read, consistent, and visually appealing, which in turn enhances collaboration and maintains a clean codebase.

Install it:

yarn add -D prettier

Create a .prettierrc file in your project directory with your preferred formatting rules:

{
  "semi": true,
  "trailingComma": "all",
  "singleQuote": true,
  "printWidth": 120,
  "tabWidth": 2
}

Add a script to format your code:

"pretty": "prettier --write \"src/**/*.ts\""

Now, you can run yarn pretty to format your TypeScript files in the src directory of your project.

To build and start your application run yarn build and yarn start.

Congratulations! You've successfully set up a Node.js server with TypeScript, added linting with ESLint, code formatting with Prettier. Happy coding!

Having secured a remarkable 95.20% in my Std X boards, I found myself enrolled at Government Polytechnic Pune. At that time, I had little clarity about my career path. Through a combination of setbacks and achievements, I navigated my way forward. Reflecting on my progress, I often wonder about the series of events that led me to my present position. Starting my diploma without a clear plan, but ending up with a clear vision after completing my bachelor's degree this year, has been an incredible journey. I want to share all the lessons I've learned along the way to make your life in college easier.

My journey began with my first year of diploma studies. During this time, we delved into the fundamentals of programming, starting with the C language. As time marched on, I encountered a significant realization that left a lasting impact.👇

Embrace the courage to attempt without dwelling on the result—whether you stumble or triumph holds no significance in the realm of learning.

But how did I learn this?

Our C programming teacher was guiding us through the intricacies of coding when she posed an intriguing challenge: she wanted a student to jot down a program on the board. Understandably, the room was tinged with nervous excitement; this marked our maiden voyage into the realm of coding. However, I chose to embrace the moment, summoning my courage and raising my hand. With a determined spirit, I penned the program onto the board. Much to my astonishment, its execution unfolded flawlessly. This marked a turning point, a juncture where I resolved to always confront challenges head-on and derive wisdom from them. It's true, I encountered numerous failures along the way, but one constant remained—the unwavering journey of learning.

The second lesson that became apparent to me was when I began to realize that I could effortlessly formulate program logic, no matter how complex, all thanks to my solid grasp of technical fundamentals. Hence the second lesson 👇

Strengthen your technical foundation; every challenge appears conquerable with a solid base.

As I effortlessly grasped concepts, I started underestimating the necessity of rote memorization for exam answers. It took me a while to recognize that I was scoring lower than individuals who hadn't comprehended the concepts as deeply. Even when I elaborated extensively on the subject matter, a crucial element seemed to be lacking. It was at this point that I imbibed my third crucial lesson.

Mastering concepts and their implementation is one thing, but translating that mastery into technical writing, enabling others to grasp your explanations, presents a whole different challenge.

Understanding and mastering complex technical concepts is one facet of the journey, yet the challenge deepens when one strives to transform that mastery into written form, allowing others to seamlessly comprehend the explanations. I came to realize this disparity as I encountered difficulty in employing the precise technical language outlined in textbooks, unlike some of my peers who were doing it with repeated efforts put into memorizing the answers.

This discrepancy signalled the need for me to cultivate my writing skills, understanding that technical concepts cannot be communicated simplistically. The process of articulating these ideas in writing acts as a bridge between comprehension and effective communication. It is the path to finding clarity and depth, making sure the complexities of technical subjects are communicated accurately. This proficiency in technical writing extends beyond exam performance—it facilitates effective teaching, collaborative projects, and the seamless exchange of ideas in real-world scenarios.

Despite achieving a commendable score of 89.80%, fate dealt an unexpected hand as I found myself excluded from the initial allocation list of the degree college. This circumstance compelled me to accept whatever options were presented during the second and final round. The degree college I ended up in wasn't my initial preference. However, adhering to the philosophy that "everything happens for a reason," I chose to perceive this situation through that lens. But I will still say it was one of the best things that happened to me as,

Sometimes you have to fall to bounce back even stronger.

Having completed my diploma studies at a top-tier college in Maharashtra, the transition to a tier 3 college for my degree was undeniably challenging. Recognizing the hurdles that lay ahead, I embraced a strategic approach. In response, I made the conscious decision to become an active participant in coding clubs—incidentally, our college lacked one, but my friends and I rallied to establish it. This initiative facilitated engagement with individuals who shared my passion, fostering an environment in which I could thrive. By forming a circle of like-minded friends, I positioned myself for growth and development despite the demanding road that stretched ahead.

Select your circle of friends thoughtfully, for they wield a substantial influence over your mindset.

This journey transformed my thought processes and cognitive approaches significantly. Swiftly, I delved into a teaching internship, beginning to earn some dollars. It wasn't long before the realization dawned on me—I needed to undertake tangible real-world projects. Thus, I undertook the creation of a digital marketing website for my brother's business. This venture proved invaluable in enhancing my web development proficiency. As time progressed, fueled by three subsequent internships, I proudly adopted the title of a web developer. Moreover, amidst these endeavours, I dedicated time to learning about blockchain technology and attended web3 meetups to connect with like-minded and experienced individuals.

As I grew more adept at crafting projects across various programming languages, I learnt that once your foundational knowledge is solid, you can readily delve into the intricacies of any technology or language and make strides. Amidst my evolving interests, a key insight emerged—comprehending the significance of core fundamentals. Things like networking, databases, how programming works, operating systems, and hardware form the solid foundation for becoming skilled in different areas.

Over these 6 years, my journey led me through various domains - from DSA to Databases, then onto JavaScript and Android app development. Eventually, I found my niche in full-stack web development with a focus on blockchain technology.

That is when I learnt,

Interests shift as new technologies emerge over time. The key to adapting smoothly is having a strong foundation in the basics of computer fundamentals.

Embark on exploration and uncover what aligns with your passions. Avoid hastily narrowing your focus. Early specialization can limit your breadth of knowledge. Instead, venture across various domains, absorbing insights, until you discover the optimal fit that resonates most with you.

In this journey, hackathons stand as invaluable waypoints. They provide not only the chance to dabble in diverse fields but also to hone essential skills like quick adaptation, innovative thinking, and collaborating effectively under pressure. These experiences enrich your explorations, infusing your path with a potent blend of versatility and expertise, ultimately guiding you towards a destination where your passions and capabilities converge.

Hackathons are where rapid thinking fuses with agile coding.

Participating in hackathons provides a unique opportunity to boost your self-confidence in rapidly creating practical and impactful products within condensed timeframes and fast-paced environments. These intense events challenge you to harness your creativity, technical skills, and collaborative prowess to deliver solutions that address real-world problems. This immersive experience not only refines your technical abilities but also fosters adaptability, teamwork, and effective problem-solving. As a result, hackathons serve as a crucible where your development skills and personal growth converge, enriching your overall journey in tech.

Final Thoughts

As I step forward into the ever-evolving landscape of technology, these lessons remain my North Star, guiding me through the challenges and opportunities that lie ahead. They remind me that the true essence of learning is not confined to textbooks and lectures; it's the fusion of experience, insight, and a relentless hunger to innovate.

Delta Graphs and Hubs

At the core of Farcaster's functionality lies the concept of "Delta Graphs." These graphs are dynamic structures that capture and represent the interactions between users in a flexible and efficient manner. These graphs find their home within hubs, which play a vital role as repositories for all user-generated content and information. As the size of a hub increases, so does the cost to run it efficiently, prompting the platform to introduce storage limits for users. Farcaster employs delta pruning to manage the vast amount of data generated over time. Older messages are archived to keep the platform efficient and clutter-free. However, Farcaster ensures that no user's storage is ever depleted by setting these limits judiciously. For those seeking additional storage beyond the allocated limits, Farcaster offers the option to pay for extra storage, accommodating users with diverse needs and preferences.

Farcaster's underlying architecture relies on hubs, which are collections of deltas. To ensure the smooth functioning of the platform, incentives are offered to companies building their apps and simpler API services. This encourages more hubs to operate, leading to a robust network.

Delta Types

1. Casts: Public Broadcasting of Text

Casts are the backbone of Farcaster, allowing users to share text publicly visible to all. Whether it's expressing thoughts, sharing updates, or making announcements, users can communicate with a broad audience through these public broadcasts.

1. Reactions: Likes and Recasts

Farcaster enables users to react to posts through likes and recasts (like shares or retweets). Liking a post indicates appreciation or agreement, while recasting allows users to amplify a message by sharing it with their followers.

1. Amps: Endorsements of One User

Amps provide a way for users to endorse another user on Farcaster. It serves as a virtual pat on the back, acknowledging someone's contributions or accomplishments.

1. Verifications: Proofs of Ownership and Link Wallets

In a world where identity verification is crucial, Farcaster allows users to provide proof of ownership and link their wallets securely. This feature enhances authenticity and trust among users.

1. User Data: Metadata (Bio, Profile, etc.)

Farcaster enables users to customize their profiles by adding metadata like a bio, profile picture, and other relevant information, allowing them to express their individuality and interests.

1. Signers: Signing Key-Pair Created Initially

For added security, Farcaster uses signing key pairs that are generated during the initial setup. These signers play a vital role in ensuring the authenticity and integrity of messages on the platform.

Hub Sync

In the vast expanse of the digital landscape, we need a way for messages to propagate quickly and in a reliable way through the network, and Farcaster operates through interconnected hubs. These hubs play a crucial role in facilitating seamless communication between users, ensuring information reaches its intended recipients promptly.

Each hub knows the address of each other hub on the network. Gossip channels are set up between these hubs through which the communication is carried out. Whenever a new Hub is added, it must know the address of at least one hub to download the entire state of the network. Gossip protocol doesn’t guarantee the ordering of messages and some messages might be discarded by other hubs while downloading the data, so these hubs perform an out-of-band sync process to periodically request full state of the hub and update themselves likewise.

To resolve conflicts arising from different social graphs, hubs employ a "merge" function, which determines the true social graph. Rules within each hub dictate how conflicts are resolved, considering timestamps and hashes to make informed decisions.

Secure Messaging: Enabling Private Communication through Advanced Encryption

Farcaster takes a proactive approach to safeguard sensitive information through a robust encryption process. This encryption methodology involves a combination of public-private key pairs, Key Defining Functions (KDFs), and advanced cryptographic techniques.

At the core of Farcaster's security model is the utilization of public-private key pairs. Both the sender and the receiver possess their unique set of keys – a public key and a private key. These keys serve a dual purpose: the public key is openly shared and used for encryption, while the private key remains confidential and is only accessible to the key owner. This asymmetric encryption ensures that only the intended recipient, who possesses the corresponding private key, can decrypt the messages encrypted with their public key.

To establish a shared secret between the sender and receiver, Farcaster employs a Key Defining Function (KDF). This function takes both the sender's private key and the recipient's public key as input and generates a secure shared secret key. The shared secret acts as the foundation for subsequent cryptographic processes, ensuring that any unauthorized party cannot access the key even if they intercept the communication.

From this shared secret, Farcaster generates two additional keys: KDF-key2 and a messaging key (MKey). The KDF2 key is derived using a secondary Key Defining Function, enhancing the complexity and strength of the encryption scheme. This multi-layered approach further fortifies the security of the communication channel.

However, the real strength of Farcaster's secure messaging lies in the messaging key (MKey). This key is crafted from the shared secret and is specifically designed to encrypt and decrypt the messages exchanged between the sender and receiver. As a result, every message is uniquely encrypted with the MKey, ensuring that even if an attacker were to gain access to one message, they would not be able to decrypt other messages without the MKey.

When a user sends a message through Farcaster, the platform employs the MKey to encrypt the content of the message before transmission. The recipient, in possession of their private key and the corresponding shared secret, can then decrypt the message using the MKey. This process ensures end-to-end encryption, where the message remains confidential throughout its journey and can only be read by the intended recipient.

Conclusion

Farcaster is a pioneering social media platform that goes beyond the conventional like-comment-share paradigm. By providing users with an array of delta types, secure messaging, and efficient data management, Farcaster empowers individuals to connect, collaborate, and share their thoughts and ideas in a secure and privacy-conscious environment. As social media continues to shape the way we communicate, Farcaster sets a new standard for inclusive, secure, and user-centric networking experiences.

The decentralized approach to social media promises to foster an unprecedented level of transparency, privacy, and autonomy for users, heralding a new era of digital interaction. While decentralized social media holds great promise, it also comes with its fair share of challenges.

1. Identity Verification Across Platforms

2. Authentication of Messages

3. Content Availability Across Platforms

4. Consistency in Rules and Moderation

Creation of trustworthy identities

Remembering a long and complex wallet address can indeed be quite challenging for users in the realm of decentralized finance and blockchain-based platforms. As we seek more user-friendly solutions, the idea of adopting a naming system akin to domain names and IP addresses holds considerable promise. However, we must tread carefully, as this approach presents a unique challenge - the possibility of identity squatting and impersonation.

Users could have a personalized and easy-to-remember username, like @yourname, associated with their wallet address. This would undoubtedly enhance the overall user experience, promoting broader adoption of decentralized applications and platforms. Yet, the catch lies in ensuring the security and authenticity of these usernames. In a decentralized system, there's no central authority governing username allocation, making it susceptible to identity theft and malicious actors. Imagine a scenario where someone manages to secure a coveted username like @twitter. They could potentially exploit this privileged position, masquerading as Twitter's official account and misleading users for malicious purposes. This could lead to scams, misinformation, and significant reputational damage to legitimate entities.

How does Farcaster come into the picture?

By leveraging blockchain technology, Farcaster introduces a secure and privacy-centric approach, empowering users with full control over their digital identities. Below are some of the key benefits Farcaster brings to the world of decentralized social identities:

1. Self-Sovereign Identities owned and controlled by users.

2. Unique Farcaster ID (FID) upon registration for ensuring seamless interactions across various decentralized applications without the need for repetitive account creation.

3. Human-Readable Farcaster Name (Fname) associated with FID simplifies the process of identification and enhances user experience.

4. Enhanced Security with Signers eliminating the need for users to expose their custody address's private key.

5. Account Recovery by setting up a designated recovery address to regain control of the accounts in case of compromise or loss of access.

6. Farcaster promotes interoperability among decentralized applications, enabling users to seamlessly navigate various platforms with a single set of credentials and data availability amongst various platforms.

Farcaster Identities

Farcaster maintains a dual identification system comprising a primary identifier known as the Farcaster ID (FID) and a secondary identifier known as the Farcaster Name (FName).

1. Farcaster ID (FID): The Farcaster ID issued by the ID Registry serves as the primary and fundamental identifier for users within the decentralized ecosystem. It is a cryptographically secure and globally unique identifier assigned to each user upon registration. The FID plays a critical role in facilitating secure transactions, interactions, and record-keeping on the Farcaster network. By using cryptographic techniques, the FID ensures that users can be identified and verified without relying on a central authority, maintaining the core principles of decentralization.

2. Farcaster Name (FName): Recognizing the challenge of remembering long and complex FIDs, Farcaster introduces Farcaster Name (FName) as a user-friendly, human-readable alternative. This FName issued by the Name Registry allows users to create personalized and memorable names associated with their FIDs. For example, a user with FID "0x1a2b3c4d5e6f" could choose the FName "@username" for easier identification by other users on the platform. To ensure the integrity and security of the FName system, Farcaster employs a partially centralized service responsible for the allocation and management of FNames. This authority follows stringent protocols to prevent misuse, cyber-squatting, or impersonation. The allocation process is designed to be transparent, fair, and safeguarded against abuse, while also protecting the privacy of users' underlying FIDs.

Farcaster Authentication

Authentication in web3 decentralized applications (dApps) operates on a fairly simple and secure premise. When using web3 dApps, the apps request users to sign messages using their private keys through their wallets. This process is fundamental to proving ownership and control over a specific blockchain address.

However, introducing third-party social media apps into the equation adds a layer of complexity and potential risk that users must be cautious about. These apps may request users to load their private keys into the application to facilitate the signing process. Doing so poses significant dangers, as sharing private keys with third-party services compromises the security of the user's funds and identity.

The Farcaster protocol introduces a novel approach to message signing by creating a separate signer public-private key pair. Now whenever the sender wants to send a message the social media app signs it using the signer already created. This innovative method enhances security and privacy by eliminating the need to use the sender's private key for signing messages. Consequently, the public address associated with the sender is now referred to as the "custody address."

When a user logs into any messaging app built on the Farcaster platform, two essential tasks are initiated to establish their identity and enable secure communication. Firstly, the app generates a unique Farcaster ID (FID) and Farcaster Name (Fname) for the user, utilizing the ID Registry and Name Registry on the Identity Layer. If the user does not already have an FID and Fname, this transaction creates them, ensuring a distinct and verifiable identity within the Farcaster network.

Subsequently, the app generates a new signer on the App Layer for the user. This signer serves as a cryptographic key pair, securely stored locally on the user's device. Its primary function is to sign messages on behalf of the user, providing a secure means of authentication without requiring the user's custody address's private key. Each application within the Farcaster ecosystem generates its own unique signer for the user, maintaining isolation and security between different applications.

Once the messages are signed by the user's signer, they are transmitted to the Farcaster hubs, which operate on the Data Layer of the Farcaster architecture. These hubs play a crucial role in syncing and maintaining a global state of the messages sent and received across the Farcaster network.

Account Recovery with Farcaster

In Farcaster, users have the option to enhance the security of their accounts through the implementation of a recovery address. This recovery address acts as a fail-safe mechanism in case the user's primary custody address is compromised or inaccessible. When a user's account is compromised, the recovery address owner can initiate a transfer of ownership request to reclaim control of the account. However, to prevent any potential malicious actions, Farcaster enforces a 7-day waiting period before the transfer of ownership is completed. This grace period ensures that the request is genuine and not an attempt by unauthorized entities to take control of the account. By introducing this recovery address feature and the waiting period, Farcaster strikes a balance between robust security measures and user-friendly account recovery, safeguarding users' digital assets in the decentralized ecosystem.

Final Thoughts

Farcaster's approach to authentication and identity generation represents a pioneering stride towards enhancing security, privacy, and user experience in the decentralized landscape. By introducing a separate signer public-private key pair, Farcaster eliminates the need for users to expose their custody address's private key during message signing, fortifying the protection of their digital assets.

The implementation of a recovery address further adds a layer of resilience to account security. Users can proactively set a designated recovery address, allowing them to reclaim control of their accounts in the event of compromise or access loss.

In a decentralized world where self-sovereignty is paramount, Farcaster's authentication and identity generation mechanisms set new standards for privacy and control over digital assets.

January 2022

It's always exciting to start a new year and think about all the possibilities and opportunities it may bring. So started with a dedication to being a better developer and working on my physical health. Developed a personal project being more serious than ever before after a friend challenged me to do so. For the first time ever - no Youtube video references just pure use of API documentation of various libraries. Played handball for the first time and participated in the University games with just 2 days worth of practice. Guess what, I got selected for ZONALS.🤾‍♀️

Started learning about web3 and blockchain and YO, I liked it! LFG.

February 2022

Wanted some time off the screen so visited a bird sanctuary I had always wanted to visit. It is a very beautiful place and I enjoyed every single moment I spent there in the boat watching an entire regiment of FLAMINGOS and clicking so many breathtaking photos.

Later continued my journey in learning web3 and blockchain basics along with developing some stuff. Met and bonded with a few friends from previous college whilst the small convocation was arranged and had a blast.

February was a calm and light month, basically. But yes I started competitive coding and was quite active on Codechef - a really good platform to practice coding for beginners and even pros. My friend and I use to take part in weekly challenges to improve our skills.

Bought a new domain for my portfolio too. LOL! 🚀

March 2022

March was literally a turning point in my life, experienced a small but very transformative heartbreak that changed my thought process. Decided to code like never before and then was introduced to some cool platforms to learn and build blockchain projects like LearnWeb3 and Buildspace. Got into a bit of frontend development for the projects I had to develop on these platforms and left my fear of frontend far behind. This time my friends and I decided to have a quick trip and we enjoyed River Rafting at Kolad, OH what a breathtaking experience it was!😍

Meanwhile learning web3 and competitive coding continues.

April 2022

April was a month full of dilemmas and gave me the clarity I needed in life. Overcame stage fright by opting to dance for a college event in front of 100+ people.

Visited Hyderabad after years and loved it this time. Finally, my hometown made me realize my mistakes and I corrected them this month after returning. Finally understood the meaning of the following quote,

In search of gold, don't lose a diamond! 💎

Decided to keep things simple and not pressurize myself with everything that I want at a single time and started to work on things that really mattered to me.

Also, donated blood for the first time :)🩸

May 2022

May was beautiful and jolly but in the meantime, it was also resourceful. I had been hearing all the buzz about web3 meetups and stuff so finally decided to attend one. I was so afraid to go alone that I dragged a friend with me there. But yeah! It was a cool networking session and made some really great friends there. Met Tamar from the Solana ecosystem there and I was really very inspired by her.

Worked on a Bill Spilting application with a completely new frontend framework this time. Building this one overjoyed me and boosted my self-confidence. My friends circle literally used this one to split bills amongst us. 🏆

Oh did I forget to mention? I even experienced a bike accident this month. Yes, my bike slipped over the water. GG!

June 2022

As the month of June approached, I knew that it would bring with it a host of new challenges and opportunities. One of the biggest challenges I faced was deciding how to spend my time and energy. There were so many different things I could be doing, and I wanted to make sure that I was making the most of every day.

One opportunity that presented itself was the chance to help a friend market the new app he had been working on at his startup, Foster Reads. 📚

I spent time working closely with the entire team, helping to create promotional materials and coming up with a marketing strategy for the event. It was a lot of work, but it was also extremely rewarding.

And here was the time for another web3 meetup, this time had a little less anxiety and met some cool builders there. We talked about blockchains, some project ideas, and other technologies.

July 2022

Bruh, my birthday month🎂, and for the first time in my life the exam month too. Anyway passed with a pointer of 9.43 and had a cute birthday date. Later this month worked on my first frontend freelance gig and delivered a good working prototype to the client. Improved my frontend skills 100x times. July was so worked up that I needed a break and so visited Lohgad at peak monsoon times. The weather was soothing and the trek was refreshing.

August 2022

In the never-ending search for internships, I finally landed one this month. Took up a frontend role at CFT Labs.🖥 Tried my hands on Solana too :P Attended my first web3 event away from the city and of course, it had to be Web3Conf Goa. I can sit all day and write about how difficult it was to reach Goa with all the roads blocked due to heavy rainfall. Thank God we reached safe, and then the event gave me a whole new experience of the tech industry. Networking sessions OP!

Returned to Pune with loads of memories only to realize I had lots of pending work from my new internship. I struggled to understand the code written by someone else and took too much time to settle in. Fell sick thrice with the pressure of work and realized I had to cope. After a few days, I started to work with more dedication and finally was at mental peace.

September 2022

Strived for the entire month working on the internship project, and learned so many new things about frontend development. Improved my problem-solving approach, error handling, and dynamic screen updations.

This month I wrote my first piece of article on a web3 project and researched the technical side of that project. It was finally time to say goodbye as I wanted something related to the blockchain field and later this month joined WowLabz as a technical writer for web3 and metaverse.✍

Meanwhile, I was continuing coding and learning Solidity too.

October 2022

October was a busy and exciting month for me, as I was given the opportunity to become the TPG Pune chapter lead. The Phoenix Guild, or TPG, is a non-profit organization that is dedicated to fostering education and diversity in the web3 community. ☀

As the TPG Pune chapter lead, I was responsible for organizing and leading events and initiatives in my local community. This was a big responsibility, but I was excited about the opportunity to make a difference in my community and help promote the values of the TPG.

I also started learning advanced Solidity from the TPG Solidity Bootcamp and it was really helpful for me to understand concepts in detail.

November 2022

November was a month full of firsts for me. One of the biggest achievements of the month was writing my very first blog on the ERC20 token standard and publishing it on Hashnode. This was a topic that I had been interested in for a while.

I also conducted my first workshop for Shardeum, a Layer 1 blockchain company. The workshop was focused on introducing participants to the basics of smart contracts and deploying custom tokens, and I was thrilled to be able to share my knowledge with a new audience.

In addition to these achievements, I was also accepted to participate in EthIndia, a web3 hackathon in Bangalore. This was a huge honor, as the hackathon is one of the most prestigious in the web3 community.

To top it all off, November was also the month that I took my very first flight. ✈ I was nervous but excited to embark on this new adventure, and I was looking forward to meeting new people and learning new things at the hackathon.

Overall, November was a month of growth and opportunity for me, and I was grateful for all of the experiences and challenges that it brought my way.

December 2022

Participating in EthIndia and the TPG Hacker House was an incredible experience for me. From the moment I arrived in Bangalore, I knew that this was going to be a special trip. I had the opportunity to speak at the dAOs 3.0 event in Bangalore.

The hackathon itself was an intense and exciting event, and I loved being surrounded by so many talented and passionate people. I was a little nervous at first, as I wasn't sure how well I would be able to keep up with the other participants. Unfortunately, things didn't go exactly as planned for our team. We struggled with project ideation and ended up having to pivot to a new idea at the last minute. It was a bit of a mess, but we were determined to make the most of the opportunity. In the end, we managed to pull together a quick project that got us through the hackathon. It wasn't our best work, but we were proud of what we had accomplished given the circumstances.

After returning to Pune from EthIndia, I was feeling energized and motivated to continue working on my skills. I had learned so much at the hackathon and had made some great connections, and I was determined to make the most of these opportunities.

One way that I decided to do this was by participating in a virtual hackathon. This was a new experience for me, as I had never participated in a virtual hackathon before. But I was excited for the chance to test my skills and see what I was capable of. I decided to go solo for this hackathon, which was a bit of a risk. But I was confident in my abilities and wanted to prove to myself that I could succeed as a solo hacker. The hackathon was a lot of work, but it was also a lot of fun. I enjoyed the challenge of working on a project completely on my own, and I was proud of the end result. In the end, I was able to submit a project that I was really proud of, and I felt great about my progress.

The end of December was a cherry on top of an already exciting year for me. After months of hard work and dedication, I finally got a college placement offer as a developer at a highly sought-after software company. To top it off, I was also selected to be a member of the Developer DAO.✨

Quick recap

This entire year has been full of ups and downs, with moments of joy and sorrow, success and failure, having lots of fun to completely losing my mind. Despite the challenges, I have remained determined and motivated to keep pushing forward.

There have been times when things seemed impossible, and I wasn't sure if I would be able to overcome the obstacles in front of me. But I have always found the strength and resilience to keep going, and I am proud of everything that I have accomplished this year.

I have learned so much and grown in so many ways, and I am grateful for all of the experiences and challenges that have come my way. By sharing my experiences, I hope to provide insight and inspiration to others who may be going through similar experiences and to read amazing experiences by other developers you can check out posts for Dev Retro 2022 from Hashnode.

2023, I am waiting ....

Looking ahead to 2023, I have the energy and enthusiasm to make it an even more amazing year. I am excited about the opportunity to continue learning and growing, and I am ready to take on whatever challenges come my way.

No matter what the future holds, I know that I am up to the task, and I am confident that I will be able to make the most of every opportunity that comes my way. 🤝

Accessing data on the blockchain

Blockchain information needs to be indexed and made accessible in order to increase transparency, security, and trust in the data stored on the blockchain. By making this data accessible, users can more easily verify the accuracy of the information, ensure the security of their data and trace the source of the data. Additionally, by indexing the data, users can quickly and efficiently search the blockchain for specific information, such as transactions, contracts, and ownership records. This will make it easier for users to audit and analyze the data stored on the blockchain, as well as to identify any potential security vulnerabilities. Furthermore, indexing and making blockchain data accessible will enable developers to create powerful applications that utilize the data in a secure, transparent, and efficient way. Therefore, it is essential that blockchain information is indexed and made accessible in order to ensure the integrity and security of the data stored on the blockchain. But how do we do it, technically?

Enter Covalent.

Covalent is a unified API that helps to organize the world's blockchain information, providing users with an easy-to-use interface and a comprehensive set of tools. It is the only multi-chain API that provides access to deep, granular, and historical blockchain data. Covalent has indexed the entire blockchain so nothing really remains inaccessible. Covalent API’s features help to make sense of the vast amounts of data that are generated from the various blockchains. It enables users to track, analyze, and visualize the data from multiple networks and blockchains, providing users with a comprehensive view of their data. Covalent’s tools are designed to make it easier for users to understand the data from different networks. It provides interactive visualizations of the data, allowing users to quickly spot trends and identify anomalies. It also provides powerful analytics tools that allow users to gain deeper insights into the data. In addition, Covalent provides users with access to a wide range of APIs, allowing them to easily access and integrate data from different networks. This makes it easier to build applications that need to access data from multiple blockchains. Overall, Covalent is a powerful platform that helps to make sense of the data generated by the world’s blockchains. It provides users with an easy-to-use interface and a comprehensive set of tools that make it easier to understand and analyze the data. Covalent Query Token (CQT) is a proof of stake (PoS) governance token powering the Covalent network.

Using the Covalent Unified API

You can access the API here on the official website.

You need an API key to get started with the API which you can generate by creating your account - click on 'Get an API key'

Example: To get transactions for address using Covalent API

request format: https://api.covalenthq.com/v1/{chain_id}/address/{wallet_address}/transactions_v2/

According to the docs, this returns all transactions along with their decoded log events. This endpoint does a deep crawl of the blockchain to retrieve all kinds of transactions that reference the address including indexed topics within the event logs given chain_id and wallet_address

so a sample request on the 'Polygon Mumbai Testnet' would look like: https://api.covalenthq.com/v1/80001/address/0xE5C73643Fba5652635207c689091A00eeAdae644/transactions_v2/

returning data in a JSON object like this, with items array having details of every transaction on that address

{
   "address": "0xe5c73643fba5652635207c689091a00eeadae644",
   "updated_at": "2022-12-07T07:00:28.983983340Z",
   "next_update_at": "2022-12-07T07:05:28.983983720Z",
   "quote_currency": "USD",
   "chain_id": 80001,
   "items": []
}

Other significant API requests

1. Get historical portfolio value over time

returns wallet value for the last 30 days at 24 hour interval timestamps.

2. Get ERC20 token transfers for address

returns all ERC20 token contract transfers along with their historical prices at the time of their transfer.

3. Get NFT transactions for contract

returns a list of transactions for the particular contract.

Final Thoughts

In conclusion, the Covalent unified API offers a powerful and convenient solution for indexing blockchain data. With its robust and easy-to-use interface, it allows users to quickly and easily access the information they need from multiple blockchain networks. This makes it an invaluable tool for developers and other users who need to work with blockchain data on a regular basis. Its ability to provide a unified view of data from multiple blockchains is particularly useful, as it allows users to easily compare and analyze data from different networks in a single platform. Overall, the API is a valuable resource for anyone looking to index and work with blockchain data.

A token is a type of digital asset that can be used for numerous purposes like tickets to social events, payment systems, etc. They can basically represent anything and everything. Tokens may be used as proof of ownership for digital collectibles or even physical world items. They are also used to raise funds from the community.

Tokens are to crypto, what shares are to the stock market💸

Tokens are cryptocurrencies that are built on top of another blockchain (they are not native assets of the blockchain like ETH is to Ethereum and SOL is to Solana)

While every blockchain follows different rules and regulations to create and manage tokens, ERC20 is a standard used by Ethereum-based blockchains to fulfill this purpose.

The ERC-20 standard

ERC stands for Ethereum Request for Comment. The Ethereum-based tokens created using this standard are fungible tokens meaning that each token when replaced with another of its kind holds the same value in nature as the previous one. For example, if you replace a $1 note with another $1, it still values at $1. The same applies to cryptocurrencies like Bitcoin and Ethereum. (1 BTC will always be equal to 1 BTC) In simple words, ERC-20 tokens are interchangeable.

A token contract should have these 5 basic functionalities:

1. Transfer - transfer tokens from one address to another
2. Mint - create new tokens to increase the supply
3. Burn - remove the tokens from supply (sending them to address(0))
4. Approve - allow an address to take control of owner's tokens
5. Transferfrom - transfer tokens from some address to another, only an address approved to do so by the owner of tokens can perform this operation

Popularly, ERC-20 tokens are created using Openzeppelin's ERC-20 contract which can be found here.

It takes only 5 lines of code to actually create ERC20 tokens but the logic behind the same is often unknown to many Solidity developers (which btw is a very big no-no).

So moving on to understanding the code of the ERC-20 contract which we inherit for our custom token contract. LFG.🚀

A contract binds together variables and functions.

State variables and mappings:

The statement uint public _totalSupply; indicates a variable name _totalSupply with data type uint(unsigned integer) is created to maintain a count of the total tokens that are created and are currently in supply

mapping(address => uint) public _balances; maps address to a uint number which keeps a track of the total tokens a particular address holds

mapping(address => mapping(address => uint)) public _allowances; is a nested mapping and is used to approve a particular address to spend some amount of tokens on behalf of the sender (delegate control) here the first address is the one whose control of tokens is delegated to the second address. uint holds the number of tokens that a particular address is allowed to spend

string private _name; stores the name of the token you will create like Aptos

string private _symbol; stores the symbol for the token like APT

the constructor of the contract will assign these values - _name and _symbol

 constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

Functions

1.transfer

Function transfer is a virtual function that returns a boolean and takes two arguments

a. to - the recipient to whom the tokens are to be transferred

b. amount - how many tokens are to be transferred to the recipient

function transfer(address to, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, amount);
        return true;
    }

transfer function then calls another internal function _transfer (with an additional argument of owner that stores the sender address) which executes the main logic of transferring tokens from one address to another

function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(from, to, amount);

        uint256 fromBalance = _balances[from];
        require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[from] = fromBalance - amount;
            // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by
            // decrementing then incrementing.
            _balances[to] += amount;
        }

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, amount);
    }

Here, it is checked if both addresses are valid with the require conditions then an optional function _beforeTokenTransfer(from, to, amount); can be called if there are some steps to be executed before the token transfer

uint256 fromBalance = _balances[from]; gets the sender's balance from the mapping _balances

require(fromBalance >= amount, "ERC20: transfer amount exceeds balance"); is used to check if the sender has enough balance for the specified amount to be transferred if the condition fromBalance >= amount is not satisfied then the transaction reverts with message 'ERC20: transfer amount exceeds balance'

If everything goes well, we deduct the balance of sender and increase the balance of the receiver with _balances[from] = fromBalance - amount; & _balances[to] += amount;

Finally an event emit Transfer(from, to, amount); is emitted indicating successful transfer of function, and an optional function _afterTokenTransfer(from, to, amount); can be executed if required.

2._mint

This function takes an address account to whom the tokens will be transferred after minting and amount i.e. the number of tokens to be minted

function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply += amount;
        unchecked {
            // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
            _balances[account] += amount;
        }
        emit Transfer(address(0), account, amount);

        _afterTokenTransfer(address(0), account, amount);
    }

Here too, the address is checked to be a valid one before any other transaction is carried out.

_totalSupply += amount; increases the total supply of tokens by amount

_balances[account] += amount; increases the balance of the account whose address was given with the _mint function by the number of tokens minted and finally emits a Transfer event

3._burn

This function has almost the same steps as getting the balance of the account in the _mint function except, instead of creating new tokens it destroys the already created ones and removes them from circulation decreasing the total supply.

 function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
            // Overflow not possible: amount <= accountBalance <= totalSupply.
            _totalSupply -= amount;
        }

        emit Transfer(account, address(0), amount);

        _afterTokenTransfer(account, address(0), amount);
    }

uint256 accountBalance = _balances[account]; get balance of account who is willing to destroy their tokens

require(accountBalance >= amount, "ERC20: burn amount exceeds balance"); checks if there is enough balance

_balances[account] = accountBalance - amount; subtracts the balance by the amount of tokens to be burnt and then reduces the total supply with _totalSupply -= amount;

Finally, a Transfer event is emitted. Note that the account that receives the token is address(0) which means they are sent to an address that cannot be operated.

4.approve

This function approves a particular address spender to spend amount tokens on behalf of the owner - sender of this message

function approve(address spender, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, amount);
        return true;
    }

It calls another internal function that is _approve(owner, spender, amount);

function _approve(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

The changes are made in the _allowances mapping with _allowances[owner][spender] = amount;

This basically means 'approve the spender to spend amount number of tokens on behalf of the owner' and typically the mapping structure is somewhat like this owner ---> (spender ---> amount)

An event is emitted with emit Approval(owner, spender, amount); which indicates successful approval

5.transferFrom

This function has 3 arguments, from - owner address (owner may not be the message's sender) to - receiver address amount - number of tokens to be transferred

function transferFrom(
        address from,
        address to,
        uint256 amount
    ) public virtual override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, amount);
        _transfer(from, to, amount);
        return true;
    }

It eventually calls another internal function _spendAllowance(from, spender, amount); which has the main logic to check how much amount of tokens can the approved addresses transfer

_transfer(from, to, amount); uses the logic as explained above to transfer tokens from one address to another

function _spendAllowance(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            require(currentAllowance >= amount, "ERC20: insufficient allowance");
            unchecked {
                _approve(owner, spender, currentAllowance - amount);
            }
        }
    }

function allowance(owner, spender)

function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

calculates how many tokens owned by the owner are allowed to be controlled by the spender and assigns it to currentAllowance

The_spendAllowance function then checks if currentAllowance that is the number of tokens approved to be controlled by the spender is greater than or equal to the amount of tokens to be transferred

Then _approve(owner, spender, currentAllowance - amount) is called to set the new approval limit and executes as explained above

Here new approval limit will be calculated by subtracting the tokens that will be transferred now(amount) from the total number of tokens allowed(currentAllowance)

After the _spendAllowance function in the transferFrom function is rightfully executed a call to _transfer(from, to, amount); is made which executes the transfer of tokens from one address to another.

Additions

The functions increaseAllowance and decreaseAllowance increase or decrease the number of tokens that can be controlled by the spender on behalf of the owner.

Finally, let us write a contract to deploy our own token on the blockchain

//SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol";

contract BlogToken is ERC20{
    constructor(string memory _name, string memory _symbol) ERC20(_name, _symbol){
        _mint(msg.sender, 10000 * 10**18);
    }
}

Note: This is a small contract to show a demo of how our own 10000 tokens can be deployed to the blockchain using _mint and the contract to professionally deploy a token will have a lot more functionality like approve, transferFrom, and others.