Forem: Olasunkanmi Igbasan

Fundamentals of Networking: Connecting the Digital World

Olasunkanmi Igbasan — Thu, 28 Sep 2023 22:20:14 +0000

In today's interconnected world, understanding the basics of networking is crucial. This article explores the fundamental principles that powers the internet and modern communication systems. From Client-Server Architecture to the OSI model to IP addressing, we'll demystify the essential concepts that underpin our digital lives.

Client -Server Architecture

Client-Server Architecture is a fundamental computing model that revolutionised the networking space. It's a distributed architecture where tasks or processes are divided between two types of entities: clients and servers.

1. Reinventing the Networking Space:

Before Client-Server Architecture:

In the early days of computing, the predominant model was the centralized mainframe. All processing occurred on a single mainframe computer, and users had limited access through terminals. This model was inflexible and did not scale well.

Client-Server Revolution: The client-server architecture introduced the concept of distributing tasks between clients (requesters) and servers (providers). This approach allowed for greater flexibility, scalability, and better resource utilization.

2. Importance of the Reinvention:

Scalability:

The architecture enables scaling by adding more servers to handles increased client demand. The scalability is crucial for accommodating growing user bases

Flexibility:

It offers flexibility by allowing different types of clients (e.g., desktop applications, web browsers, mobile devices) to access server resources, making it adaptable to various platforms.

Security:

Centralized servers enables better security management, as security measures can be implemented as the server to avoid unwanted access and prevent data loses

3. Benefits Of the Reinvention:

Resource Utilization:

Server resources (e.g., databases, computation power) can be efficiently shared among multiple clients, maximizing resource utilization.

Reliability:

Clients can rely on the server to provide consistent and up-to-date data, reducing data inconsistency issues.

Maintenance:

Centralized server management simplifies maintenance and updates, as changes can be applied at the server without affecting clients.

Indeed, while the client-server architecture is remarkable, effective communication between diverse hardware components necessitates a structured communication model and standardised protocols.
This is precisely where the OSI(Open Systems Interconnection) Model steps in. The OSI Model provides a comprehensive framework that delineates the intricate layers of network communication, ensuring seamless interoperability and reliable data exchange between different hardware elements. It serves as the foundational structure that enables the digital world to communicate coherently and efficiently, making it an indispensable cornerstone of modern networking.

Fundamentals Of Network Engineering For Backends.

Olasunkanmi Igbasan — Thu, 28 Sep 2023 20:53:56 +0000

Welcome to the Fundamentals Of Network Engineering For Backends

Welcome to the comprehensive resource center for the Fundamentals Of Network Engineering For Backends series. This collection of articles serves as a cornerstone for understanding the core principles and practices associated with network engineering, particularly in the context of backend systems. Whether you're a seasoned network professional or just starting your journey in this field, this series will provide you with valuable insights and knowledge.

Overview

The Fundamentals Of Network Engineering For Backends series is designed to help you grasp the essential concepts and techniques necessary for effective backend design and management. If you're looking to deepen your understanding of network engineering or are pursuing a career in backend development, this series is a valuable resource.

Course on Udemy

For those who prefer a structured learning experience, you can access the course through the following link: Fundamentals of Networking for Effective Backend Design by Hussein Nasser. It offers a guided curriculum and hands-on exercises to reinforce your learning.

Articles in the Series

Here are some of the topics we'll cover in this series:

Fundamentals of Networking: Understand the fundamentals on Networking, The Why and How.

These articles will serve as a valuable reference as you progress through the series and deepen your knowledge of network engineering for backends.

Regular Updates

This page will be regularly updated to ensure that you have access to the latest articles and resources related to the series. Check back often to stay up-to-date.

Thank you for joining me on this educational journey. I am excited to be your guide in mastering the fundamentals of network engineering for effective backend design. Stay tuned for my upcoming articles, and don't hesitate to explore the Udemy course for a structured learning experience.

Building Robust Node.js Applications with Socket.io: Best Practices

Olasunkanmi Igbasan — Thu, 16 Mar 2023 03:13:58 +0000

Introduction

This article will guide you through building a basic AI chatbot using Node.js and socket.io while incorporating some of the best practices for Node.js development. With its bi-directional communication capabilities, socket.io makes it easy to build real-time applications that require continuous interaction between the server and clients.

Throughout the development process, we'll follow best practices to ensure that our application is secure, scalable, and maintainable.

Setting up the Environment

To set up the environment for building a web application using Node.js, you will need to follow a few simple steps:

1 Install Node.js.
2 Setup project directory.

my-chatbot/
├── node_modules/
├── public/
│   ├── css/
│   │   ├── style.css
│   ├── js/
│   │   ├── chat.js
│   │   ├── socket.io.js
│   ├── index.html
├── app/
│   ├── services/
│   |     ├── store.js
│   ├── socket/
│   |    ├── socket.js
│   |    ├── socketHelper.js
│   ├── utils/
│   |     ├── constants.js
├── config/
│   |      ├── app.js
├── app.js
├── .env
├── .gitignore
├── package-lock.json
├── package.json
└── README.md

3 Install the necessary dependencies.

npm i express socket.io

Socket.io

Socket.io is a popular library for building real-time web applications that require bi-directional communication between the server and clients. It is built on top of the WebSockets API and provides a simple and elegant API for building real-time applications with features such as broadcasting, namespaces, and rooms.

Socket.io would be a crucial part of the chatbot has it would majorly be handling the communication between our server and client.

Creating the express server

app/: This directory contains all the backend code for our application.

Within this file we would be initializing our express application.

const express = require('express');
const { appConfig, Logger } = require('./config');
const app = express();

global.logger = Logger.createLogger({ label: 'E-commerce Chatbot' });

appConfig(app);

module.exports = app;

This is a simple configuration that exports an instance of the Express application after initializing the app configuration and logger.

Firstly, we import the express framework module, then we import appConfig, Logger from the config module.

global.logger = Logger.createLogger({ label: 'E-commerce Chatbot' });

In the line above, logger is defined as a global variable. This allows it to be accessed from any module within the Node.js application, providing a centralized location for logging.

Configuring Express app

const express = require('express');
const http = require('http');
const path = require('path');
const Socket = require('../app/socket/socket');

const appConfig = async (app) => {
    // Set up server
    const server = http.createServer(app);

    // Set up socket
    const { SocketInstance } = Socket.createSocket(server);
    SocketInstance(server);
    // Set static files
    app.use(express.static(path.join(__dirname, '../public')));

    const PORT = 9000;
    // Listen to port
    server.listen(PORT, () => {
        logger.info(`Server running on port ${PORT}`);
    });
};

module.exports = appConfig;

This is the appConfig function which configures the Express app.

The appConfig function plays a critical role in configuring the Express app for the chatbot. It creates an HTTP server using http.createServer(app), configures the socket instance using Socket.createSocket(server), and sets up static files with express.static(). The function then listens to a specified port using server.listen(). These actions follow Node.js best practices, such as setting up the server to listen on a specific port and using the path module to serve static files.

Additionally, it is a good practice to keep the app configuration within the scope of a function in Node.js. It helps to isolate the configuration code and prevents it from being accessed or modified outside of the function's scope, which can help improve the security of the application.

By doing so, you can limit the access to important variables or configurations that are necessary for your application to work properly, making it more difficult for unauthorized access or modification. Additionally, it can also help to improve the maintainability of your code by keeping it organized and easy to read.

Configuring Socket.io

One of the key aspects of backend development is data-privatization and encapsulation. One of best way to implement this is the use of a class-based approach.

Within the Socket class, private methods are used to handle the socket events, such as when a user sends a message or when a user joins or leaves the chatroom. The use of private methods helps to keep the implementation details hidden from external modules, improving the overall security and maintainability of the code.

Furthermore, the public methods of the Socket class are used to emit messages to the chatroom, whether it be from the user or the bot. By separating these methods, it becomes easier to manage the logic of the socket instance and improves the overall readability of the code.

The constructor of the Socket class initializes the instance with the necessary properties, such as the server and the socket instance. Additionally, default values for the bot and user names are set, providing a more customizable implementation.

The initializeSocket method is responsible for handling the connection event and initializing the necessary event listeners for user messages, bot messages, notifications, and disconnections. By organizing these events in a separate method, the code is easier to understand and maintain.

Finally, the createSocket static method is used to create a new instance of the Socket class and initialize the socket instance. This method provides an easy-to-use interface for other modules to create and manage their own socket instances.

*Socket config 👇🏼 *

const socket = require('socket.io');
const constants = require('../utils/constants');

const {
    CHAT_BEGINNING,
    NEW_CONNECTION,
    BOT_NAME,
    BOT_INTRO,
    BOT_INTRO_2,
} = constants;

class Socket {
    constructor(server) {
        this.server = server;
        this.io = socket(server, { cors: { origin: '*' } });
        this.botName = BOT_NAME;
        this.userName = 'User';
    }

    /**
     * @private
     * @function _emitUserMessage
     * @param {object} socket
     * @param {object} message
     * @emits userMessage - when a user sends a message
     * @memberof Socket
     * @returns {object} message - returns user message to the chatroom
     */
    _emitUserMessage(socket, message) {
        socket.emit('userMessage', Helper(this.userName, message));
    }

    /**
     * @private
     * @function _emitBotMessage
     * @param {object} socket
     * @param {object} message
     * @emits botMessage - when the chatbot sends a message
     * @memberof Socket
     * @returns {object} message - returns bot message to the chatroom
     */
    _emitBotMessage(socket, message) {
        socket.emit('botMessage', Helper(this.botName, message));
    }

    /**
     * @private
     * @function _emitNotification
     * @param {object} socket
     * @param {object} message
     * @emits notification - when a user joins or leaves the chatroom
     * @memberof Socket
     * @returns {object} message - returns notification to the chatroom
     */
    _emitNotification(socket, message) {
        socket.emit('notification', Helper(this.botName, message));
    } 

    /**
     * @private
     * @function _broadcastNotification
     * @param {object} socket
     * @param {object} message
     * @emits notification - when a user joins or leaves the chatroom
     * @memberof Socket
     * @returns {function} _emitNotification - returns notification to the chatroom
     */
    _broadcastNotification(socket, message) {
        this._emitNotification(socket.broadcast, message);
    }

    /**
     * @private
     * @function _emitDisconnect
     * @param {object} socket
     * @emits disconnect - when a user disconnects from the chatroom
     * @memberof Socket
     * @returns {function} _broadcastNotification - returns notification to the chatroom
     */
    _emitDisconnect(socket) {
        socket.on('disconnect', (reason) => {
            this._broadcastNotification(socket, reason);
        });
    }


    /**
     * @private
     * @function initializeSocket
     * @memberof Socket
     * @returns {function} _listenRegister - listens for register
     * @returns {function} _emitNotification - emits notification to the chatroom
     * @returns {function} _emitBotMessage - emits bot message to the chatroom
     * @returns {function} _listenToChatMessage - listens for chat message
     * @description Initializes socket
     * @listens for connection
     * @emits userMessage
     * @emits botMessage
     * @emits notification
     * @emits disconnect
     * @emits access
     */
    initializeSocket() {
        this.io.on('connection', (socket) => {
            logger.info(NEW_CONNECTION(socket.id));


            // Emit to the new user only
            this._emitNotification(socket, CHAT_BEGINNING);

            // Emit bot message
            this._emitBotMessage(socket, BOT_INTRO);

            this._emitBotMessage(socket, BOT_INTRO_2);


        });


    }

    /**
     * @static
     * @function createSocket
     * @param {object} server- server instance
     * @memberof Socket
     * @returns {object} socketInstance - returns socket instance
     * @description Creates a socket instance
     */
    static createSocket(server) {
        const _createSocketInstance = (server) => {
            const socketInstance = new Socket(server);
            return socketInstance.initializeSocket();
        };

        return {
            SocketInstance: _createSocketInstance,
        };
    }
}

module.exports = Socket;

Full Break down

When the server starts up, the Socket constructor is called and is passed the HTTP server instance. Inside the constructor, the Socket.IO library is used to create a new socket instance and this instance is stored as a property of the Socket object. The Socket object also initializes some properties to store the names of the bot and the user, which will be used later.

The Socket class has several private methods that are used to emit messages to the connected sockets. These methods include _emitUserMessage, _emitBotMessage, _emitNotification, and _broadcastNotification. These methods all take a socket object and a message object as parameters and emit the message to either the socket that called the method or to all sockets except for the socket that called the method.

Advantages of using private class methods

Defining these methods as private methods within the class provides encapsulation and modularity to the code. By keeping these methods within the class, they are not exposed to the global scope and can only be accessed within the class itself. This prevents potential naming conflicts with other methods or variables in the global scope.
Additionally, by encapsulating these methods within the class, it makes it easier to maintain and modify the code. Since these methods are closely related to the functionality of the class, it makes sense to keep them within the class for better organization and ease of access.
Another advantage of defining these methods as private within the class is that it helps to abstract away some of the complexities of using the Socket.io library. By creating methods that handle the details of emitting specific events and messages, the rest of the code can focus on the higher-level logic of the application, without needing to worry about the specifics of Socket.io's API.
Finally, it also helps with code reusability, as these methods can be called from within other methods in the class, rather than being duplicated across multiple functions. This helps to reduce code duplication and makes it easier to maintain the codebase.

The Socket class also has a public method called initializeSocket, which is called to start the socket server. Inside this method, the Socket.IO library's on method is used to listen for the connection event. When a new client connects to the socket server, a new socket object is created for that client and a logger is used to log that a new connection has been established.

The initializeSocket method then calls some of the private methods to send messages to the client, such as a welcome message from the bot, a notification that a new user has joined, and an introduction message from the bot. The method also listens for the disconnect event and broadcasts a notification to all connected sockets when a client disconnects from the server.

A class-based approach for socket.io can be particularly beneficial for backend developers, as it allows them to maintain a cleaner and more organized code structure. This is especially important for backend development, where code can become complex and difficult to manage as the application grows in size and complexity.

By encapsulating socket-related logic and events within a class, backend developers can effectively separate the concerns of the application, making it easier to manage and maintain the code. This can be particularly helpful when working with large-scale applications that require multiple developers to work on different parts of the codebase.

In addition to improving the organization of the code, using a class-based approach for socket.io can also help to prevent conflicts and improve modularity. This is because different parts of the application can use sockets without interfering with each other, allowing developers to work on different components of the application in parallel.

Furthermore, by adopting a class-based approach, backend developers can make use of object-oriented programming concepts, such as inheritance and polymorphism, which can lead to more efficient and maintainable code. For example, by using inheritance, developers can create a base class for common socket-related logic and events, and then extend this class to add specific functionality for different parts of the application.

Overall, using a class-based approach for socket.io can be a valuable tool for backend developers, helping to streamline development, improve code organization, and enhance modularity and efficiency.

Building a simple REST api with Express: A walkthrough.

Olasunkanmi Igbasan — Tue, 10 Jan 2023 22:57:48 +0000

Project Description
This article is meant for developers and other technical audiences, looking to understand the implementation of a blogging app or any app really with the Express framework. Furthermore, this article is organized in a way that would cover the main areas of the project such as the technical requirements, design and implementation, challenges, deployment and testing and conclusion.

This project is a web application using Node.js, Express, and MySQL, It also demonstrates a one-to-many SQL relationship.

Technology Stack

server side : Node.js, Express.js
Database: MySQL

Prerequisites

Basic knowledge of JavaScript, and SQL.
MySQL server, Node.js and npm installed on your Machine.

Step 1: Setting up the server

Create a new directory for the project.
Navigate to the terminal of the directory.
Initialize a new Node.js project with the code below

`npm init -y`

Install the following dependencies

nodemon - nodemon is a tool that helps develop node-based applications by automatically restarting the node application when file changes in the directory are detected.

Express - Express is a free and open-source Node.js web application framework.

bcrypt - bcrypt turns a simple password into fixed-length characters called a hash.

body-parser - body-parser is the Node.js body parsing middleware.

crypto-js - crypto-js is a module in Node. js which deals with an algorithm that performs data encryption and decryption.

dotenv - The dotenv package is a great way to keep passwords, API keys, and other sensitive data out of your code.

express-rate-limit - express-rate-limiting is a strategy you can use to control traffic on a network, secure backend API and limits the number of unwanted requests that a user can make within a specific time frame.

helmet - helmet fills in the gap between Node.js and Express.js by securing HTTP headers that are returned by your Express apps.

joi - joi is used for schema description and data validation.

joi-password - joi-password is an extension of joi that helps in validating passwords.

jsonwebtoken - Often called JWT, or JSON Web Token. JWTs are mainly used for authentication. After a user signs in to an application, the application then assigns JWT to that user.

morgan - morgan is a Node. js and Express middleware to log(taking records of events that occur in a software) HTTP requests and errors, and simplifies the process.

winston - winston is designed to be a simple and universal logging library with support for multiple transports.

The Reactor Pattern in NodeJS

Olasunkanmi Igbasan — Tue, 22 Nov 2022 14:10:32 +0000

Every programming language, framework, and library has a unique design pattern and guiding philosophy which makes up for its peculiarity, and it is widely known that NodeJS is built with on the chrome V8 Engine.

However, the Reactor pattern is the heart of Nodejs.

The Reactor Pattern.

To prevent input/output operations from being blocked, the reactor pattern is used. It provides a handler connected to I/O operations for us, I/O requests are generated and sent to a demultiplexer, which handles concurrency to prevent I/O mode blocking, gathers the requests in the form of events, and queues those events accordingly to the Event Loop.

I/O operations are performed generally in two ways:

Blocking I/O

The execution thread will be blocked by the function call associated with an I/O request (user request) in conventional blocking I/O programming until the operation is finished. i.e. Synchronous programming

2 Non I/O Blocking
The system call always returns immediately in this operating mode, without waiting for the data to be read or written. If there are no results available at the time of the call, the function will simply return a predefined constant, indicating that there is no data to return at that time. i.e. Asynchronous programming

Recipe for the Reactor Pattern.

Since you have learned that the Reactor pattern is the Heart of NodeJS, then what exactly is the Reactor pattern made of?

Resources: They are shared by multiple applications for I/O operations, making executions generally slower. (this is because I/O is naturally slow )
Synchronous Event Demultiplexer: When a read or write operation carried out over one of those resources is finished, the synchronous event demultiplexer watches multiple resources and returns a new event (or set of events). The synchronous event demultiplexer is advantageous in this situation because it naturally blocks until there are new events to process.
In conclusion, the Event De-multiplexer pushes the new events into the Event Queue when a set of I/O operations is finished.
Event Queue and Event Loop:
An event queue is a repository where events and each handles from the application are held prior to being processed by a receiving program or system, which is the Event Loop. The Event Loop iterates over the event queue

How does the Reactor Pattern Works?

(a) When a new I/O request is generated by the application by submitting a request to the Event Demultiplexer. The application also attaches an handle to the request, which will be called when the operations is complete. (b). Submitting an I/O request is to the Event Demultiplexer asynchronous in nature, hence control is returned back to the application.
When the operations for request is complete, the events with its corresponding handler is pushed into the Event Queue.
At this points, the Event Loop iterates over the items in the Event Queue
The handler for the I/O request in the Event Loop is invoked for execution.
(a)After the invocation and execution of the Handler, control is given back to the Event Loop. (b) While the handler executes it can cause for a new I/O request be made (usually asynchronous), causing new items to be added to the Event Demultiplexer.
A new cycle begins when a new event becomes available after all of the items in the Event Queue have been processed by the Event Loop, which then blocks once more on the Event Demultiplexer.

When there are no more pending operations in the event demultiplexer and no more events to process inside the event queue, a Node.js application will exit.

Sources:

https://www.geeksforgeeks.org/what-is-reactor-pattern-in-node-js/
Node Design Patterns by Mario Casciaro and Luciano Mammino

NodeJS Module System

Olasunkanmi Igbasan — Tue, 15 Nov 2022 10:30:32 +0000

A JavaScript run-time called Node.js is built on top of the Chrome v8 engine. In essence, the Node.js platform offers an environment for JavaScript code execution that is separate from the typical web browser (it's crucial to remember that Node.js was developed for the creation of network applications utilizing JavaScript).

The building blocks for building complex applications are modules in Node.
Using the module building system, you can segregate the codebase into manageable chunks that can be independently created and tested. By keeping all the functions and variables that are not explicitly designated to be exported private, modules are also the primary mechanism for enforcing information shielding.

Modules are of three types:

Core Modules
Local Modules
Third Party Modules

Core Modules: Node.js comes with a number of inbuilt modules that are installed as part of the infrastructure. The require function can be used to import these modules into the application.

const module = require('module-name')

You need only refer to the module name when loading a core module or a module from the node modules subdirectory.

Local Modules:

A separate JavaScript file must be used to create the local module. We can declare a JavaScript object with various properties and functions in a separate file.

const Hello = {

    sayHello : function() {
        console.log("Hello  user");
  },

  curTime : new Date().toLocaleDateString(),


}

module.exports = Hello

Using the above module;

const localModule = require("./Hello.js");
localModule.sayHello();
console.log(localModule.currTime);

Third Party Modules :

Third party modules are often external modules installed through the Node Package Manager.

npm install express

👆🏼 How to install third party modules.
👇🏼 How to import third party modules.

const express = require('express')

How loading a module works

When loading a module, node first checks to see whether the module identifier (the string passed into the require function call) begins with "./," "/," or "../," and if it doesn't, node checks to see whether the identifier matches any of its core modules (http, path, fs, etc.). If a match is found, node loads the recognized core module; or else, node knows to browse the node modules folder.

The Need for modules.

The ability to divide the codebase into several files
This keeps the code more ordered, makes it simpler to understand, and helps maintain the independence of different functionality.
Enabling code reuse across various projects: It's possible for a module to implement a generic feature that can be helpful for various projects.
Encapsulation (information protection): Most module systems allow for the selective concealment of the private portion of the code while exposing the public interface, such as functions, classes, or objects, which are intended for usage by the module's consumers.

In conclusion, depending on the global scope is a very risky effort, especially as your application evolves. As a result, when a modification is required, just the module where the function is written is addressed.
When a change is required or when your application changes, the Module system prevents a complete breakdown.

The well-known DON'T REPEAT YOURSELF software development philosophy is taken to a whole new level with the Module system.

Simple search vs Binary search Algorithms.

Olasunkanmi Igbasan — Sun, 14 Aug 2022 13:28:00 +0000

Hello there !
Welcome and stay with me as I explain Big O Notation to you in the simplest words ever!

"Total time needed for an algorithm to run," is the simplest definition of Big O Notation, but why does it matter to you as a developer?

To answer that, below is a simple search Algorithm that finds any given item in an array; if the given item is not in the array, our algorithm returns null.

Simple Search Algorithm.

           Fig 1.0 (For-loop search algorithm )

The above is a simple JavaScript For-loop that iterates over each item in the array, checks if the current iteration equals our input ('item' ), and if the item is not in the array, it returns "null."

Below (Fig 2.0 ) is a while loop that does the same as the above For-loop.

Binary Search Algorithm.

      Fig 2.0 (while loop search algorithm )

Although, the above functions do precisely the same thing. But what happens when the number of items in our array increases exponentially?

How efficient will both our algorithms still be ?

A step-by-step break-down of the Binary Search Algorithm:

We compare 'item' with the middle index of the array.
if 'item' matches the mid index, we return the mid element.
else if 'item' is greater than the middle element, length of the array is reassigned to the middle ( element - 1 ).
else if 'item' is lesser than the middle element, beginning of the array is reassigned to the middle ( element + 1 ).

With this method we eliminate half of the array in the first comparison.

For better understanding,
If the length of the array increases to 1millon.
With the first function (Fig 1.0), we will perform 1 million iterations (worst case) to find our item. However, we will perform at most 10 iterations (worst case) with the second function.

The Big O notation of our functions.

Simple search algorithm (Fig 1.0) - O(n) // Bad guy
Binary search algorithm (Fig 2.0) - O(log n) // Good guy.

Stay with me on this blog while I explain Algorithms and Data Structures as succinctly as possible.

Link to Code and remember to give it a star.
https://github.com/Olatisunkanmi/Data-Structures-and-Algorithms-/tree/main/5%20Algorithms/Binary%20Search