DEV Community: Eyitayo Itunu Babatope

How to Implement LLM Grounding using Retrieval Augmented Generation Technique(RAG)

Eyitayo Itunu Babatope — Fri, 05 Dec 2025 03:30:11 +0000

Introduction

Nowadays, when you prompt ChatGPT for information not part of its training data, it will search the web to retrieve it, use it in context, and return an appropriate response. Grounding is when Large Language Models(LLMs) use domain-specific information and data to generate accurate and relevant output. This article will examine LLM grounding using the RAG technique.

Importance of LLM grounding

This section highlights the importance of LLM grounding. The importance of LLM grounding is listed below:

Reduce LLM Hallucinations.
Improve LLM precision and accuracy.
The LLM becomes adept at addressing complex issues quickly.
LLM becomes more capable of clarifying intricate issues and reducing confusion.

LLM grounding techniques

This section examines LLM grounding techniques. There are two broad categories of LLM grounding, namely:

Retrieval-Augumented Generation(RAG)
Fine-tuning.

This article focuses on the RAG technique.

RAG technique

This section focuses on how to implement the RAG technique for LLM grounding. The RAG technique starts by retrieving relevant information based on a query. The retrieved content with the prompt is then merged into the LLM context window to generate a relevant output.

The Implementation of the RAG technique starts with creating a vector representation of the external data through a process called embeddings. It is the process of converting data into vectors, long arrays of numbers that represent semantic meaning for a given sequence of data. Below is an embedding produced by the Ollama "nomic-embed-text" model for the text "Grounding improves LLM output".

[0.079886355,0.026696106,-0.2009385,-0.081955306,0.033845328,0.0026561292,0.030165939,0.013311965,-0.055660687,-0.048723537,0.014457284,0.027321639,0.029530374,0.02201595,0.013614955,0.057640318,0.03209041,-0.051196527,-0.017932769,-0.06712348
...
-0.02952636,-0.053060006,0.051573362,-0.0038687028,0.054432027,-0.0071464307,0.07941523,-0.0049896343,-0.013346551,-0.006801469,-0.02958884,-0.039702114,0.005442398,0.027762491,0.029064095,-0.024355555,0.01312534,0.046164576,-0.045630153,0.014882911,-0.031765144,0.049317453,-0.0023815103,-0.059432093,-0.03721353,-0.014398544,-0.021900289]

The vector can be stored in vector databases such as ChromaDB for later use.

There are LLMs trained to create embeddings. OpenAI has the following embedding models:

text-embedding-3-small
text-embedding-3-large
text-embedding-ada-002

Similarly, Ollama has the following embedding models:

nomic-embed-text
mxbai-embed-large
all-minilm

It must be noted that embeddings generated by Ollama LLMs cannot be used by OpenAI models and vice versa. This is because each platform produces vector embeddings with different dimensions. The dimensions for OpenAI LLMs are 1536, 3072 … and for Ollama, the vector dimensions are 768, 1024 …

To create an OpenAI vector embedding, you can use any of its models, as shown below:

from openai import OpenAI

client = OpenAI()

embedding = client.embeddings.create(
    model="text-embedding-3-small",
    input="Grounding Improves LLM output .",
    encoding_format="float",
)
print(embedding)

For Ollama, it can be done as follows, assuming you have an Ollama installation on your system:

import ollama
response = ollama.embed(model=”nomic-embed-text”, prompt="Grounding Improves LLM output")

The differences between the embedding models are performance, cost, and vector output size.

The next step is to retrieve the relevant part of the embeddings. You create an embedding for the user prompt, use it to retrieve content relevant to the user’s prompt, then pass both the content and the prompt to the LLM to generate a response, as shown below:

from openai import OpenAI

client = OpenAI()

response = client.responses.create(

    model="gpt-5-nano",

    input=f" You are an assistant, use this data {data} to this input {prompt}"

)

print(response.output_text)

Using Ollama.

import ollama

output = ollama.generate(
    model="llama2", prompt=f"Use this data: {data} to respond to this prompt: {input}"
)

print(output)

Data in the codes above refers to the content retrieved from the database using the user prompt embeddings.

LLM grounding use case:

Customer Service and Support: Question and Answer Chatbots
Legal Research: Quickly retrieving relevant case law and statutes from a large database.
Content creation and research
Code Assistant: Troubleshooting and fixing errors in code.
Medical Assistant: Generate medical insight and history of patients.

Conclusion

Grounding improves LLM output. It reduces hallucination, increasing accuracy and reducing confusion in LLM output. In this article, we have examined the RAG technique for grounding LLM. We examined how to use OpenAI and Ollama embedding models to create embeddings.

Smart Contract Fork Testing Using Foundry Cheatcodes

Eyitayo Itunu Babatope — Sun, 16 Jun 2024 04:42:16 +0000

Introduction

Testing is important in smart contract development due to the immutable nature of smart contracts. Testing helps identify and resolve potential security vulnerabilities in smart contracts. Safeguard against unauthorized access.

Sometimes smart contract developers must interact with real-world data that testnet cannot provide. Hence, there is a need for fork testing. In this article, readers will learn how to conduct fork-testing in a foundry development environment.

Content

Introduction
Prerequisites
Benefits of fork testing?
What are Foundry Cheatcodes?
Project Setup and Testing
Conclusion.

Prerequisites

This tutorial requires foundry installation.
Knowledge of Solidity programming and smart contract development.

Benefits of fork-testing

Fork testing mimics the production environment as much as possible. There is no need to use a testnet public faucet to get test coins for testing.

It allows developers to debug in an environment that is as close to the production as possible.
It gives developers access to real-time data such as the current state of the blockchain which testnet cannot provide since testnet operates in an isolated environment.
It gives developers unprecedented control over smart contracts. Developers can mint or transfer tokens like they own the token creation smart contract.
Developers can create blockchain addresses easily.

What are Foundry Cheatcodes?

According to Foundry Documentation, Forking cheatcodes allow developers to fork blockchain programmatically using solidity instead of CLI arguments. Forking cheat codes support multiple forks and each fork has a unique uint256 identifier. The developer must assign a unique identifier when the developer creates the fork. Forking cheatcodes execute each test in its own standalone EVM. Forking cheatcodes isolate tests from one another, and execute tests after the setUp function. It implies that a test in forking cheatcodes mode must have a setup function.

Project setup and testing

To demonstrate fork testing, we will create a savings smart contract. The contract will allow users to save, set a deadline for withdrawal, and allows users to withdraw when the deadline has elapsed.
Open a CLI terminal and run the command below to scaffold a foundry project. Name the project fork_testing.
forge init fork_testing.
Navigate to the src folder create a file and name it Savings.sol.
Open the Savings.sol file and create a Savings contract as shown below.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13; 

contract Savings {

 }

Create the under-listed variables and an event in the contract as shown below.

event Saver(address payer, uint256 amount);
mapping(address => uint256) public balances;
mapping(address => uint256) public tenor;
bool public openForWithdraw = false;
uint256 public contractBalance = address(this).balance;

The variable tenor maps the address of the saver to the duration in seconds the user wants to keep his token. The variable balance maps the address of a saver to the amount saved in the contract. The boolean variable openForWithdraw is set to false and does not allow the saver to withdraw before the tenor lapses. The contract will emit the Saver event when a user transfers or sends funds to the contract.

Next, add a receive () payable function that allows the contract to receive funds. The function will require the user to set a tenor before the user can send funds to the contract. The function will use the map balances to keep track of the funds sent by an address. On successful savings, the function emits the address and amount sent by a user. The receive() is as shown in the code below.

receive() external payable {
        require(tenor[msg.sender] > 0, "You must set a tenor before saving");
        balances[msg.sender] += msg.value;
        contractBalance = address(this).balance;
        emit Saver(msg.sender, msg.value);
    }

Next add two functions to the contract, a setTenor() and a getTenor() view function. The setTenor() allows the user to set the duration the user wants to keep the funds and getTenor() retrieves the duration the user wants to keep the funds in the contract. The implementation of the functions is shown below.

function setTenor(address saver, uint256 _tenor) public {
        tenor[saver] = block.timestamp + _tenor;
    }

function getTenor(address saver) public view returns (uint256) {
        return tenor[saver];
    }

Add a get balance() as shown below. The function returns the total funds received by the contract.

function getBalance() public view returns (uint256) {
        return address(this).balance;
    }

Next, add a view function getIndividualBalance() as shown below. The getIndividualBalance() returns the balance of the individual address.

function getIndividualBalances(
        address saver
    ) public view returns (uint256) {
        return balances[saver];
    }

Add a timeLeft() view function that returns the time left before the tenor lapses. The implementation is shown below.

function timeLeft(address saver) public view returns (uint256) {
        if (block.timestamp >= tenor[saver]) {
            return 0;
        } else {
            return tenor[saver] - block.timestamp;
        }
    }

Lastly add a withdraw function, that allows the user to withdraw their funds if the tenor has elapsed. The implementation is shown below.

 function withdraw(uint amount, address withdrawer) public {
        if (timeLeft(withdrawer) <= 0) {
            openForWithdraw = true;
        }
        require(openForWithdraw, "It is not yet time to withdraw");
        require(
            balances[withdrawer] >= amount,
            "Balance less than amount to withdraw"
        );
        balances[withdrawer] -= amount;
        (bool success, ) = withdrawer.call{value: amount}("");
        require(success, "Unable to withdraw fund");
    }

Below is the full code implementation of the Savings contract.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
contract Savings {
    event Saver(address payer, uint256 amount);
    mapping(address => uint256) public balances;
    mapping(address => uint256) public tenor;
    bool public openForWithdraw = false;
    uint256 public contractBalance = address(this).balance;

    // Collect funds in a payable `receive()` function and track individual `balances` with a mapping:
    // Add a `Saver(address,uint256, uint256, uint256)`
    receive() external payable {
        require(tenor[msg.sender] > 0, "You must set a tenor before saving");
        balances[msg.sender] += msg.value;
        contractBalance = address(this).balance;
        emit Saver(msg.sender, msg.value);
    }

    // Set the duration of time a user will save token in the contract.
    function setTenor(address saver, uint256 _tenor) public {
        tenor[saver] = block.timestamp + _tenor;
    }

    // Returns the duration of time a user is willing save funds in the contract.
    function getTenor(address saver) public view returns (uint256) {
        return tenor[saver];
    }

    // Returns the contract balance.
    function getBalance() public view returns (uint256) {
        return address(this).balance;
    }

    // Returns the balance saved in the contact by an address.
    function getIndividualBalances(
        address saver
    ) public view returns (uint256) {
        return balances[saver];
    }

    // Returns the time left before the tenor elapsed.
    function timeLeft(address saver) public view returns (uint256) {
        if (block.timestamp >= tenor[saver]) {
            return 0;
        } else {
            return tenor[saver] - block.timestamp;
        }
    }
    // Allows a user to withraw funds once the tenor has elapsed.
    function withdraw(uint amount, address withdrawer) public {
        if (timeLeft(withdrawer) <= 0) {
            openForWithdraw = true;
        }
        require(openForWithdraw, "It is not yet time to withdraw");
        require(
            balances[withdrawer] >= amount,
            "Balance less than amount to withdraw"
        );
        balances[withdrawer] -= amount;
        (bool success, ) = withdrawer.call{value: amount}("");
        require(success, "Unable to withdraw fund");
    }
}

Testing the Savings contract.

Open the test folder, create a .env file, and add a variable MAINET_RPC_URL. Copy and paste your mainnet RPC_URL as value as shown below.
MAINET_RPC_URL = ‘https://your_rpc_url’
Next, create a Savings.t.sol file. Open the file and specify the license and solidity compiler version. In the file, import the foundry Forge Standard Library, the Savings contract and forge standard output as shown below. Forge Standard Library is a collection of contracts that makes Test contracts easy to write and test. The forge-std/Test.sol contains the forge standard experience.

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;

//import dependencies
import "forge-std/Test.sol";
import "../src/Savings.sol";
import "forge-std/console.sol";

Add a test contract to the Savings.t.sol file. Let the test contract inherit from the Test.sol.

contract TestSavings is Test {

}

Add the variables listed below to the contract.

uint256 mainnetFork;
string MAINNET_RPC_URL = vm.envString("MAINNET_RPC_URL");
Savings public savings;

The variable mainnetFork will hold the fork's unique identifier, and the string MAINNET_RPC_URL holds the RPC_URL loaded from the .env file using cheatcodevm.envString(). The vm is an instance offorge cheatcodes.

Next, add receive() external payable{} to allow the test contract to receive funds. Add a setUp function to the contract, to create, select the mainnet fork and create an instance of the Savings contract as shown below.

 function setUp() public {
        mainnetFork = vm.createFork(MAINNET_RPC_URL);
        vm.selectFork(mainnetFork);
        savings = new Savings();
    }

In the code above, we used the cheatcodes vm.createFork(MAINNET_RPC_URL) to fork the Ethereum mainnet blockchain and create a unique uint256 identifier which we assigned to the variable mainnetFork. Next, we select the fork with vm.selectFork(mainnetFork).

Since forge cheatcodes isolate tests from one another, we will create six test functions listed below.

function testInitialBalance() public view {}: To test if the Savings contract initial balance is zero.
function testSavingsWithoutTenor() public{}: To test if a user can send funds to the Savings contract without a tenor. The test should revert if a user did not set a tenor before sending funds to the Savings contract.
function testSetTenor() public {}: The test expects the tenor to be greater than the current block.timestamp.
function testSavings() public{}: Once, the user sets a tenor, the test expects the user to be able to save.
function testWithdrawBeforeTime() public {}: The user should not be able to withdraw funds before the tenor elapses.
function testWithdrawAfterTime() public {}: The user should be able to withdraw funds after the tenor elapses. The full code implementation of the test contract is shown below.

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;

//import dependencies
import "forge-std/Test.sol";
import "../src/Savings.sol";
import "forge-std/console.sol";

//Test Contract
contract TestSavings is Test {
    uint256 mainnetFork;
    string MAINNET_RPC_URL = vm.envString("MAINNET_RPC_URL");
    Savings public savings;

    // Allow the test contract to receive funds.
    receive() external payable {}

    // Initial configuration.
    function setUp() public {
        mainnetFork = vm.createFork(MAINNET_RPC_URL);
        vm.selectFork(mainnetFork);
        savings = new Savings();
    }

    // The initial balance should be 0.
    function testInitialBalance() public view {
        assertLt(savings.getBalance(), 1);
    }

    // User should not be able to save without setting a tenor.
    function testSavingsWithoutTenor() public {
        vm.deal(address(this), 2 ether);
        vm.expectRevert();
        (bool sent, ) = address(savings).call{value: 1 ether}("");
        require(sent, "Failed to send Ether");
    }

    // User should be able to set tenor.
    function testSetTenor() public {
        savings.setTenor(address(this), 30);
        uint tenor = savings.getTenor(address(this));
        assertGt(tenor, block.timestamp);
    }

    // User should be able to save, if the user has set a tenor.
    function testSavings() public {
        savings.setTenor(address(this), 30);
        vm.deal(address(this), 2 ether);
        (bool sent, ) = address(savings).call{value: 1 ether}("");
        require(sent, "Failed to send Ether");
        assertGt(savings.getIndividualBalances(address(this)), 0);
    }

    // User should not be able to with the tenor elapses.
    function testWithdrawBeforeTime() public {
        savings.setTenor(address(this), 30);
        vm.deal(address(this), 2 ether);
        (bool sent, ) = address(savings).call{value: 1 ether}("");
        console.log(sent);
        vm.expectRevert("It is not yet time to withdraw");
        savings.withdraw(0.5 ether, address(this));
    }

    // User should be able to withdraw after the tenor elapses.
    function testWithdrawAfterTime() public {
        savings.setTenor(address(this), 0);
        vm.deal(address(this), 1 ether);
        (bool sent, ) = address(savings).call{value: 1 ether}("");
        console.log(sent);
        uint256 oldBalance = address(this).balance;
        savings.withdraw(0.5 ether, address(this));
        uint256 newBalance = address(this).balance;
        assertGt(newBalance, oldBalance);
    }
}

In the testBalance() , we use the assertLt() to check if the contract balance is less than 1. The test should pass.

The testSavingsWithoutTenor() test if a user can save without setting a tenor. In the function, we retrieve the balance of the Savings contract with savings.getBalance() and assign the return value to the variable initial balance. Then we set the balance of the test contract to 2 ether using vm.deal(). We expect that when a user tries to send funds to the Savings contract without a tenor, the transaction should revert. We use vm.expectRevert() to handle the revert. Then, we send 1 ether to the Savings contract from the test contract using (bool sent, ) = address(savings).call{value: 1 ether}(""). Next, we retrieve the balance of the Savings contract and assign the return value to the variable newBalance. Then, we test if the new balance of the savings contract is equal to the initial balance using assertEq(). We expect the test to pass.

The function testSetTenor tests if a user can set the tenor for funds to be stored in the savings contract. We set the tenor using setTenor() of the Savings contract with the address of the test contract and the duration of 30 seconds. The test expects the tenor should be greater than the current block.timestamp.

The testSavingsWithTenor() tests if a user can save after the user sets a tenor. We set the tenor with the savings.setTenor to 30 seconds, set the balance of the test contract to 2 ether, then transfer 1 ether to the Savings contract. We retrieve the balance mapped to the test contract address in the Savings contract with the getIndividualBalances function. We expect the retrieved balance to be greater than 0.

The testWithdrawBeforeTime() tests if a user can withdraw funds before the tenor elapses. We send 1 ether to the savings contract, then try to withdraw 0.5 ether from the Savings contract to the test contract with savings.withdraw(0.5 ether, address(this)). We expect the transaction to revert.

The testWithdrawAfterTime() tests if a user can withdraw after the tenor has elapsed. We set the tenor to 0 seconds, retrieve the balance of the test contract and assign it to the variable oldBalance, then transfer 1 ether to the Savings contract, and withdraw 0.5 ether from the Savings contract. Thereafter, retrieve the balance of the test contract and assign the value to the variable newBalance. We expect that the newBalance should be greater than the oldBalance.

Run the tests with the command:
forge test
For trace result, run the command:
forge test -vvv
Or
forge test -vvvv

Conclusion

Testing is essential in smart contract development, it enables developers to discover errors, and security vulnerabilities in smart contracts before deployment. Once we deploy a smart contract, it becomes immutable. Fork testing is a way to test smart contracts in an environment that is as close to the production environment as possible. In this article, we have demonstrated how to carry out fork testing using Foundry cheatcodes. We have demonstrated how it is easy to fork an Ethereum mainnet and transfer ether from one contract to another without the need to use testnet faucet or tokens.

Like, Share, or Comment if you find this article interesting.

Video Streaming with MPEG-DASH?

Eyitayo Itunu Babatope — Tue, 17 Oct 2023 18:25:00 +0000

Introduction

MPEG-DASH is one of the most popular protocols for streaming media content over the internet. MPEG-DASH can download large files without causing bandwidth overuse or interruptions to video streaming. YouTube and Netflix, two major video streaming platforms use MPEG-DASH for video streaming. MPEG-DASH protocols adapt to the connection bandwidth of the user by switching from one bandwidth to another. In this post, the reader will learn about MPEG-DASH, how to encode media files using MPEG-DASH

MPEG-DASH
Dynamic Adaptive Streaming
Media Presentation Description
How to encode video files using MPEG-DASH Protocol?
How to Serve and Consume DASH Stream
Conclusion

MPEG-DASH

In a bid to have a unified protocol for streaming media content over the internet, Morning Picture Expert Group(MPEG) issued a call for proposals in 2009. In 2012, the group published a standard specification called Dynamic Adaptive Streaming over HTTP(MPEG-DASH).

MPEG-DASH is a streaming protocol. Its advantages over other streaming protocols are that, it is codec agnostic and supports multiplexed and un-multiplexed encoded contents. MPEG-DASH supports multiple Digital Rights Management and encryption of media contents.
According to MPEG-DASH 2012(1) specification guideline, MPEG-DASH has the following features.

Switching and selectable streams: the MPD provides adequate information to the client for selecting and switching between streams, e.g. selecting one audio stream from different languages, selecting video between different camera angles, selecting the subtitles from provided languages, switching between different bitrates of the same video camera dynamically.
Ad-insertion: Permits advertisement placement as a period between periods or segments between segments in both on-demand and live cases.
Compact manifest: the segment's address URLs can be signaled using a template scheme that produces a compact MPD. Fragmented manifest: Division of the MPD into multiple parts or some of its elements externally referenced, enabling downloading MPD in multiple steps.
Segments with variable durations: Variation of segment duration. With live streaming, the duration of the next segment can also be signaled with the delivery of current segment. Multiple base URLs: the same content can be available at multiple URLs, i.e. at different servers or CDNs, and the client can stream from any of them to maximize the available network bandwidth.
Clock drift control for live sessions: the UTC can be included with each segment to enable the client to control its clock drift.
Scalable Video Coding (SVC) and Multiview Video Coding (MVC) support: the MPD provides adequate information regarding the decoding dependencies between representations and is used for streaming any multi-layer coded streams such as SVC and MVC.
A flexible set of descriptors: for describing content rating, components roles, accessibility features, camera views, frame-packing, and audio channel configuration.
Subseting of adaptation sets into groups according to the content author's guidance.
Quality metrics for reporting the session experience: A set of well-defined quality metrics for the client to measure and report back to a reporting server.

MPEG-DASH streams Multimedia content by dividing the content into segments. To prevent buffering, MPEG-DASH will adjust the video quality of the stream according to the user's internet connection speed. MPEG-DASH utilizes Multimedia Presentation Description(MPD) to achieve dynamic adaptive streaming.

Dynamic Adaptive Streaming

Dynamic adaptive streaming requires a multiple bitrate of media content to be available on the server. For example, if we have a video file named match.mp4. Typically, this file will contain video, audio, text, and subtitles. To utilize the DASH protocol, we must have multiple bitrates of this file on the server. Let's say we encoded our match.mp4 at the following bitrate 100kb/s, 64kb/s, 24kb/s. After encoding, each alternative bitrate will be in chunks called segments, which are about 10s of multimedia content. Each segment contains approximately 100 Access Units. Also, an iframe-only bitstream with a low frame rate is available for streaming during trick play mode.

A client device starts streaming the first segment of match.mp4 at the highest bitrate of 100kb/s. While monitoring the network bandwidth, on completion of the first segment, if the device realizes the bandwidth is lower than 100kb/s, the device will start streaming at a lower bandwidth. If the bandwidth increases, the device streams at the highest bandwidth. When the user pauses the stream and rewind, the device streams the video in trick mode, playing the video in reverse order with muted audio until the user press play at the desired point. The device will resume streaming at the highest bitrate rate while monitoring the network bandwidth.

Multimedia dynamic streaming can stream 3D, video streams with subtitles and captions, ad insertion, and multiple camera view streaming. Dynamic streaming uses an MPD file to switch from one bitrate to another.

Media Presentation Description

MPD is an XML document that describes the characteristics of the multimedia content. For a DASH client to stream multimedia content, the client downloads the MPD file and parses the file. MPD files consist of one or more periods. A period is the interval between multimedia contents along the temporal axis. A period consists of multiple adaptation sets. An adaptation set contains information about one or more multimedia components and its alternative bitrate.

An adaptation set consists of representation: information about the encoded bitrate alternative of the same multimedia component. In an MPD file, rep-24.mp4, rep-64.mp4, and rep-100.mp4 are examples of alternative encoded bitrate representations of the same multimedia content.

<?xml version="1.0" encoding="utf-8"?>
<MPD xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns="urn:mpeg:dash:schema:mpd:2011"
    xmlns:xlink="http://www.w3.org/1999/xlink"
    xsi:schemaLocation="urn:mpeg:DASH:schema:MPD:2011 http://standards.iso.org/ittf/PubliclyAvailableStandards/MPEG-DASH_schema_files/DASH-MPD.xsd"
    profiles="urn:mpeg:dash:profile:isoff-live:2011"
    type="static"
    mediaPresentationDuration="PT8M59.9S"
    maxSegmentDuration="PT5.0S"
    minBufferTime="PT16.6S">
    <ProgramInformation>
    </ProgramInformation>
    <ServiceDescription id="0">
    </ServiceDescription>
    <Period id="0" start="PT0.0S">
        <AdaptationSet id="0" contentType="video" startWithSAP="1" segmentAlignment="true" bitstreamSwitching="true" frameRate="60000/1001" maxWidth="1280" maxHeight="720" par="16:9" lang="eng">
            <Representation id="0" mimeType="video/mp4" codecs="avc1.640020" bandwidth="800000" width="1280" height="720" sar="1:1">
                <SegmentTemplate timescale="60000" initialization="init-stream$RepresentationID$.m4s" media="chunk-stream$RepresentationID$-$Number%05d$.m4s" startNumber="61">
                    <SegmentTimeline>
                        <S t="30013984" d="500500" r="3" />
                        <S d="383383" />
                    </SegmentTimeline>
                </SegmentTemplate>
            </Representation>
            <Representation id="2" mimeType="video/mp4" codecs="avc1.640020" bandwidth="300000" width="1280" height="720" sar="1:1">
                <SegmentTemplate timescale="60000" initialization="init-stream$RepresentationID$.m4s" media="chunk-stream$RepresentationID$-$Number%05d$.m4s" startNumber="61">
                    <SegmentTimeline>
                        <S t="30013984" d="500500" r="3" />
                        <S d="383383" />
                    </SegmentTimeline>
                </SegmentTemplate>
            </Representation>
        </AdaptationSet>
        <AdaptationSet id="1" contentType="audio" startWithSAP="1" segmentAlignment="true" bitstreamSwitching="true" lang="eng">
            <Representation id="1" mimeType="audio/mp4" codecs="mp4a.40.2" bandwidth="128000" audioSamplingRate="48000">
                <AudioChannelConfiguration schemeIdUri="urn:mpeg:dash:23003:3:audio_channel_configuration:2011" value="2" />
                <SegmentTemplate timescale="48000" initialization="init-stream$RepresentationID$.m4s" media="chunk-stream$RepresentationID$-$Number%05d$.m4s" startNumber="104">
                    <SegmentTimeline>
                        <S t="24784896" d="240640" r="3" />
                        <S d="171509" />
                    </SegmentTimeline>
                </SegmentTemplate>
            </Representation>
            <Representation id="3" mimeType="audio/mp4" codecs="mp4a.40.2" bandwidth="128000" audioSamplingRate="48000">
                <AudioChannelConfiguration schemeIdUri="urn:mpeg:dash:23003:3:audio_channel_configuration:2011" value="2" />
                <SegmentTemplate timescale="48000" initialization="init-stream$RepresentationID$.m4s" media="chunk-stream$RepresentationID$-$Number%05d$.m4s" startNumber="104">
                    <SegmentTimeline>
                        <S t="24784896" d="240640" r="3" />
                        <S d="171509" />
                    </SegmentTimeline>
                </SegmentTemplate>
            </Representation>
        </AdaptationSet>
    </Period>
</MPD>

A representation contains information about one or more segments, the actual chunks of a media file. The segment contains the URI of the media file on the server and the start period. A device will use the URI to download the media segment with the HTTPS GET method.

How to encode video files using MPEG-DASH Protocol?

To encode our video file, we will use FFmpeg, a software for encoding multimedia content. However, other software like Handshake will work.

Download and install FFmpeg
To install FFmpeg on Windows, download the latest build here

https://www.gyan.dev/ffmpeg/builds

Extract the zip file and copy it to C://. Open the Command Line as an administrator. Copy the following code and press enter.

 setx /m PATH "C:\ffmpeg\bin;%PATH%"

Restart system. To confirm installation, run ffmpeg -h. The command will output a series of ffmpeg commands to the screen.

After installation, create a folder and give it a name of your choice. In this case, we named the folder videodash. Copy your video into the videodash folder.Section 4.9 of FFmpeg documentation specified how to use FFmpeg to encode and create MPD files. Open the command line, cd into the videodash folder, copy, and run the code below.

ffmpeg -re -i culture.MOV -map 0 -map 0 -c:a aac -c:v libx264 -b:v:0 800k -b:v:1 300k -s:v:1 320x170 -profile:v:1 baseline -profile:v:0 main -bf 1 -keyint_min 120 -g 120 -sc_threshold 0 -b_strategy 0 -ar:a:1 22050 -use_timeline 1 -use_template 1 -window_size 5 -adaptation_sets "id=0,streams=v id=1,streams=a" -f dash output.mpd

Code Explanation
You execute ffmpeg commands with sets of options and parameters. The above code is for dash streaming.

-re read input at native frame rate
-i indicate input stream
-map 0 select the first audio stream
-map 0 select the first video stream
-c:a audio codec aac
-c:v video codec libx264
-b:v 0 set the bitrate of the first video stream to 800k
-b:v 1 set the bitrate of the second video stream to 300k
-s✌️1 set the size of the second video stream to 320 x 270
-profile:v 1 use baseline as the profile for the second video
-profile:v 0 use main as the profile of the first video stream
-bf 1 set the bufsize to 1
-keyint-min
-h gulp size 120
-sc_threshshold
-b_strategy
-ar🅰️1 audio rate of the second audio stream is 22050
-use_timeline enables the use of Segment templates
-use_template enables the use of Segment templates
-window_size sets the number of segments in the manifest to 5.
-adaptation_sets assign streams to adaptation sets video stream to id 0 and audio to id 1
-f specify the wrapper for the output, in this case, dash.

The output file is out.mpd. You can give the output file any name of your choice. For a better understanding of ffmpeg options, Read the documentation. In the videodash folder, we will have a series of chunk files with m4s extension and an MPD file.

How to Serve and Consume DASH Stream.

Video streamed using MPEG-DASH can only be viewed using DASH Client. There is a JavaScript implementation of the DASH client dash.js which you can download or you can use CDN.
Copy the videodash folder to your localhost or remote server.
In your server folder, create a html file and name it video.html then copy the code below

<!doctype html>
<html>
    <head>
        <title>Dash.js Rocks</title>
        <style>
            video {
                width: 640px;
                height: 360px;
            }
        </style>
    </head>
    <body>
        <div>
            <video id="videoPlayer" controls></video>
        </div>
        <script src="yourPathToDash/dash.all.min.js"></script>
        <script>
            (function(){
                var url = "https://dash.akamaized.net/envivio/EnvivioDash3/manifest.mpd";
                var player = dashjs.MediaPlayer().create();
                player.initialize(document.querySelector("#videoPlayer"), url, true);
            })();
        </script>
    </body>
</html>

Go to your browser and input the URL of your server.

Conclusion

Before now there was no interoperability between commercial multi-media streaming platforms. Each commercial platform has its manifest, content format, and protocols but nowadays, media contents over the internet are available to a wide range of devices such as mobile phones, PCs, laptops, consoles, and TVs using the same manifest, protocol, and content format. This is due to the advent of protocols like MPEG-DASH. In this post, we examined the fundamentals of MPEG-DASH, how to encode media files using MPEG-DASH protocol, and how to serve MPEG-DASH encoded media files.

References

ISO/IEC 23009-1:2012(E). Information technology — Dynamic adaptive streaming over HTTP (DASH) — Part 1: Media presentation description and segment formats

Develop a Video Chat App with WebRTC, Socket.IO, Express and React.

Eyitayo Itunu Babatope — Fri, 01 Sep 2023 03:49:43 +0000

INTRODUCTION

In 2013, Google developed Web Real-Time Communication (WebRTC) technology for peer-to-peer communication. WebRTC enables web browsers to capture audio and video, exchange data, and conduct teleconferencing without plugins or intermediaries. WebRTC achieves these through APIs and protocols that interact with one another. WebRTC media streaming, when used with SocKet.IO, will produce an application that streams media and exchanges data instantly.

Socket.IO is a library that provides low latency bi-directional communication between client and server. Socket.IO is built on WebSocket, a communication protocol that provides full-duplex and low-latency communication between the server and browser. In this article, readers will learn how to build a video chat application using WebRTC and Socket.IO. This article is for web developers who wish to develop web applications that can stream media between two computers in real time without installing any plugins.

Prerequisite

This article assumes the reader is familiar with setting up an Express NodeJS server, Socket.IO, a working knowledge of React.js, JavaScript, and CSS. We created the UI of the video chat using React and vanilla CSS, while we created the signaling server using Express and Socket.IO.

WebRTC Media Streaming Concept
Advantages of WebRTC
Drawbacks of WebRTC
Socket.IO Concept
Advantages of Socket.IO
Drawbacks of Socket.IO
Socket.IO Signaling Server setup
WebRTC Setup
Video Chat UI
Conclusion

WebRTC Media Streaming Concept

At the top level, WebRTC media streaming occurs in four phases:

Offer.
Signaling.
Answer.
Data exchange between two browsers.

WebRTC uses Session Description Protocol(SDP) to create an offer and answer mechanism. SDP provides a profile of your device to other users trying to connect to your device. SDP is a text-based protocol, that contains information about the type of media stream, codec, transport layer, and other information.

To make an offer, a WebRTC peer connection object is created and takes an optional parameter. The optional parameter contains the configuration for the Interactive Connectivity Establishment Protocol(ICE) servers. ICE finds the shortest path for media to travel between two peers. ICE helps devices connect across the internet, and overcome NAT(Network Address Translator), firewalls, and anything that can hinder peer-to-peer communication.

For devices to communicate over the internet, they utilize IP addresses and port numbers. However, most devices operate behind a firewall or NAT that hides their IP addresses, preventing peer-to-peer communication. During ICE gatherings, ICE allows devices to exchange potential network addresses called ICE candidates. The candidates contain IP addresses, port numbers, and transport protocols. A computer device can have multiple ICE candidates. ICE protocol then decides the best network path for a session using the information provided by ICE candidates. Devices exchange ICE candidates using the ICE servers. There are two types of ICE servers

1 Session Traversal Utilities for NATS(STUN)
2 Traversal Using Relay around NATS(TURN)

Turn servers are used in a more restrictive network when both peers are behind a firewall, NAT, or symmetric NAT that prevents direct communication between devices.

Advantages of WebRTC

High communication quality
Automatically adjusts to any type of connection.
Automatic microphone sensitivity (AGC) control for all connections.
All connections are protected (HTTPS) and encrypted (SRTP).
WebRTC application works on desktop or mobile operating systems provided it has browser support.

Drawbacks of WebRTC

Audio and video mixing to run group audio or video conferences.
WebRTC solutions are incompatible with each other.
Vendors decide on signaling, messaging, file transfer, conference scheduling, etc. No uniformity in signaling or messaging

Socket.IO concepts

Socket.IO is a library that facilitates bi-directional low-latency communication between the client and the server. The communication between the client and server is event-based. The client and the server emit and listen to events. To use Socket.IO, the client and the server library must be installed on the client and server. Socket.IO is used for applications that depend on real-time data like the stock market, weather, and chat applications. Socket.IO is implemented in most major languages, Python, Java, and C++. In this article, we used JavaScript implementation for both the client and server side.

Advantages of Socket.IO

Multiple namespace streams down a single engine.io session.
Encoding of messages as named JSON and binary events.
Acknowledgment callbacks per event

Drawbacks of Socket.IO

Socket.IO doesn't provide end-to-end encryption.
Socket.IO does not guarantee exact-once messaging semantics. By default, an at-most-once guarantee is provided.

SOCKET.IO Signaling server setup

Create a directory and name it videoserver or any name of your choice.

mkdir videoserver
cd video server
npm init

The npm init directive will create a package.json file in our folder.
Install Express and Socket.IO packages.

npm install express
npm install socket.io

Create a file in the root of the directory and name it server.js. Open the server.js file, and import the necessary packages. Create the server as shown in the code below.

require("dotenv").config();
const express = require("express");
const cors = require("cors");
const app = express();
app.use(cors());
const server = require("http").createServer(app);
const io = require("socket.io")(server, {
  cors: { origin: "http://127.0.0.1/:5173" },
});
const PORT = 3000 || process.env.PORT;
io.on("connection", (socket) => {
  console.log("Connected");

  socket.on("message", (message) => {
    socket.broadcast.emit("message", message);
  });

  socket.on("disconnect", () => {
    console.log("Disconnected");
  });
});

function error(err, req, res, next) {
  // log it
  if (!test) console.error(err.stack);

  // respond with 500 "Internal Server Error".
  res.status(500);
  res.send("Internal Server Error");
}
app.use(error);
server.listen(3000, () => {
  console.log("listening on Port 3000");
});

In the script above, the require statements load the needed packages by the script. The script uses the Cross Origin Resource Sharing (CORS) package to allow cross-origin server requests. The code snippet below creates a Socket.IO session.

const io = require("socket.io")(server, {
  cors: { origin: "http://127.0.0.1/:5173" },
});

Socket.IO permits event-based communication between client and server. The code below shows how to emit an event with Socket.IO.

socket.emit("custom-named-event", data)

The code below shows how to listen to an event.

socket.on("custom-named-event", (data)=>{
//process the data 
})

The script listens to a client connection with io.on. When a Socket.IO client connects to the server, it will log 'Connected' to the console. The script uses the function error to handle the error that occurs during the script execution.

WebRTC Setup

We mentioned earlier that peer-to-peer connections in WebRTC occur through an offer-and-answer mechanism. A peer(caller) creates an instance of the RTCPeerConnection object and passes to it, an optional configuration object that contains the iceServers. The RTCPeerConnection creates an offer and sets the offer as its local session description, emits the offer to the remote peer through the signaling server. The caller uses the browser API getUserMedia to access the device media. Then attach the media stream and ice candidates to the RTCPeerConnection.

The remote peer(callee) will also create an instance of the RTC peer connection. When the callee receives an offer, it will set its remote session description to the offer, then create an answer, and set the answer as its local session description. The callee will send the answer to the caller through the signaling server. The callee would also attach its media stream and ice candidate to the peer connection.

The connection between the caller and callee can only take place after they have both exchanged ice candidates. We mentioned before that ice candidates are potential network addresses that peers can use to communicate with one another. The caller would send its ice candidate to the callee through the signaling server and listen for the ice candidate of the callee, when the caller receives the ice candidate of the callee, it will add it to the RTCPeerConnection. The callee would also repeat this process.

We implemented the offer and answer mechanism in the code below.

import { io } from "socket.io-client";
import { useRef, useEffect, useState } from "react";
import { FiVideo, FiVideoOff, FiMic, FiMicOff } from "react-icons/fi";

const configuration = {
  iceServers: [
    {
      urls: ["stun:stun1.l.google.com:19302", "stun:stun2.l.google.com:19302"],
    },
  ],
  iceCandidatePoolSize: 10,
};
const socket = io("http://localhost:3000", { transports: ["websocket"] });

let pc;
let localStream;
let startButton;
let hangupButton;
let muteAudButton;
let remoteVideo;
let localVideo;
socket.on("message", (e) => {
  if (!localStream) {
    console.log("not ready yet");
    return;
  }
  switch (e.type) {
    case "offer":
      handleOffer(e);
      break;
    case "answer":
      handleAnswer(e);
      break;
    case "candidate":
      handleCandidate(e);
      break;
    case "ready":
      // A second tab joined. This tab will initiate a call unless in a call already.
      if (pc) {
        console.log("already in call, ignoring");
        return;
      }
      makeCall();
      break;
    case "bye":
      if (pc) {
        hangup();
      }
      break;
    default:
      console.log("unhandled", e);
      break;
  }
});

async function makeCall() {
  try {
    pc = new RTCPeerConnection(configuration);
    pc.onicecandidate = (e) => {
      const message = {
        type: "candidate",
        candidate: null,
      };
      if (e.candidate) {
        message.candidate = e.candidate.candidate;
        message.sdpMid = e.candidate.sdpMid;
        message.sdpMLineIndex = e.candidate.sdpMLineIndex;
      }
      socket.emit("message", message);
    };
    pc.ontrack = (e) => (remoteVideo.current.srcObject = e.streams[0]);
    localStream.getTracks().forEach((track) => pc.addTrack(track, localStream));
    const offer = await pc.createOffer();
    socket.emit("message", { type: "offer", sdp: offer.sdp });
    await pc.setLocalDescription(offer);
  } catch (e) {
    console.log(e);
  }
}

async function handleOffer(offer) {
  if (pc) {
    console.error("existing peerconnection");
    return;
  }
  try {
    pc = new RTCPeerConnection(configuration);
    pc.onicecandidate = (e) => {
      const message = {
        type: "candidate",
        candidate: null,
      };
      if (e.candidate) {
        message.candidate = e.candidate.candidate;
        message.sdpMid = e.candidate.sdpMid;
        message.sdpMLineIndex = e.candidate.sdpMLineIndex;
      }
      socket.emit("message", message);
    };
    pc.ontrack = (e) => (remoteVideo.current.srcObject = e.streams[0]);
    localStream.getTracks().forEach((track) => pc.addTrack(track, localStream));
    await pc.setRemoteDescription(offer);

    const answer = await pc.createAnswer();
    socket.emit("message", { type: "answer", sdp: answer.sdp });
    await pc.setLocalDescription(answer);
  } catch (e) {
    console.log(e);
  }
}

async function handleAnswer(answer) {
  if (!pc) {
    console.error("no peerconnection");
    return;
  }
  try {
    await pc.setRemoteDescription(answer);
  } catch (e) {
    console.log(e);
  }
}

async function handleCandidate(candidate) {
  try {
    if (!pc) {
      console.error("no peerconnection");
      return;
    }
    if (!candidate) {
      await pc.addIceCandidate(null);
    } else {
      await pc.addIceCandidate(candidate);
    }
  } catch (e) {
    console.log(e);
  }
}
async function hangup() {
  if (pc) {
    pc.close();
    pc = null;
  }
  localStream.getTracks().forEach((track) => track.stop());
  localStream = null;
  startButton.current.disabled = false;
  hangupButton.current.disabled = true;
  muteAudButton.current.disabled = true;
}

function App() {
  startButton = useRef(null);
  hangupButton = useRef(null);
  muteAudButton = useRef(null);
  localVideo = useRef(null);
  remoteVideo = useRef(null);
  useEffect(() => {
    hangupButton.current.disabled = true;
    muteAudButton.current.disabled = true;
  }, []);
  const [audiostate, setAudio] = useState(false);

  const startB = async () => {
    try {
      localStream = await navigator.mediaDevices.getUserMedia({
        video: true,
        audio: { echoCancellation: true },
      });
      localVideo.current.srcObject = localStream;
    } catch (err) {
      console.log(err);
    }

    startButton.current.disabled = true;
    hangupButton.current.disabled = false;
    muteAudButton.current.disabled = false;

    socket.emit("message", { type: "ready" });
  };

  const hangB = async () => {
    hangup();
    socket.emit("message", { type: "bye" });
  };

  function muteAudio() {
    if (audiostate) {
      localVideo.current.muted = true;
      setAudio(false);
    } else {
      localVideo.current.muted = false;
      setAudio(true);
    }
  }

  return (
    <>
      <main className="container  ">
        <div className="video bg-main">
          <video
            ref={localVideo}
            className="video-item"
            autoPlay
            playsInline
            src=" "
          ></video>
          <video
            ref={remoteVideo}
            className="video-item"
            autoPlay
            playsInline
            src=" "
          ></video>
        </div>

        <div className="btn">
          <button
            className="btn-item btn-start"
            ref={startButton}
            onClick={startB}
          >
            <FiVideo />
          </button>
          <button
            className="btn-item btn-end"
            ref={hangupButton}
            onClick={hangB}
          >
            <FiVideoOff />
          </button>
          <button
            className="btn-item btn-start"
            ref={muteAudButton}
            onClick={muteAudio}
          >
            {audiostate ? <FiMic /> : <FiMicOff />}
          </button>
        </div>
      </main>
    </>
  );
}

export default App

In the script above, we initialized a variable named configuration and assigned it an object with two fields, iceServers, and iceCandidatePoolSize. The value of the iceServers field is an array that contains the URL of the ice servers. Next, we instantiated a Socket.IO client and assigned it to the variable socket. The instance of the Socket.IO client contains two parameters, the URL of server-side Socket.IO and the transport protocol to use. Then, we declared seven global variables without assigning any value to them.

The instance of the Socket.IO client listens to a message event. On receiving a message event, the event will be passed through a switch block to handle a specific type of event. The offer and answer were implemented through five async functions:

makeCall
handleOffer
handleAnswer
handleCandidate
hangUp

Video App UI

We used React.js to create the UI of the video chat app. We created a component named App. To start a video call, click on the phone icon. This will fire the browser API navigator.mediaDevices.getUserMedia({video: true, audio:{'echoCancellation':true}}) The stream from the camera will be seen in the video element of the App component. Open another tab in the browser, and type the URL of the React App, you will see two streams of videos. One local and one remote.

Below are the Cascading Style Sheets(CSS) and HTML for the UI

.bg-body {
  background-color: #332e33;
}

.container {
  display: flex;
  flex-direction: column;
  gap: 5px;
  padding: 10px;
}
.col-container {
  display: flex;
  flex-direction: column;
  width: inherit;
}
.label-text {
  color: #fff;
  text-align: center;
  font-size: 20px;
}
.btn-start {
  background-color: #0ced23;
}
.btn-end {
  background-color: rgb(225, 5, 5);
}
.btn {
  display: flex;
  flex-direction: row;
  justify-content: center;
  column-gap: 20px;
  margin-top: 10px;
}
.btn-item {
  width: 50px;
  height: 50px;
  color: #fff;
  border-radius: 50%;
}
.video {
  display: flex;
  flex-direction: column;
  justify-content: center;
  align-items: center;
  row-gap: 10px;
}
.video-item {
  width: 90%;
  height: 250px;
  border: 2px solid #fff;
  border-radius: 10px;
  margin: 10px auto;
}
@media only screen and (min-width: 800px) {
  .container {
    margin-top: 30px;
  }
  .video {
    display: flex;
    flex-direction: row;
    column-gap: 0.5%;
    justify-content: center;
  }
  .video-item {
    width: 40%;
    height: 400px;
  }
  .btn-item {
    width: 80px;
    height: 80px;
    color: #fff;
    border-radius: 50%;
  }
}

<!doctype html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <link rel="stylesheet" href="/style.css" />
    <title>Video Chat</title>
  </head>
  <body class="bg-body">
    <div id="root"></div>
    <script type="module" src="/src/main.jsx"></script>
  </body>
</html>

Conclusion

In this article, we explained WebRTC, and Socket.IO concepts and how to set them up to create a Video Chat App. Also, we discussed the advantages and disadvantages of using WebRTC for video chat applications.

Like, Share, or Comment if you find this article interesting.

Toggle Password Visibility Using React useRef

Eyitayo Itunu Babatope — Fri, 04 Aug 2023 10:41:59 +0000

Introduction

One way to manipulate Document Object Model(DOM) without triggering a re-render of the component in React is to use the useRef hook. In this article, I will use the ref hook to toggle password input visibility.

This article is for React beginner developers with a basic understanding of the React library. The reader will learn how to toggle password field visibility using useRef.

Outline

Understanding useRef
Application of useRef
Toggle password Demo
Conclusion

Understanding useRef

React documentation defines useRef as a hook that lets you reference a value not needed for rendering. It is a built-in hook used for accessing the DOM. It does not trigger a re-render of the component. UseRef is a top-level component. You can access the value held by useRef using its current property.

Application of useRef


import React,{useRef} from 'react';

function TogglePassword(){

    const inputRef= useRef(initialValue)

}

In the above code example, I imported useRef from React and initialized it with an initial value. The value can be string, int, or object. To access the useRef value, I used its current property as shown below.

const refValue= inputRef.current

Toggle password Demo

I used uesRef to access the DOM to achieve the toggle password effect. In the code example below, I set the initial value of useRef to null.

import React, { useRef, useState } from "react";
import { FaEyeSlash, FaEye } from "react-icons/fa";
function TogglePassword() {
  const inputref = useRef(null);
  const [iconState, setIcon] = useState(false);
  const handleClick = () => {
    const inputattr = inputref.current.getAttribute("type");
    inputattr === "password"
      ? inputref.current.setAttribute("type", "text")
      : inputref.current.setAttribute("type", "password");
    iconState ? setIcon(false) : setIcon(true);
  };
  let icon;
  if (iconState) {
    icon = <FaEyeSlash />;
  } else {
    icon = <FaEye />;
  }
  return (
    <>
      <div>
        <p>Email</p>
        <input type="text" id="email" />
      </div>
      <div>
        <p>Password</p>
        <input ref={inputref} type="password" id="pwd" />

        <span onClick={handleClick}>{icon}</span>
      </div>
    </>
  );
}

export default TogglePassword;

In the code above, I initialized the iconState to false using the useState hook to track password visibility. I created a handleClick function to toggle password visibility by listening to a click event on the eye icon. In the JSX of the togglePassword component, I used inputRef to hold the reference to the password input. Next, I used the inputRef.current property to access the input type attribute. If the input type attribute was password, I set the type to 'text' and vice versa using the ternary operator. Then, I toggled iconState to true or false. Next, I declared a variable icon and was assigned an eye component or eye slash component depending on the iconState.

Conclusion

In the article, I demonstrated the usage of useRef and showed how it can access the DOM. Now, the readers should have gained a better understanding of useRef and how to use it to access the DOM.

Find this article educative, comment, like, and share.

React Hooks Made Easy

Eyitayo Itunu Babatope — Wed, 19 Jul 2023 07:18:17 +0000

Introduction:

React Hooks allow functional components to use React features such as state and life cycle methods. Functional components use hooks to maintain state, fetch data from an external source, cache results of an expensive calculation, and receive data from distant parent components without passing it as props. Knowing which React hooks to use can be tricky. In two articles series, we will look at each of the React Hooks and demonstrate their usage with code examples.

These two articles series are for React developers who wish to better understand React hooks. The article assumes the reader has basic knowledge of React, functional components, lifecycle methods, and how to include React library in a project.

In this article, the reader will learn about

Rules for hooks
How to use hooks
Categories of Built in hooks
Usage of hooks

Rules for Hooks

Hooks are call within a functional component.
Hooks are call at the top level of a component.
It cannot be conditional
Hooks begin with the keyword use.

How to use Hooks in an application

To use hooks in an application, we import the hooks using the keyword import.

import {useState} from "react"

In the above example, we imported the useState from React. We can import more than one hooks. See the example below.

import {useState, useEffect} from "react"

React comes with built-in hooks. Also, we can customize hooks to meet specific requirements.

React Built-Hooks are categorize into the following groups:
1)State Hooks
2) Effect Hooks
3) Context Hooks
4) Performance Hooks
5) Other Hooks

React State Hooks

State in react is a built-in react object that stores data or value of a property. State let component remember user input between re-render. When the value of a property changes, react re-renders the component.
useState and useReducer are two hooks that manage the state in React.

React useState

useState is a react hook that updates or sets the value of a property directly. The useState returns an array of two values. The current state and a function that sets or updates the current state.

1 import React,{useState} from 'react';
2 function MyText(){
3 const [myText, setText]=useState('first Text');
4 const handleSubmit=(event)=>{
5    event.preventDefault();
6    const textForm=document.forms['textForm']['mytext'].value
7   setText(textForm)
8 }
9 return(
10    <>
11    <div>{myText}</div>
12    <form name="textForm" onSubmit={handleSubmit}>
13        <textarea name="mytext"  cols={20} rows={10} />
14        <button type="submit">Click Me</button>
15    </form>
16    </>


17 )
18 }
19 export default MyText;

Line 1: We imported useState.
Line 2: We created a react functional component called MyDetails.
Line 3: We initialized useState with a string and deconstructed the array returned by useState with variable text and function setText.
Line 4: We declared a function to handle the form submission.
Line 5: We called the event.preventDefault function to prevent default form propagation.
Line 6: We assigned the value of the textarea element to the variable textForm.
Line 7: Called setText to set the value of myText.
Line 9: Return JSX of MyText component.

React useState hook can be initialized with an empty string, an object, or an array. See the code example below.



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

2 function MyDetails(){
3 const [myDetails, setMyDetails]=useState({'firstname':"",'lastname':' ','age':0});
4 const handleSubmit=(event)=>{
5    event.preventDefault();
6    const fname=document.forms['detailsForm']['fname'].value
7    const lname=document.forms['detailsForm']['lname'].value
8    const age=document.forms['detailsForm']['age'].value
9    setMyDetails({firstname:fname,
10    lastname:lname,
11    age: age    })
12 }
13 return(
14    <>

15    <form name="detailsForm" onSubmit={handleSubmit}>
16       <label>Firstname</label>
17        <input type='text' name='fname' />
18        <label>Lastname</label>
19        <input type='text' name='lname' />
20       <label>Age</label>
21        <input type='number' name='age' min='1' max='100'/>

22        <button type="submit">Click Me</button>
23    </form>
24    <ul>
25        {Object.entries(myDetails).map(([index,element]) => {
26          return (<li key={element}>{index}:{element}</li>)
27        })
28        }
29    </ul>
30    </>


31 )
32 }
33 export default MyDetails;

Line 3: We initialized useState with an object with firstname, lastname, and age as properties.

Line 4: We declared the handleSubmit function with an event argument.
Lines 6,7,8: We assigned the values of the input fields to variables.
Line 8: We called the setMyDetails to set the value of the properties of MyDetails.
Line 13: It rendered JSX of the MyDetails component.
Line 25: We called the Object.entries function to transform myDetails into an array of key and value pairs and iterated through the returned array with the array.map function.

useReducer

useReducer sets or updates state but the logic to update the state is in another function called reducer.
useReducer takes three arguments: the reducer function, the initial argument, and an init function(optional). The init function returns the initial state. If it is not specified, it defaults to the initial argument. The useReducer returns an array of two values: the current state and a dispatch function that lets you update the current state to a new value.

1 import React,{useReducer} from 'react';
2 function reducer(jobDescription,action){

3   switch(action.type){
4.      case "janitor":
      5 return{category: action.type}
6       case "manager":
        7 return{category: action.type}
8       case "secretary":
        9 return{category: action.type}
10       default:
          11 return " ";
    }

}
12 const initialArg={category:""}
13 function Employee(){
14 const [jobDescription, dispatch]= useReducer(reducer,initialArg);

15 return(
    <>
16   <select name='jobs' onChange={(event)=>{
         dispatch({type:event.target.value})
    }}>
17        <option value=" "> </option>
18        <option value="janitor">Janitor</option>
19       <option value="secretary">Secretary</option>
20        <option value="manager">Manager</option>
    </select>
21   <div>Your job description is {jobDescription.category}</div>
    </>


)
}
22 export default Employee;

Line 2: We declared a reducer function with two arguments; jobDescription(state) and action
Line 3-11: We passed action.type through a switch block, each case set the category and returned the updated category.
Line 12: We declared a variable initial argument and initialized it with an object that has a category field with an empty value.
Line 13: We declared an Employee component.
Line 14: We called a useReducer hook with two arguments; reducer function and intialArg. The useReducer returned an array of two values which we deconstructed into variable jobDescription(state) and a dispatch function.
Line 16: We used the HTML select tag to create four options field, with an onChange event listener. Whenever there is a change in the selected value, the dispatch function will be called inside the event listener.
Line 17-20: The different option.
Line 21: We rendered the current jobDescription(state).

Conclusion:

In part 1 of react hooks, we defined hooks, enumerated the rules for hooks, and mentioned various types of hooks. We demonstrated how to use useState and useReducer hooks with code examples. In part two of react hooks, we will discuss other react hooks.

Test Driven Development in NodeJS

Eyitayo Itunu Babatope — Fri, 17 Feb 2023 18:34:27 +0000

Introduction

Testing in software is the step wise process that ensures your code does what it was written to do. A typical programmer's work flow is to come up with an algorithm, write the code, and run the code. If the program runs without an error, it is code well written. If otherwise, the programmer tries to fix the error using the error message as a guide. Then, run the program again, hoping the error has been fixed. Sometimes the error get fixed at the first attempt and sometimes it takes many attempt.

For few lines of code, this method of testing will do but as application scales, this method of testing becomes tedious and time-consuming. Hence, the need for automated testing. Though test-driven development might sound esoteric, something for the senior developers. In reality, testing can be automated using testing frameworks such as mocha and implemented with few lines of code.

Mocha is a popular JavaScript framework that organizes our tests and runs them for us. In this post, mocha framework will be used to organize the test and assert module of Nodejs will be used to compare test values.

Prerequisite: JavaScript, Nodejs.
Objective: To gain knowledge about using mocha testing framework.

Step 1: Install mocha using
npm install mocha -save
in your package.json change the test field to
"test":" mocha test.js"

In the root folder, create a test.js file.
There are two key functions in mocha

describe(): it helps group similar tests together.
it(): contains test code, this is where we run our test code. Other functions are the hooks, such as
before()
beforeEach()
after()
afterEach() Read more about mocha Mocha Framework here

The above are hooks you run before or after the test function. The implementation is shown in the example below. The before and after() hooks run once, while beforeEach and afterEach run before and after every it() .

Open the test.js file and import the assert module and any other module needed. See the example below.

import assert from "assert/strict";
import { describe } from "node:test";
import { Student } from "../model/schema.js";
import { connectToDb,conClose } from "../model/connection.js";

describe('CRUD test',function(){

before(function(){
 connectToDb()
})
it('document should save without an error', function(done){
    const result=  new Student({email:"eyitayo@yahoo.com",pwd:"Sep215"})
    result.save(done)

  })
it('collection should return length greater than 0',async function(){
  const result= await Student.find({})
  assert.notStrictEqual(result.length, 0)

})
it('document should update without an error', async function( ){
    const query= await Student.updateOne({email:"eyitt@yahoo.com"},{firstname:'eyitayo',lastname:'itunu',gender:'male'})
    const result= await Student.findOne({email:'eyitayo@yahoo.com'})
    assert.strictEqual(result.lastname,'itunu')

  })
after(function(){
    conClose()
})
})

In the above example, the describe() has two parameters: a string that describes the test and a callback function. Inside the callback function is it(). It has two parameters: a string that describes the outcome and a callback function that contains the test code. The assert strict function is used to compare test values. Other assert functions are

assert.deepEqual()
assert.deepStrictEqual()
assert.notDeepEqual()
assert.notDeepStrictEqual()
assert.notEqual()

Read more about [assert module]( https://github.com/nodejs/node/blob/v19.0.1/lib/assert.js

To run the test, go to the terminal and type npm test, test result is shown below.

> lmsnj@1.0.0 test
> mocha test/test.js

# Subtest: CRUD test
ok 1 - CRUD test
  ---
  duration_ms: 0.0530164
  ...



connected to MongoDb successfully
  1) document should save without an error
  ✔ collection should return length greater than 0 (350ms)
  ✔ document should update without an error (1713ms)

  2 passing (5s)
  1 failing

  1) document should save without an error:
     Error: Timeout of 2000ms exceeded. For async tests and hooks, ensure "done()" is called; if returning a Promise, ensure it resolves. (C:\Users\USER\lmsnj\test\test.js)
      at listOnTimeout (node:internal/timers:559:17)
      at processTimers (node:internal/timers:502:7)



1..1
# tests 1
# pass 1
# fail 0
# cancelled 0
# skipped 0
# todo 0
# duration_ms 38.0393548

The first test failed, while the other two passed and were marked accordingly.

Finally
Testing is an important aspect of software development. It ensures that the code does what it was written to do. Using a testing framework like mocha automates the process.

If you find this post interesting, like and comment.

Take Your Web Development Skills to Next with Web API's

Eyitayo Itunu Babatope — Fri, 17 Feb 2023 17:30:22 +0000

Web API's is one of the most kept open secret in Web development. You hardly see it in text or any forum post. If you have used document.querySelector() or document.getElementById to interact with HTML element, you have made use of Web API's. Web API's are used typically with JavaScript but it can be used with any programming Language. There are many many Web APIs available and it can be daunting going through each one. From media streaming to HTML drag and drop, Web API's are available. One thing is sure, Web API's will take your web development skills to another level.

In this post and subsequent ones, I will demonstrate Web API's fuctionality. I will start with Web Share API for sharing text,links, files and any content to any selected target.

Prerequisite: HTML, Javascript
Objective: To famailarise readers with Web Share API

The Web share API has two methods
1. navigator.canShare() method to validate data is shareble.
2. navigator.share() method invokes the native sharing mechanism of the underlying operating system.

I will use the HTML skeleton below to demonstrate Web share API are at work.

<html>
<head>
<title>Share page </title>
</head>
<body>
        <div class="share">

            <h1 class="groupH">SHARE DONATION LINK</h1>
            <p class="groupP">Share a link to family and friends to make DONATION to your alma mata</p>

            <button class="btn-secondary share-link" type="submit" onclick="shareLink()">SHARE DONATION LINK</button>
        </div>
 <script type="text/javascript">
        const shareData = {
            title: 'Donation',
            text: 'Donation for my Alma matter',
            url: 'http://localhost:3080/share'
        }
        const shareLink = async (event) => {

            try {
                await navigator.share(shareData)
                console.log('Donation shared successfully')
            } catch (err) {
                console.log(err)
            }
        }


    </script>
</body>
<html>

In the script tag, I created a javascript object shareData that has the web page I want to share. I called navigator.share() with the shareData as parameter inside shareLink function. ShareLink is triggered when the user clicks the Share Donation Button. This will trigger the operating system sharing mechanism.

Finally

As demonstrated above, Web API's makes web development easy. In my next post, I will demonstrate how to use Web Share API to share files.

Like and comment, if you find this post educative.

Take Your Web Development Skills to Next Level with Web API's

Eyitayo Itunu Babatope — Thu, 02 Feb 2023 12:13:12 +0000

In this post and subsequent ones, I will demonstrate Web API's fuctionality. I will start with Web Share API for sharing text,links, files and any content to any selected target.

Prerequisite: HTML, Javascript
Objective: To famailarise readers with Web Share API

The Web share API has two methods
1. navigator.canShare() method to validate data is shareble.
2. navigator.share() method invokes the native sharing mechanism of the underlying operating system.

I will use the HTML skeleton below to demonstrate Web share API at work.

<html>
<head>
<title>Share page </title>
</head>
<body>
        <div class="share">

            <h1 class="groupH">SHARE DONATION LINK</h1>
            <p class="groupP">Share a link to family and friends to make DONATION to your alma mata</p>

            <button class="btn-secondary share-link" type="submit" onclick="shareLink()">SHARE DONATION LINK</button>
        </div>
 <script type="text/javascript">
        const shareData = {
            title: 'Donation',
            text: 'Donation for my Alma matter',
            url: 'http://localhost:3080/share'
        }
        const shareLink = async (event) => {

            try {
                await navigator.share(shareData)
                console.log('Donation shared successfully')
            } catch (err) {
                console.log(err)
            }
        }


    </script>
</body>
<html>

In the script tag, I created a javascript object shareData that has the web page link I want to share. I called navigator.share() with the shareData as parameter inside the shareLink function. When a user clicks the Share Donation Button, the operating system sharing mechanism will be triggered.

Finally

As demonstrated above, Web API's makes web development easy. In my next post, I will demonstrate how to use Web Share API to share files.

Like and comment, if you find this post educative.

Responsive Web Design Hack

Eyitayo Itunu Babatope — Mon, 16 Jan 2023 03:05:40 +0000

Sometimes ago, I came across a post on the web that says " If you have to write many media queries and CSS to create a responsive web pages, then the design is faulty." I agree with this principle. With few lines of CSS, you can create responsive web pages adaptable to any device using CSS flex and common tricks. In this post, the reader will learn how to create responsive web pages with fewer lines of CSS code. This post assumes the reader knows the basic of CSS and CSS flex

Table of Content

Introduction
Relative Units
Responsive design & CSS Flex box layout
Conclusion

Introduction

Responsive web pages target the width of the device and not the height. It is natural to scroll up a web page but unnatural to scroll side ways. Scrolling sideways leads to poor user experience. So the hack of responsive web pages is to focus on the width of the html elements and make it adapt to the width of any device.

The first step in developing responsive web pages with few CSS code and media query is to start with mobile version first. A developer might be tempted to start with the desktop version because of the development environment, such as laptop and desktop. Later on, the developer writes media query to adapt to mobile devices. Experience have shown that this is a tedious process. So remember mobile first.

The second is to set the device viewport in the html head.

<head>
<meta name='viewport' content='width=device-width,intial-scale=1.0' >
</head>

The above will control dimension and scale of the web page read more about viewporthere

Relative Unit

One major hack of responsive web design is to use relative unit for the width of the element instead of fixed unit. Remember, responsive design is about the width of the device. Relative unit scale very well. Fixed unit don't change. Example of fixed unit are
-px
-cm
-pt etc.

relative unit are
-rem
-em
-%
-vh
-vw etc.
Read more about relative unit.

rem unit are relative to the font size of the root html while em are relative to the font size of the nearest parent element. rem provides better control than em.

html{
font-size:16px;
}

2rem= 32px

Another hack is to set the width of images and form elements such as input, button in percentages. The elements will scale nicely on any device.

img{
  width:100%; 
height:10rem; /* 160px */
}

input{
 width: 60%;
}
button{
 width:30%;
}

CSS flex box layout has made responsive web design easy. On mobile version set your flex box direction to column. All the element in the flex container will be displayed stacked on one another. On larger devices, you can set the flex direction to row, to display element side by side.

Mobile version

div{
 display:flex;
flex-direction:column;
width:100%;

}

@media screen and (min-width:1000px){

div{
  display:flex;
flex-direction:row;
}


}

Another hack is to set the flex-flow property of the flex box to row wrap. The element inside the flex box will stack on one another or flow side by side depending on the width of the element.

div{
  display:flex;
flex-flow: row wrap;

}

Conclusion

It is most likely that your web page will be viewed on mobile device. In November 2022, about 50 percent of internet traffic came from a mobile device. This figure will continue to rise. Hence, it is imperative to develop a website that will adapt to most devices. The objective of this post is to enable developers to design responsive web page with ease.

If you find this post educative, comment and like.

Hack CSS GROUPING SELECTORS

Eyitayo Itunu Babatope — Wed, 11 Jan 2023 10:02:33 +0000

This article is for intermediate or entry level frontend developers interested in CSS Grouping selectors. The writer assumes that the reader has basic knowledge of CSS selectors, HTML elements. This article will not cover other type of selectors . At the end of the article, the reader can style nested HTML elements with CSS grouping selectors. The article will utilize a basic HTML layout to demonstrate CSS grouping selectors at work.

HTML Layout.

Types of grouping Selectors
1)Selector list (“,”): Two or more CSS selectors separated by comma(s). From the above HTML, below is an example of selector list.

.header-content, .content-input, .header-people{
background-color: red;
}
The above styles will give the three classes a background color of red.

2) Descendant selectors (" " ): It is an empty space two CSS selectors.

.container p{
color:#FF4820

}
The style above gives all the p element and any element within p such as the span element an orange colour.

3) Child selectors “>”: Greater than sign between two CSS selectors D>E. The style affects all E that are directly within D and not those inside E.
.container >p{
color:#FF4820

}
The style will only affect the p element and not the span element.

4)Sibling selector (~): Given two CSS selectors A~B, the sibling selector select all B that follows A.
H1~p{
font-family:verdana;
font-size:24px;

}
The above will style all p elements that follows h1
5) Adjacent Sibling Selector (+): Given two CSS selectors D+E. The style will affect the first E that follows D.
h1+p{
font-family:verdana;
font-size:24px;

}
The style will affect the first p that follows h1.

Take note that grouping selectors can be nested. For example

.container .header-content >p {

}
It means style a element p that is a child of class header-content, a descendant of class container.

The article listed different CSS grouping selectors with examples.

Selector List
Descendant Selector
Child Selector
Sibling Selector
Adjacent selector Also, the articles demonstrated nesting of grouping selectors.

DEV Community: Eyitayo Itunu Babatope

How to Implement LLM Grounding using Retrieval Augmented Generation Technique(RAG)

Introduction

Importance of LLM grounding

LLM grounding techniques

RAG technique

LLM grounding use case:

Conclusion

Smart Contract Fork Testing Using Foundry Cheatcodes

Introduction

Content

Prerequisites

Benefits of fork-testing

What are Foundry Cheatcodes?

Project setup and testing

Testing the Savings contract.

Conclusion

Video Streaming with MPEG-DASH?

Introduction

Contents

MPEG-DASH

Dynamic Adaptive Streaming

Media Presentation Description

How to encode video files using MPEG-DASH Protocol?

How to Serve and Consume DASH Stream.

Conclusion

References

Develop a Video Chat App with WebRTC, Socket.IO, Express and React.

INTRODUCTION

Prerequisite

Contents

WebRTC Media Streaming Concept

Socket.IO concepts

SOCKET.IO Signaling server setup

WebRTC Setup

Video App UI

Conclusion

Toggle Password Visibility Using React useRef

Introduction

Outline

Understanding useRef

Application of useRef

Toggle password Demo

Conclusion

React Hooks Made Easy

Introduction:

Rules for Hooks

How to use Hooks in an application

React State Hooks

React useState

useReducer

Conclusion:

Test Driven Development in NodeJS

Introduction

Take Your Web Development Skills to Next with Web API's

Finally

Take Your Web Development Skills to Next Level with Web API's

Finally

Responsive Web Design Hack

Table of Content

Introduction

Relative Unit

Conclusion

Hack CSS GROUPING SELECTORS