DEV Community: Abel Osaretin

Brief Overview of the Importance of Frontend Technologies in Modern Web Development

Abel Osaretin — Sat, 29 Jun 2024 15:38:56 +0000

Introduction

Frontend technologies play a crucial role in modern web development by defining how users interact with web applications. They are responsible for the visual and interactive aspects of a website or application, and they directly affect user experience and satisfaction. So picking the right frontend technology is crucial for the survival of your website or application.

Major Frontend Technologies.

There are a lot of frontend frameworks available today, web development has gone far from the days of using direct HTML, CSS, and JavaScript to create websites. There are libraries and frameworks that make use of the basic technology as a foundation for building interesting and unique websites, that do not affect speed and optimization. E.g.

React Js.
Vue Js.
Angular.
Svelte. etc.

Today I will focus on React Js and Angular.

Background

React Js: This libary was developed by Facebook in March 2013, the key focus was to address several challenges faced in web development, particularly in building large-scale, high-performance web applications with complex user interfaces.
Angular: The angular framework was developed by Google in 2016, the aim was to provide a comprehensive framework for building dynamic, single-page applications with a strong emphasis on structure and scalability.

Performance

Below are some performance metrics between React Js and Angular:

1. Initial Load Time:

React

Bundle Size: React apps usually have smaller bundles, leading to faster initial load times.

Code Splitting: Tools like Webpack and dynamic imports allow React to load parts of the app on demand.

Server-Side Rendering (SSR): Using frameworks like Next.js, React can render content on the server for quicker initial display.

Angular

Bundle Size: Angular’s comprehensive framework can result in larger bundles and longer load times.

AOT Compilation: Angular compiles code during the build process, reducing the bundle size and improving load times.

Lazy Loading: Angular can load modules as needed, improving initial load times by delaying non-critical parts.

2. Runtime Performance

React

Virtual DOM: React’s virtual DOM minimizes direct DOM updates, making UI updates more efficient.

Reconciliation Algorithm: This algorithm ensures only necessary changes are made to the DOM.

Memoization: React.memo and hooks like useCallback and useMemo help prevent unnecessary re-renders.

Angular

Real DOM: Angular updates the real DOM directly, which can be less efficient but is managed with change detection.

Change Detection: Angular’s hierarchical change detection and OnPush strategy optimize UI updates.

Zone.js: Manages async operations to keep the app state consistent, though with some performance overhead.

3. Optimizations Available

React

React.memo: Memoizes functional components to avoid re-renders.

Concurrent Mode: Improves app responsiveness by managing multiple tasks simultaneously.

Suspense: Handles asynchronous data fetching gracefully.

Angular

AOT Compilation: Improves performance by compiling during build time.

OnPush Change Detection: Checks for changes only when input properties change.

Ecosystem and Tooling.

React has a very good and vibrant community, with a lot of tools to build interactive and beautiful websites, for example they have:

Next.js: A powerful React framework for building server-rendered applications, static websites, and APIs. It includes features like automatic code splitting, static site generation, and server-side rendering.

Angular also has unique ecosystem tools such as:

RxJS: A library for reactive programming using observables, heavily used in Angular for managing asynchronous operations and state.

Use Cases and Examples

React

HNG: This is where I am currently interning,they make use of React, NextJs, and Radix UI for their website. If you will like to intern here or search for jobs use the links below to learn more.

HNG Site
HNG Internship
HNG Premium
HNG Jobs

Netflix: React is used for parts of the Netflix platform to enhance performance and maintainability.

Angular

Forbes: The Forbes website uses Angular to handle its large volume of content and deliver a smooth user experience.
Upwork: The freelancing platform uses Angular to manage its extensive user interface and functionality.

Conclusion

In conclusion, both React JS and Angular are powerful frontend frameworks that cater to different needs and preferences in web development.
The choice between React.js and Angular ultimately depends on project requirements, team expertise, and specific application needs.

Thank you.

EIP ERC721 Implementation

Abel Osaretin — Fri, 16 Feb 2024 12:37:30 +0000

ERC 721 is different from ERC 20 token standard because it allows us to create a group of tokens that are uniquely different from each other. This feature allows NFTs to represent assets such as digital collectibles, physical properties, etc.

The ERC 721 standard has nine (9) functions, three (3) events, and one (1) interface.

First we create our state variables, mappings, and constructor.

State Variables


 // Token name
 string private _name;

 // Token symbol
 string private _symbol;

Mappings


// To track the NFT (tokenId) and get the owner's address  
mapping(uint256 tokenId => address) private _ownersOf;

// To track the address to get the NFTs owned
mapping(address owner => uint256) private _balancesOf;

// To track approval of a particular NFT that other addresses can interact with.
mapping(uint256 tokenId => address) private _approvals;

// To grant approval for all the NFT in the address to another
mapping(address owner => mapping(address operator => bool)) private _IsApprovedForAll;

Constructor

// Here we are setting the name and symbol for our collection
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}

Functions

1. Balance Of:
This returns the number of NFTs owned by an address passed into _owner

Specification:

function balanceOf(address _owner) external view returns (uint256);

Implementation:

function balanceOf(address owner) public view virtual returns (uint256) {

return _balancesOf[owner];

}

2. Owner Of:
This returns the owner to an NFT

Specification:

function ownerOf(uint256 _tokenId) external view returns (address);

Implementation:

function ownerOf(uint256 tokenId) public view virtual returns (address) {

return  owner = _ownerOf[tokenId];

}

3. Set Approval For All:
Enable or disable approval for a third party ("operator") to manage all of msg.sender's assets

Specification:

function setApprovalForAll(address _operator, bool _approved) external;

Implementation:

function setApprovalForAll(address operator, bool approved) external {

isApprovedForAll[msg.sender][operator] = approved;

emit ApprovalForAll(msg.sender, operator, approved);
}

4. Approval:
Change or reaffirm the approved address for an NFT

Specification:

function approve(address _approved, uint256 _tokenId) external payable;

Implementation:

function approve(address spender, uint id) external {

address owner = _ownerOf[id];

require(
msg.sender == owner || isApprovedForAll[owner][msg.sender],
"not authorized" );

_approvals[id] = spender;

emit Approval(owner, spender, id);

}

5.Get Approval:
Get the approval on an address for a single NFT

Specification:

function getApproved(uint256 _tokenId) external view returns (address);

Implementation:

function getApproved(uint id) external view returns (address) {

require(_ownerOf[id] != address(0), "token doesn't exist");

return _approvals[id];

}

6. Approved or Owner:
if an address is an authorized operator owner and checks if _owner The address that owns the NFTs

Specification:

function isApprovedForAll(address _owner, address _operator) external view returns (bool);

Implementation:

function isApprovedOrOwner(
address owner,
address spender,
uint id
) internal view returns (bool) {

return (spender == owner ||
isApprovedForAll[owner][spender] ||
spender == _approvals[id]);

}

7. Transfer From:
Transfer ownership of an NFT

Specification:

function transferFrom(address _from, address _to, uint256 _tokenId) external payable;

Implementation:

function transferFrom(address from, address to, uint id) public {

require(from == _ownerOf[id], "from != owner");

require(to != address(0), "transfer to zero address");

require(_isApprovedOrOwner(from, msg.sender, id), "not authorized");

_balanceOf[from]--;

 _balanceOf[to]++;

 _ownerOf[id] = to;

 delete _approvals[id];

 emit Transfer(from, to, id);

 }

8. Safe Tranfer From Address to Address:
Transfers the ownership of an NFT from one address to another address
Specification:

function safeTransferFrom(address _from, address _to, uint256 _tokenId) external payable;

Implementation:

function safeTransferFrom(address from, address to, uint id) external {

transferFrom(from, to, id);

require(

to.code.length == 0 ||
                IERC721Receiver(to).onERC721Received(msg.sender, from, id, "") ==
                IERC721Receiver.onERC721Received.selector,
"unsafe recipient" );

}

9. Safe Transfer From Address to Contract:
Transfers the ownership of an NFT from one address to contract address.

Specification:

function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes data) external payable;

Implementation:

function safeTransferFrom(
address from,
address to,
uint id,
bytes calldata data
) external {

transferFrom(from, to, id);

require(

to.code.length == 0 ||
                IERC721Receiver(to).onERC721Received(msg.sender, from, id, data) ==
                IERC721Receiver.onERC721Received.selector,
"unsafe recipient"

);
}

EIP ERC20 IMPLEMENTATION

Abel Osaretin — Thu, 15 Feb 2024 10:55:48 +0000

November 19th, 2015 an Ethereum Improvement Proposal (EIP) was published to standardize the structure to create tokens on the Ethereum blockchain. The authors were Fabian Vogelsteller and Vitalik Buterin, it was the 20th Ethereum Request For Comment (ERC) so it was given the name ERC-20: Token Standard.

The aim for creating this token standard was to provide basic functionality to transfer tokens, as well as allow tokens to be approved so they can be spent by another on-chain third party. It will also allow any tokens on Ethereum to be re-used by other applications: from wallets to decentralized exchanges.

First we need to create our constructor and state variables to set Name, Symbol, Decimal, and total supply on deployment.

State Variables


string private TokenName;

string private TokenSymbol;

uint8 private TokenDecimals;

uint256 private TokenSupply;

address public owner;

Constructor


constructor(

string memory _tokenName,

string memory _tokenSymbol,

 uint8 _tokenDecimals,

uint256 _tokenSupply

) {

 owner = msg.sender;

 TokenName = _tokenName;

TokenSymbol = _tokenSymbol;

TokenDecimals = _tokenDecimals;

TokenSupply = _tokenSupply;

balance[owner] = TokenSupply;

}

There are 9 functions and 2 events specifications. I will list out the specifications and show you how I implemented it in my code.

Events


event Transfer(address indexed _from, address indexed _to, uint256 _value);

event Approval(address indexed _owner, address indexed _spender, uint256 _value)

Functions

1. Name:

Specification:

Returns the name of the token - e.g. “My Token”

function name() public view returns (string)

Implementation:

function name() public view returns (string memory) {
return TokenName;
}

2. Symbol:

Specification:

Returns the symbol of the token - e.g. “MTK”

function symbol() public view returns (string)

Implementation:

function symbol() public view returns (string memory) {
return TokenSymbol;
}

3. Decimals:

Specification:

Returns the number of decimals the token uses - e.g. 8 means to divide the token amount by, 100000000 to get its user representation.

function decimals() public view returns (uint8)

Implementation:

function decimals() public view returns (uint8) {
return TokenDecimals;
}

4. Total Supply:

Specification:

Returns the token total supply.

function totalSupply() public view returns (uint256)

Implementation:

function totalSupply() public view returns (uint256) {
return TokenSupply;
}

5. Balance Of:

Specification:

Returns the account balance of another account with address “_owner”.

function balanceOf(address _owner) public view returns (uint256 balance)

Implementation:

function balanceOf(address _owner) public view returns (uint256) {
return balance[_owner];
}

6. Transfer:

Specification:

Transfers “_value” amount of tokens to address “_to”, and MUST fire the “Transfer event”. The function SHOULD “throw” if the message caller’s account balance does not have enough tokens to spend.

function transfer(address _to, uint256 _value) public returns (bool success)

Implementation:

function transfer(
address payable _to,
uint256 _value
) public returns (bool) {

require(_to != address(0x0), "Wrong EOA");

require(_value <= balance[msg.sender], "You Don't have enough Token");

balance[msg.sender] = balance[msg.sender] - _value;

balance[_to] = balance[_to] + _value;

return true;

}

7. Transfer From:

Specification:

Transfers "_value" amount of tokens from address "_from" to address "_to", and MUST fire the "Transfer" event. The "transferFrom" method is used for a withdraw workflow, allowing contracts to transfer tokens on your behalf.

function transferFrom(address _from, address _to, uint256 _value) public returns (bool success)

Implementation:

function transferFrom(
address _from,
address _to,
uint256 _value
) public returns (bool) {

require(_to != address(0x0), "Wrong EOA");

require(_value <= approval[_from][msg.sender]);

uint256 _burnAmount = _value / 10;

approval[_from][msg.sender] -= _value;

balance[_from] -= _value;

balance[_to] += _value;

burn(_from, _burnAmount); // You will see this function bellow

return true;
    }

8. Approve:

Specification:

Allows "_spender" to withdraw from your account multiple times, up to the "_value" amount. If this function is called again it overwrites the current allowance with "_value".

function approve(address _spender, uint256 _value) public returns (bool success)

Implementation:

function approve(address _spender, uint256 _value) public returns (bool) {

approval[msg.sender][_spender] = _value;

return true;

    }

9. Allowance:

Specification:

Returns the amount which "_spender" is still allowed to withdraw from "_owner".

function allowance(address _owner, address _spender) public view returns (uint256 remaining)

Implementation:

function allowance(
address _owner,
address _spender
) public view returns (uint256 approved) {

return approval[_owner][_spender];

}

Burn Feature.

I added a burn feature to the contract which was called in transferFrom function.

10. Burn

It burns 10% of the total supply.

Implementation:


function burn(address _from, uint256 _value) internal {

require(balance[_from] >= _value, "Insufficient balance to burn");

balance[_from] = balance[_from] - _value;

TokenSupply = TokenSupply - _value;

emit Transfer(_from, address(0), _value);

}