DEV Community: Emmanuel Amoo

Intent-Based Trading: The Next Evolution of DeFi?

Emmanuel Amoo — Mon, 03 Mar 2025 16:18:20 +0000

Decentralised Finance (DeFi) has undergone rapid evolutions, from simple token swaps and lending protocols to more sophisticated trading mechanisms. Although DeFi has revolutionised financial access, its user experience can be complex and demanding. Traditional DeFi trading often requires users to manage each step of a transaction, from selecting liquidity pools to calculating gas fees. While it can be empowering, giving users control over transactions and assets, the process can be challenging for many. Intent-based trading, another exciting DeFi evolution, redefines how users interact with markets and currency. But what exactly is intent-based trading, and why is it considered the next evolution of DeFi?

What is intent-based trading?

Traditional DeFi trading relies on users specifying exact trade details, such as the token pair, price, slippage tolerance, and liquidity source, before executing a transaction. However, intent-based trading flips this approach by allowing users to express their intent rather than specifying the exact execution parameters.

For example, instead of manually executing a swap, bridging assets, and depositing into a yield farm, a user might simply state, "I want to deposit 1 ETH into the highest-yielding stablecoin farm." The system then handles the complexities of routing, execution, and optimization.

Previously, investors had to manually juggle various wallets, shift between platforms, and monitor multiple tokens and strategies. However, this evolution streamlines the process by automatically executing investment plans across different blockchains, allowing assets to grow on autopilot.

How does it work?

The core mechanism of intent-based trading involves the following steps:

Intent Registration : The user registers their intent without specifying trade details. For example, an investor might state, 'I want to deposit 1 ETH into the highest-yielding stablecoin farm.' This clearly outlines their goal and simplifies the investment process.
Analysis and Optimization : Solvers, which can be on-chain or off-chain entities, analyze available liquidity sources, trading paths, and execution strategies. The solver that provides the most optimal outcome fulfills the trade, often leveraging smart order routing and batch processing.
On-Chain Execution : The transaction is executed successfully on-chain, and the user's intent is fulfilled without the need for manual intervention.

Intent languages are standardized to express user intents, enabling interoperability across various platforms and solvers. These systems aggregate liquidity from multiple DEXs and protocols, optimizing for factors such as slippage, gas fees, and yield. Solvers typically execute the entire intent in a single transaction, ensuring that all steps are completed or none are, thereby eliminating the risk of partial fills or stuck transactions.

Benefits of intent-based trading

By eliminating the need for users to manually determine trade parameters, intent-based trading optimises execution across fragmented liquidity pools and multiple DEXs. This results in lower slippage as solvers find the best execution routes. Additionally, transactions can be bundled or executed in gas-efficient ways, reducing gas fees.

MEV bots exploit users in traditional DeFi trading by frontrunning transactions for profit. Intent-based trading mitigates this risk by offloading execution decisions to trusted solvers, thereby minimising MEV threats.

For retail users, setting parameters like slippage tolerance, liquidity source selection, and price limits can be complex. Intent-based trading simplifies this by shifting execution responsibilities to automated systems, making DeFi more accessible and user-friendly.

By integrating various DeFi protocols and liquidity pools under a single intent execution framework, the system enhances liquidity access and enables seamless cross-chain trading. Aggregation across multiple protocols allows for better capital utilization and access to deeper liquidity. Users can effortlessly express complex trading strategies without needing to execute each step individually.

Challenges and Considerations

Trust and Security : Users need to have confidence in solvers to execute their intents accurately and securely. Implementing robust reputation systems and thorough security audits is vital to building this trust.
Solver Competition : Encouraging fair competition among solvers is crucial to preventing centralization and ensuring that users reap the maximum benefits from a diverse solver ecosystem.
Intent Language Standardisation : Creating standardised intent languages is key for enabling interoperability and facilitating the widespread adoption of intent-based systems.
Complexity of Intent Resolution : Designing efficient and robust algorithms to solve complex intents poses a significant technical challenge, but it's essential for the system's overall effectiveness.
On-chain vs. off-chain execution : Deciding which parts of the intent resolution should be on-chain or off-chain is a crucial design consideration that affects system performance and security.

The Future of DeFi?

Intent-based trading has the potential to become a foundational layer of DeFi, transforming it from a complex ecosystem designed for advanced users into a seamless and accessible financial platform for everyone. By focusing on user intents rather than technical details, it can unlock the true potential of decentralized finance, driving mass adoption and fostering innovation.

With advancements in zero-knowledge proofs, smart contract automation, and decentralized solvers, intent-based trading could become the dominant model for DeFi trading. This approach is poised to redefine how DeFi markets operate, making trading smarter, more efficient, and user-friendly. As more protocols adopt this model, we may see a future where DeFi users focus on their financial goals rather than execution complexities.

Though still in its early stages, intent-based trading represents a significant leap forward in the evolution of DeFi. As the technology matures and adoption grows, it has the potential to reshape the landscape of decentralized finance, making it more user-friendly, efficient, and accessible.

]]>

WTF is Pessimistic Proof? 🤔

Emmanuel Amoo — Fri, 21 Feb 2025 11:07:46 +0000

The Evolution of Blockchain and Aggregated Solutions

Since its inception, blockchain technology has evolved in diverse directions, resulting in a fragmented ecosystem. Despite its potential, only 6.8% of the world's population holds cryptocurrencies, highlighting the technology's limited reach. However, Polygon Technology's concept of aggregated blockchains aims to unify this fragmented ecosystem, offering a promising solution to the current challenges.

Aggregated Blockchains: A Recap

Introduced by Polygon in early 2024 and discussed in our last article, aggregated blockchains serve as a foundational aspect of AggLayer. This technology aims to deliver the best user experience, unified liquidity, scalability, and customisability. Unlike traditional monolithic and modular blockchains, aggregated blockchains strive to offer a holistic solution without compromising key facets.

Polygons AggLayer acts as a unified bridge between layer-1 and layer-2 blockchains, addressing the issue of users traversing multiple blockchains for simple transactions. This fragmentation has led to increased security concerns and reduced scalability, ultimately degrading performance capabilities. By leveraging zero-knowledge proofs (ZKPs) or optimistic proofs, aggregated blockchain solutions register transactions on the main blockchain seamlessly.

Challenges with Existing Mechanisms

While zero-knowledge proofs and optimistic proofs currently support aggregated blockchain solutions, they present challenges as more blockchains join the unified bridge. Optimistic proofs, for instance, can take up to seven days for a transaction to become fully integrated into a blockchain, hampering the user experience in a large-scale system.

Zero-knowledge proofs, though effective, may face reduced transaction soundness as the unified bridge interacts with networks with diverse consensus mechanisms. Additionally, without sufficient security backups, a malicious actor from one blockchain could jeopardize the entire aggregated network.

How Pessimistic Proofs Address These Issues

To overcome the limitations of existing mechanisms, Polygon introduced pessimistic proofs , a novel approach designed to enhance the security and reliability of aggregated blockchain solutions. Pessimistic proofs assume that all participants in an aggregated solution are malicious, employing a unique approach to enhance network safety. The key principle is that a participant blockchain cannot withdraw more than its deposited amount in the bridge contract.

The creation of pessimistic proofs involves verifying three critical pieces of information:

Updates are executed correctly on the participant blockchain.
The participant network's internal accounting is accurate.
All participant blockchains conduct their accounting activities correctly.

By checking each participant network for trustworthiness, the unified aggregation layer ensures no attempts are made to withdraw extra from the bridge. If a network fails the check, it can only threaten itself, not the bridge or other networks.

Technically, the unified bridge requires three inputs to generate a pessimistic proof:

The participant blockchains local exit tree (indicating withdrawals) up to the previous iteration.
The list of new withdrawals to be included in the current update.
The blockchains projected new local exit root.

The mechanism calculates the networks new exit root from the first two inputs and compares it with the third. If they match, a pessimistic proof is generated, guaranteeing the local exit root is updated correctly. Additionally, the mechanism checks the crypto token balances of participant blockchains before proceeding with a new global exit root. If the withdrawal balance exceeds the deposited balance, the update is invalid, and its state cannot be verified on the layer-1 network.

Conclusion

Pessimistic proofs represent a pioneering approach to enhancing the safety of aggregated blockchain solutions. As more layer-2 networks build on Ethereum, the need for such provenance mechanisms becomes crucial. While Polygon Technology developed this mechanism to support its AggLayer, its revolutionary appeal is set to capture blockchains worldwide. By adopting pessimistic proofs, blockchain projects, especially those building an L2 on Ethereum, can join a global network with robust security. Connect with our experts now to explore the possibilities and implement pessimistic proofs in your L2 solution with Polygons solid infrastructure.

]]>

Chainlink CCIP: A Secure Cross-Chain Communication Protocol

Emmanuel Amoo — Wed, 12 Feb 2025 10:28:10 +0000

Introduction

As Web3 adoption and the ecosystem grow, blockchain interoperability protocols are crucial for connecting blockchains and enabling cross-chain communications. The evolving blockchain ecosystem demands seamless cross-chain communication, as DeFi, NFTs, and other Web3 applications operate across multiple chains. Fragmented liquidity, security risks, and inefficient bridges create barriers to interoperability. Developers and users must navigate complex, risky, and expensive transactions without a secure and reliable cross-chain messaging system. Blockchain interoperability protocols are the foundation for building abstraction layers, which enable traditional backends and dApps to seamlessly interact with any blockchain network through a single middleware solution.

Blockchain interoperability protocols offer several key capabilities:

Transfer of assets and information across multiple blockchains.
Empowering application developers to leverage the strengths and benefits of different chains.
Fostering collaboration among developers from diverse blockchain ecosystems to build cross-chain applications, serving more users and providing additional features or products.

Chainlinks Cross-Chain Interoperability Protocol (CCIP) is an industry-standard protocol that provides a secure, decentralised, and programmable framework for cross-chain communication.

In this article, well be taking a look at Chainlinks Cross-Chain Interoperability Protocol (CCIP).

Introducing Chainlink CCIP

Chainlink CCP is Chainlinks standard protocol that enables seamless and trustless transfer of data and tokens across chains. CCIP empowers developers to create secure applications capable of transferring tokens, messages, or both across different chains.

CCIP provides native level-five cross-chain security, ensuring Web3 projects are built on solid, secure foundations. The decentralised nature of CCIP, combined with the robustness of Chainlink's Oracle network, set it apart. CCIP leverages multiple decentralised networks to secure each cross-chain transaction. It also incorporates advanced risk management systems to identify potential risks and take preventive actions.

This design prioritises security, significantly reducing the risk of exploits and vulnerabilities which have affected other cross-chain solutions. Additionally, CCIP focuses on generalised messaging, enabling it to be used for a wide range of cross-chain interactions beyond just token transfers, including smart contract calls and data relays.

CCIP Architecture and Features

The diagram below displays the basic architecture of CCIP. The routers are smart contracts that offer a simple and consistent interface for users. Users can interact with routers to achieve the following:

Execute smart contract functions on different blockchains.
Transfer tokens to a smart contract or an Externally Owned Account (EOA) on another blockchain.
Send arbitrary messages and tokens within the same transaction, enabling the transfer of tokens along with instructions on how to manage those tokens on a different blockchain.

Also, the image below gives a high-level overview of the different components involved in cross-chain transactions. Cross-chain dApps are tailored for user-specific interactions, where a smart contract, smart account, or EOA (externally owned account) uses the CCIP router to send arbitrary data and transfer tokens cross-chain. The dark blue contracts represent the CCIP interface (Router), which users need to interact with without requiring a comprehensive understanding of the entire CCIP architecture. This interface remains static over time, ensuring reliability and stability for users. In contrast, the light blue contracts are internal to the CCIP protocol and subject to change. Additionally, the contracts highlighted in orange have been integrated into the CCIP protocol to support the Cross-Chain Token (CCT) standard.

Chainlink CCP supports three main capabilities: arbitrary messaging, token transfers, and programmable token transfers.

Arbitrary messaging enables the sending of arbitrary data to another smart contract on a different blockchain. Developers can use this to initiate informed actions when receiving smart contracts. These could involve tasks like minting specific NFTs, rebalancing an index, or executing an arbitrary function with custom parameters from the sent data.

Token transfer enables the transfer of tokens to a smart contract on a different blockchain, while programmable token transfer enables the simultaneous transfer of tokens and arbitrary data in a single transaction.

CCIP Use Cases

Here are some of CCIP's use cases: DeFI, NFT minting on multiple chains, and cross-chain gaming. These use cases demonstrate the potential of CCIP to transform the cross-chain application economy.

Cross-Chain DeFi

DeFi protocols thrive on liquidity, yet assets are often trapped within isolated blockchains. It prevents users from seamlessly moving assets across chains to access better yields, trade assets, or participate in governance.

By enabling cross-chain smart contract interaction and token transfers, CCIP exponentially enhances DeFi composability. Instead of being confined to each chain and its respective DeFi protocols, all DeFi applications across various blockchains can now interoperate to create new financial products. Applications and protocols are no longer restricted to their native chains.

This cross-chain composability of DeFi applications fosters a more cohesive and connected DeFi ecosystem, making liquidity, users, and financial products across all chains accessible to all protocols.

Cross-Chain Gaming

Web3 gaming has seen a surge in popularity in recent years. Like DeFi, gaming is also restricted to its respective chains while traditional gaming can have different players with different consoles and phones play the same game together. This is a massive limitation and has prevented Web3 gaming from reaching its true potential in recent years. While gaming in Web2 is cross-platform, Web3 gaming can catch up with CCIP.

CCIP enables cross-chain Web3 gaming by facilitating asset transfers across different blockchains and enabling a shared game state. This allows gamers to play with or against each other, regardless of the blockchain they prefer to use.

Cross-Chain NFTs

Similarly, in the NFT space, interoperability can revolutionise digital ownership. Imagine owning an NFT on one chain and being able to display it in a metaverse built on another. CCIP enables cross-chain NFT bridging, allowing users to seamlessly move their digital assets between different ecosystems, expanding their utility, and creating new market opportunities.

Cross-Chain Daos

Decentralised autonomous organisations (DAOs) can leverage CCIP to facilitate on-chain voting across one or more high-speed, low-cost blockchain networks. The voting results can then be transmitted to the higher-cost blockchain that hosts the core governance contracts. This approach encourages greater participation by reducing transaction costs for DAO members while maintaining transparency and censorship resistance across all on-chain environments.

Advantages of CCIP

CCIP has notable advantages over traditional bridges in terms of security, reliability, scalability, cost-effectiveness, and programmability.

Security

Chainlinks Cross-Chain Interoperability Protocol (CCIP) security model is based on defense-in-depth security and risk management network. Much effort is paid to minimising complexity and single points of failure through their defense-in-depth approach, which protects against a broad spectrum of attacks. Chainlink identifies three key features required to power a secure cross-chain ecosystem. They are:

Level of Decentralisation: Some cross-chain solutions allow all their transactions to pass through a single environment, which can lead to a single point of failure and put user's funds at risk. In contrast, each CCIP operates in a multi-environment comprising of lanes, with each lane using three separate oracle networks to confirm different aspects of a transaction. This high level of decentralisation, with numerous nodes independently verifying key parts of the transaction, sets CCIP apart from typical cross-chain solutions.
Risk Management Network: CCIP also has the Risk Management Network, an independent active risk management layer. For instance, if a chain faces risks like block reorganisation, reliability issues, or new attacks, the Risk Management Network can independently address these by adding new conditions without altering the core CCIP protocol. This approach maintains core security while enhancing it with additional measures, creating a more decentralised and resilient system that can quickly adapt to new threats.
Client Diversity: The third crucial factor for enhancing cross-chain security is client diversity.

Reliability

CCIP uses a gas-locked transaction price payment mechanism on the source blockchain, ensuring transactions are executed even during gas spikes or network congestion on the destination blockchain.

Scalability

With CCIP, developers can access the features of various blockchains through a single interface, eliminating the need to write specific code for each platform.

Programmability

CCIP provides developers with a unified, easy-to-integrate interface, allowing them to create secure cross-chain applications without needing custom code for each blockchain.

Comparing CCIP and other Cross-Chain Solutions

CCIP isnt the only cross-chain solution that exists; several others exist with their strength and weaknesses. For instance, LayerZero is a cross-chain solution focusing on efficient message delivery; Axelar is another with an emphasis on developer friendliness; and Wormhole is notable for its cross-chain support. However, CCIP stands out due to its robust security model, leveraging its Oracle network. CCIP prioritises security and reliability, which are paramount for high-value cross-chain reactions, unlike others prioritising speed and ease of use. Chainlinks approach makes it the dominant player in the cross-chain space. A direct comparison table highlighting their abilities is displayed below:

Feature

Chainlink CCIP

LayerZero

Axelar

Wormhole

|
|

Security

High (Chainlink Oracles)

Variable

|
|

Reliability

High

Medium

|
|

Speed

Medium

High

Medium

High

|
|

Cost

Variable

|
|

Generalized Msg.

Yes

Note: Security and reliability are complex and depend on specific implementations. The above is a simplified comparison.

The Future of Cross-Chain Communication with CCIP

Cross-chain interoperability is now a necessity for DeFi, NFTs, and institutional adoption of blockchain systems. For the continued evolution of the blockchain ecosystems, cross-chain interoperability is increasingly essential. Chainlink CCIP focuses on security and reliability, positioning it well to become a standard for cross-chain communication. As the DeFi and other native blockchain landscapes mature, CCIP is positioning itself as a pillar to ensure seamless and trustless interoperability.

For developers and projects looking to build across multiple chains without security trade-offs, CCIP is the best-in-class solution. The future of blockchain is multi-chain, and Chainlink CCIP is leading the way in making that future a reality.

Want to get started? Explore CCIP today and build the next generation of secure, scalable cross-chain applications.

]]>

Architecting Scalability: Exploring AggLayer's zk-Rollup Aggregation

Emmanuel Amoo — Thu, 06 Feb 2025 08:11:09 +0000

Introduction

With the widespread adoption of blockchain technology, especially with the advent of the Bitcoin breakthrough in 2017, several new blockchains have emerged since then, taking various roles to solve several blockchain and crypto problems. Ethereum stands out and has been the chain of choice for many projects due to features such as faster transaction speed compared to Bitcoin, security, and ability to innovate and experiment which led to the introduction and adoption of several tokens and the advent of DeFi (Decentralised Finance) and lower fees.

However, Ethereum has a scaling issue; it can only process fewer transactions per second, leading to high fees and longer wait times for transactions to be processed. This problem with Ethereum necessitates the advent of new solutions to solve the issue of Ethereum scaling. Several layer 2 blockchains have been built to solve Ethereums scalability issue, leading to an even wider adoption of Ethereum. These Layer 2s have driven Ethereum to another level by improving scalability, reducing transaction fees considerably, and introducing security; these led to even more innovation in the crypto space, including the widespread adoption of DeFi. However, L2s face on Ethereum faces another problem of interoperabilitythe ability for the different blockchains to interact and share liquidity. Although these problems have been solved with bridges and rollups, they are often ladled with security risks, inefficiencies, and fragmented liquidity.

Polygon is trying to solve the interoperability issue with its new solution, "AggLayer.. Polygon is a leading Layer-2 solution, offering various chains like PoS, zkEVM, and supernets. Managing and integrating zero-knowledge proofs (ZKPs) across diverse chains can be problematic. The AggLayer was introduced to combat these problems.

Understanding Polygon

Polygon was founded in 2017 by Sandeep Nailwal, Jaynti Kanani, and Anurag Arjun as MAtic Network. Polygon was founded to create a scalable and user-friendly network for developing and connecting blockchain networks. It is a layer 2 blockchain that enables fast transactions and minimises transfer fees.

Ethereums high transaction fees and high transaction wait-time, which limited the applicability of Ethereum, birthed the Polygon solution. Polygons solution addressed Ethereums inherent weaknesses while complementing it. Polygon was initially meant to implement the Plasma chain proposed by Vitalik Buterin, but they discovered they needed a novel approach to addressing the Ethereum problem.

Matic Network was rebranded as Polygon in 2021 to enable them to move towards a new goal of becoming the internet of blockchains. They moved beyond developing single-scaling solutions to developing one that encompasses a wide range of blockchain scaling technologies, which includes optimistic rollups, ZK-rollups, and sidechains, which allowed developers to choose solutions relating to their needs.

The AggLayer concept was borne from this expansion, and it became a key core of Polygons vision to interconnect blockchains.

Introducing the AggLayer

Polygons AggLayer, short for Aggregation Layer, is a significant enhancement to the Polygon ecosystem designed to facilitate seamless connections between blockchains. The AggLayer is a decentralised protocol that aggregates proofs from all connected chains whilst also ensuring safety for fast cross-chain transactions.

Ethereum scaling challenge

Although lots of tokens operate on the Ethereum network, it presents scalability issues, as addressed in the introduction. Ethereums throughput is limited to 15 transactions per second, which severely limits its widespread adoption and user experience. As more people are onboarded into the network, the network gets congested during peak times, which leads to higher-than-normal gas fees and slower transactions. During peak times, the gas fees become especially problematic, rendering it financially unviable for users to engage with the network.

To address these problems, several solutions have been proposed to solve the scalability issue. The two main solutions are optimistic and zk rollups. Both operate differently as layer 2 solutions on Ethereum to enable scale transactions and reduce gas fees significantly. While transactions on optimistic rollups are assumed to be valid by default and only checked later if disputed, transactions on ZK rollups are bundled together and verified using zero-knowledge proofs (ZKPs). Let's briefly examine optimistic and ZK rollups.

Optimistic rollups

Layer 2 solutions allow transactions to be processed and bundled off-chain while still leveraging Ethereums security. Later, the transaction is submitted as a single transaction to the Ethereum mainnet. Transactions performed on optimistic rollups are assumed to be valid. However, network participants can dispute a transactions validity during a challenge period. If the transaction is proven to be fraudulent, the rollup reprocesses the transaction, adjusting its state while the sequencer who added the transaction is punished. Examples of optimistic rollups are arbitrum, optimism (OP), base, zora, and mantle.

ZK rollups

ZK-rollups also process transactions off-chain but use cryptographic proofs called zero-knowledge proofs to ensure transactions are valid before submitting them on-chain. Off-chain state changes are validated on-chain through the use of zero-knowledge proofs, which determine the mathematical certainty that the state changes are correct. zkRollups have several advantages over-optimistic rollups:

Security: zkRollups validate transactions using cryptographic proofs, providing stronger security compared to optimistic rollups that depend on participants challenging the validity of transactions.
Finality: zkRollups offer immediate finality for transactions, unlike Optimistic Rollups, which require a 7-day wait time for transactions to be considered final.
Data Compression: zkRollups efficiently compress transaction data, resulting in lower fees due to reduced data size.
Privacy: zkRollups ensures privacy by validating proofs without disclosing sensitive information, offering better privacy than optimistic rollups.

Examples of zk rollups are zkSync, zkSwap, Polygon Hermez, and mir protocol.

The AggLayer is based on aggregating Layer 2 solutions built on the Polygon blockchain. The AggLayer is explained in the next section.

AggLayer Explained

The AggLayer is a single bridge contract on Ethereum for all connected chains. It operates as a single contract to unify the multiple Layer 2 solutions plagued by limited liquidity. Additionally, it consolidates various frameworks, allowing for seamless interoperability and enhanced performance across numerous networks.

The AggLayer solves the fragmentation issue and enables seamless transactions between blockchains by operating as a single-layer (unified bridge). The unified bridge allows the execution of contracts between several blockchains while preventing fragmented liquidity, improving user experience, and potential gas fees.

The architecture can be broken down into the following steps:

Liquidity aggregation: AggLayer combines liquidity from multiple chains into a single accessible pool.

Cross-Chain messaging protocol: AggLayer ensures real-time data synchronisation between different chains.

Transaction finality layer: AggLayer provides low-latency confirmation mechanisms for transactions.

Developers have access to the bridgeAndCall() Solidity library, empowering them to create logic that can be executed across multiple chains. Users can transfer assets between chains and also trigger contracts on a different chain when the asset arrives. Also, users can send and participate in activities on another chain. This aggregation aims to establish a cohesive blockchain ecosystem that operates as seamlessly as a single chain. By removing the obstacles of siloed liquidity and fragmented user bases, it has the potential to pave the way for mass adoption.

Features of the AggLayer

Unified Liquidity Aggregation: AggLayer solves the liquidity problem by creating a unified liquidity network, allowing users to access liquidity across several chains without needing multiple bridging solutions.
Low-latency Cross-Chain Transactions: AggLayer minimises latency by optimising transaction routing systems, considerably reducing settlement times, and ensuring instant trade execution.
Enhanced Security: AggLayer improves security for cross-chain solutions, removing the need for wrapped tokens or centralised relayers by using cryptographic proofs and decentralised validation to ensure the trustless execution of transactions.
ZK Proof aggregation: AggLayer aggregates zk proofs from all chains, ensuring privacy and efficiency.
Scalability: AggLayer increases the transaction throughput of the polygon network by aggregating multiple scaling solutions.
Developer-Friendly Integration: AggLayer provides the bridgeAndCall() functionality to enable developers to create logic that can execute on different chains for asset transfers.

Use Cases and Applications

DeFi and Liquidity Protocols: AggLayer ensures that liquidity is consistently maintained and distributed across various protocols and chains, enhancing both the efficiency and adoption of DeFi. By integrating AggLayer, lending and borrowing protocols can boost liquidity and participation through efficient collateral management.

Decentralised exchanges: With AggLayer, tokens can seamlessly exist and be traded on multiple chains without the need for multiple bridges. Acting as a single unified bridge, AggLayer efficiently handles transfers and communications across different chains.

NFT Marketplace: AggLayer's unified bridge will enable NFTs purchased on one chain to be seamlessly traded on another, enhancing liquidity and facilitating efficient cross-chain asset transfers.

Single Unified Wallet: By utilising AggLayer's technology, assets can seamlessly move across various blockchains without relying on multiple bridges. This innovation allows users to manage their assets with a single wallet, eliminating the need for juggling multiple complex wallets across different chains.

Conclusion

AggLayer represents a significant innovation in the blockchain space, aimed at enhancing user experience and driving widespread adoption. Traditional bridging methods, while solving cross-chain communication, are slow, fragment liquidity, and can result in permanent fund loss if errors occur. Additionally, moving assets between multiple chains is both costly and complex. AggLayer simplifies this process, preserving liquidity, user experience, and speed.

As DeFi, web3 gaming, and blockchain adoption grow, seamless cross-chain communication becomes critical to the continued growth of web3. AggLayer's trustless and developer-friendly approach has the potential to redefine the blockchain industry, much like how TCP/IP improved the adoption of the internet.

]]>

Checkout my new post on oracle networks

Emmanuel Amoo — Fri, 31 Jan 2025 09:16:49 +0000

Decentralized Oracles vs. Centralized Oracles: A Deep Dive into Trust Models

Emmanuel Amoo ・ Jan 31

#web3 #oracle #blockchain #cryptocurrency

Decentralized Oracles vs. Centralized Oracles: A Deep Dive into Trust Models

Emmanuel Amoo — Fri, 31 Jan 2025 09:15:45 +0000

1. Table of Contents

Table of Contents
Introduction
Centralised and Decentralised Oracles
Centralized Oracles: The Trust Dilemma
Decentralized Oracles: A Trustless Model
BlockChain Oracles Use Cases
Comparing Leading Decentralized Oracle Networks (DONs)
Chainlink
Hybrid Smart Contracts
Node Reputation System
Data Aggregation
DIA (Decentralized Information Asset)
Pyth Network
API3
Airnodes
Ensuring Data Integrity in Decentralized Networks
Data Aggregation and Verification
Reputation and Staking Models
Conclusion

2. Introduction

An Oracle, most commonly called a blockchain oracle, are intermediary networks that connect blockchain systems to external off-chain networks, allowing the blockchain smart contracts to interact with data off-chain. Important data like financial market data, sporting events, banking data, games and many other data which exists off-chain can be made to interact with on-chain smart contract. Oracles work by fetching, verifying and delivering these data to blockchain networks.
Oracle networks serve as data providers to smart contract, they are independent bridges that verify real-life data, aggregating them before delivering them to the smart contract on-chain. They enable contact between the outside world and real data, vastly enlarging the scope of operation of smart contracts.
Centralised and decentralised oracles are examples of blockchain oracles, they’ll be evaluated below.

Figure 1: Intersection of real world data and the blockchain

3. Centralised Oracles and Decentralised Oracles

There are two major types of oracles: centralised oracles and decentralised oracles. Just as in the case of decentralised and centralised networks, decentralised oracles deliver data from a network of nodes while centralised nodes deliver data from a single network. Both have their own pros and cons based on security, reliability, and other metrics.

Figure 2: Pictorial depiction of centralised and decentralised oracles

4. Centralized Oracles: The Trust Dilemma

Centralised oracles are single entities that provide data to a smart contract from a single source. They are single organisations that interact and fetch data from a smart contract; they are responsible for any information the smart contract needs. While they have advantages such as operational efficiency and low latency, they pose risks such as having a single source of failure, censorship and manipulation, and doubtful transparency. Also, they traditionally require smaller investment and less architecture and maintenance, although they are prone to being attacked and corrupted.

5. Decentralized Oracles: A Trustless Model

Decentralised oracles also work similar to the decentralisation model in Web3, data is provided by multiple, distributed sources (nodes), enabling a trustless model. Due to this model, the accuracy of the data is verified by the many data sources, enabling the smart contract to perform with higher accuracy and veracity. Due to the decentralised model, the oracle interacts with the several sources of data, validating their data before the onwards dissemination to the smart contract. Decentralised oracles make use of variations of the ShellingCoin mechanism, where sources report data independently without collusion between parties.
Decentralised oracles are well-suited for larger companies because of the architecture and higher maintenance cost.
Decentralised oracles are utilised by several DeFi protocols, including Compound, Uniswap, SushiSwap, Balancer, and PancakeSwap.

6. BlockChain Oracles Use Cases

Oracles serve as an abstraction layer to bridge the gap between smart contracts and real-world data. Oracles are used in applications like getting financial data for DeFi applications, smart contract automation, gaming, NFTs, decentralised insurance, among others. Applications that utilize oracles include decentralised finance (DeFi), smart contract automation, gaming, NFTs, and decentralised insurance, among others. These applications leverage oracles to retrieve financial data.

7. Comparing Leading Decentralized Oracle Networks (DONs)

Decentralised oracles are the backbone of blockchain ecosystems, enabling smart contracts to securely access real-world data. From price feeds in DeFi to sports scores and weather conditions for insurance contracts, decentralised oracles play a crucial role in expanding blockchain’s utility. However, not all oracles operate the same way; different networks employ unique mechanisms to ensure data integrity, security, and decentralisation.

This article explores and compares the leading decentralised oracle networks, including Chainlink, Pyth, DIA, and API3. We’ll examine their architecture, trust models, use cases, and how they address the challenges of data accuracy and reliability in Web3 applications.

8. Chainlink

Chainlink is the world-leading decentralised oracle network that provides, complements, and enhances existing and new blockchains by providing fast, reliable, and confidentiality-preserving universal connectivity and computation for hybrid smart contracts. They provide smart contracts with real-world information in a decentralised, secure manner, enabling the use of smart contracts in wide-reaching applications. Chainlink fetches its data from diverse entities in DONs and relays data to smart contracts in "reports.". The DONs are operated by independent, security-reviewed, and performance-proven node operators. Chainlink focuses on data validation and off-chain value consensus, differing from other oracles. Chainlink also incorporates a broad range of next-generation smart contract applications and use cases with a focus on seven key areas: hybrid smart contracts, scaling, abstracting away complexity, confidentiality, order fairness, trust minimisation, and cryptoeconomic security. Chainlink’s decentralised metalayer of Oracle networks allows smart contracts to seamlessly use and create an array of decentralised services that accelerate dApp development, enable cross-chain functionality, and harmonise disparate technologies. Chainlink's decentralized oracle network metalayer enables smart contracts to seamlessly create and utilize a range of decentralized services. These services accelerate the development of decentralised applications (dApps), facilitate cross-chain functionality, and integrate diverse technologies.

Figure 3: Chainlink architecture

Some of the key features of Chainlink are included.

9. Hybrid Smart Contracts

In a literal sense, smart contracts that interact with data from the real world are known as hybrid smart contracts. They combine blockchain code with off-chain data provided by DONs. Due to this ability, the use cases and functionality of smart contracts can be expanded significantly to include things that were deemed impossible before.

10. Node Reputation System

Chainlink employs a reputation framework to assess and rank oracle nodes based on their historical performance, reliability, and data accuracy. This system incentives nodes to provide trustworthy data, as higher reputation scores can lead to more assignment opportunities and rewards. Chainlink uses a reputation system to evaluate and assign rankings to oracle nodes. These rankings are based on the nodes' past performance, reliability, and data accuracy. Nodes are incentivised to provide reliable data, as a good reputation can result in more work and rewards.

11. Data Aggregation

Accuracy of data is of paramount importance to Chainlink, so it aggregates data from multiple independent sources (nodes) for veracity and to mitigate against false information. The data is then combined into a single, reliable source and sent to the smart contract to use.

12. DIA (Decentralized Information Asset)

Decentralised information asset (DIA) is an open source DON that allows market forces to share trustable data. DIA was created to allow market actors, data users, and analysts to share digital and financial data. DIA creates an open source abstraction allowing off-chain data from various sources to be shared and interact with smart contracts for use in various financial DApps.

Figure 4: DIA's structure

DIA's focus is basically on financial data, mostly used in the DeFi space, with a focus on autonomy, transparency, and decentralisation.

13. Pyth Network

The Pyth network is an oracle for obtaining on-chain financial market data. It sources its data from “over 90 first-party data providers," which includes market agents and big exchanges. Pyth offers real-time price feeds for several cryptocurrencies, equities, exchange pairs, ETFs, and commodities for smart contract developers on more than 40 blockchains, making it a major driver of DeFi applications.

Figure 5: Pyth Data Architecture

The Pyth project began due to the need for a price oracle for ultra-low latency and institutional-quality market data. The problems were highlighted as: traditional oracles are slow, making them unsuitable for high-frequency financial applications; lack of essential price feeds on newer blockchains; opaque data sources posing risk to DeFi; and smart contract security.
The Pyth network operates as a decentralised marketplace for data; the data contributed by the individual sources, called “first parties,” is created and owned by the sources. Pyth incentivises these financial data owners to contribute directly into the blockchain.
Pyth enables publishing of financial data on-chain for dApps usage. They operate as follows:

Data providers submit price information to Pyth's Oracle program, with multiple publishers per asset to enhance accuracy and reliability.
The Pyth protocol aggregates this data, generating a single price estimate with a confidence interval.
Data users access the price information from the oracle.

Pyth is another important oracle to look at, especially if you’re into building DeFi apps for new blockchains.

14. API3

API3 is a decentralised API platform that connects Web2 APIs to decentralised applications.
API3 enables smart contracts on decentralised applications to connect with real-world data using APIs. While we’re talking about oracles in this article, API3 is an oracleless approach because of the way they facilitate on-chain and off-chain interaction. API3 connects real-world data to the blockchain directly through APIs. They allow companies to deploy their web2 APIs directly on the blockchain by using what they call "Airnodes.”

Figure 6: API3 project overview

15. Airnodes

Airnodes are cloud-based services that enable data providers to seamlessly integrate existing Web2 APIs with the blockchain, creating what’s called decentralised APIs (dAPIs). To understand the benefits of this approach, we need to first understand how data is transmitted.
Data can be grouped into first-party data and third-party data. This distinction is important for understanding the benefits of API3.
First-party data transmits data directly from the data providers, while third-party data is obtained from intermediaries that aggregate first-party data before forwarding it to the end user. API3 is based on the premise of eliminating oracles, since oracles usually transmit third-party data after aggregating several first-party data. Eliminating oracles according to API3 will allow data providers to run their own nodes, improving the quality of data. Even though this sounds contradictory, API3 has its own benefits, which include:
Transparency: Users can verify the source of their data with dAPIs, unlike Oracles, which users can’t verify and lack clarity concerning data sources.
Security: Decentralised networks are attack-prone, especially Sybil accounts where bad actors manipulate data. API3 addresses this with a collateral pool for coverage (similar to Chainlink's staking, though not yet launched) and potential legal action against public data providers, which is an option unavailable with third-party oracles.
Ease of use: API3's Airnodes are serverless and easy to deploy, requiring minimal technical expertise. Data providers don’t need blockchain knowledge or crypto handling, making it easier for traditional financial institutions to integrate their data into the blockchain.

16. Ensuring Data Integrity in Decentralized Networks

Decentralised oracle networks (DONs) play crucial roles in maintaining the integrity of off-chain data used in blockchain applications, particularly DeFi and other financial applications. Ensuring data integrity in decentralised networks is of utmost importance to prevent frauds, attacks, and other malicious activities. Mechanisms like data aggregation and verification techniques, reputation and staking models, cryptographic proofs, and governance models to improve security. Enhance security by employing mechanisms such as data aggregation, verification techniques, reputation and stake models, cryptographic proofs, and governance models.

17. Data Aggregation and Verification

Oracles aggregate data from multiple sources to reduce the probability of single points of failure, data manipulation, and inaccuracies. Aggregation ensures that outliers and erroneous values do not compromise the final data transmitted to the smart contracts. Key methods for data aggregation include using:
Median and Weighted Median Aggregation: Data is collected from multiple sources, and the median value is used to mitigate the influence of extreme values. Some oracles also apply a weighted system where sources with higher credibility get precedence.
Consensus Mechanisms: Some Oracle networks, like Chainlink and DIA, employ decentralised consensus models where a majority of nodes must agree on a data point before it is published on-chain.
Cross-Referencing with Trusted Sources: Oracles compare incoming data with publicly available, reputable sources to detect discrepancies and prevent manipulation.
Effective data aggregation and verification mechanisms are essential to preventing data manipulation and ensuring the trustworthiness of smart contract interactions.

18. Reputation and Staking Models

Decentralised oracle networks often incorporate reputation and staking systems to incentivise honest behaviour and penalise malicious actors. These models ensure that oracle nodes remain accountable and provide accurate data.
Reputation Systems: Oracles are assigned reputation scores based on their historical performance, accuracy, and reliability. Nodes with higher reputation scores are more likely to be selected for data queries. Chainlink, for instance, maintains a reputation framework where node performance is tracked transparently.
Staking Mechanisms: Many oracle networks require node operators to stake tokens as collateral, which can be partially or fully forfeited if they provide inaccurate or malicious data. Chainlink introduced a staking mechanism where staked LINK tokens serve as a security guarantee against faulty or manipulated data submissions, API3 uses a staking pool to ensure data accuracy and provide insurance against malicious activity while Pyth and DIA also integrate staking incentives to encourage honest data reporting and secure network participation.
Reputation and staking models can enhance the reliability of decentralised oracles by aligning financial incentives with truthful reporting.

19. Conclusion

Decentralised oracles are very important for intersecting real-world data and hybrid smart contracts. DeFi applications rely on oracles to provide accurate and tamper-proof data for lending protocols, derivative markets, synthetic assets, and automated market makers (AMMs). Oracles ensure that the smart contracts operate correctly based on real-world data like asset prices, interest rates, and volatility.
While centralised oracles offer efficiency, they introduce significant risks like trust and single points of failure. Decentralised ones like Pyth, Chainlink, and DIA address these issues by leveraging data aggregation and other approaches.

The Growing Sui Ecosystem: DeFi, NFTs, and Web3 Applications

Emmanuel Amoo — Sun, 19 Jan 2025 23:00:00 +0000

Introduction

The blockchain ecosystem has rapidly expanded with several new chains, protocols, and frameworks. Sui stands out as one of the most exciting developments in recent years, thanks to its low latency, innovative architecture, and developer-friendly environment, all driving its growing popularity. This article will explore how Sui is reshaping decentralised finance (DeFi), non-fungible tokens (NFTs), and broader Web3 applications.

History

Sui is a permissionless layer 1 blockchain designed to enhance both the user and developer experience. It is designed for high scalability, unrivalled speed, and low cost.

Sui's history dates back to Metas blockchain project, launched under David Marcus in 2018. The project aimed to develop a global payment system called Project Libra.

Libra developed into a large project and was designed to support global transactions; it also had numerous partnerships with major companies such as Uber, Visa, and Paypal. However, it faced regulatory hurdles, which led Meta to revamp and change its name to Diem, but the same problems arose. Diem was disbanded in 2022, and the main development team went on to found Mysten Labs. Sui's creators took the best aspects of Diem, refined them, and built a cutting-edge blockchain optimized for modern Web3 use cases such as DeFi, NFTs, and gaming.

Suis Technology and Advantages

Sui is built on several key pillars that ensure its speed, low cost, and scalability. Traditional blockchains process transactions one after another, but Sui uses parallel transaction execution. Under optimal conditions, this allows the network to handle up to 125,000 transactions per second (TPS), resulting in lightning fast transactions with very low fees.

Architecture

Suis architecture comprises several layers to ensure security, accessibility, and efficiency. This multi-layered design separates different concerns, optimising each layer for its specific functionalities. The base layer handles operations such as block validation, data storage, and network integrity while maintaining overall network security through an advanced consensus protocol. It acts as the foundation layer, ensuring stability and reliability for all other layers built on it.

The execution layer manages the processing of all transactions and the execution of smart contracts. Employing parallel transaction execution enhances stability and reduces congestion, ensuring consistent and reliable transaction processing even during periods of high network load.

The Application Layer offers developers robust tools, APIs, and frameworks to create user-centric applications. It delivers a seamless experience for end-users through intuitive interfaces and functionalities, while also encouraging innovation by simplifying the development process for blockchain-based solutions.

The service layer facilitates interaction with external systems, such as enterprise applications and data sources. It provides enhanced connectivity through standardised APIs, enabling smooth integration. Additionally, it acts as a bridge for interoperability, ensuring Sui can connect with other blockchain networks and platforms.

Through the separation of key systems into layers, SUI enhances a good experience for developers and users alike.

Move Programming Language

Sui is built using the Move programming language, which was originally developed for the Diem blockchain. Move is designed with an emphasis on security, efficiency, and accessibility. It provides tools that are beneficial for both novice and experienced developers, making it easier for anyone to participate in blockchain development.

Move is beneficial for the following reasons:

Safety-First Design: Move integrates built-in security features to protect against common blockchain vulnerabilities such as reentrancy attacks and unauthorised asset transfers. This ensures that contracts are inherently safe and secure during execution, minimising risks for developers and users.

Resource-Oriented Programming: Introduces explicit management of digital assets, treating them as unique resources that cannot be duplicated or lost inadvertently. It ensures proper ownership and transfer rules, reducing the likelihood of asset mismanagement.

Formal Verification: Allows developers to use mathematical methods to verify the correctness of their smart contracts. This ensures that contracts behave as intended, providing high reliability and reducing the chances of costly errors.

Module System: Supports modular code development, enabling developers to create reusable components for faster and more efficient application building. It encourages clean, organized, and maintainable code structures.

Type Safety: Implements a strong typing system to catch potential errors during development, ensuring no runtime errors. This enhances reliability and developer confidence in deploying production-ready code.

Move allows Sui to process transactions in parallel, drastically improving scalability and enabling near-instant finality. For developers, this means a robust set of tools and SDKs that lower the barrier to entry and encourage rapid experimentation and innovation. With initiatives such as grant programs and an open-source ethos, Sui is cultivating a vibrant developer ecosystem eager to build the next generation of decentralised applications.

DeFi on Sui

The DeFi ecosystem on Sui has been growing rapidly, with several projects offering several financial services. Sui has emerged as a premier destination for DeFi, attracting increasing financial investments and fostering the growth of stablecoins. Sui's Total Value Locked (TVL) has experienced significant growth, rising from $250 million to over $1.75 billion in the past year.

Sui has attracted interest from institutional financial players like VanEck, Franklin Templeton, and Greyscale Investments. VanEck introduced a regulated financial product backed by Sui, allowing millions of traditional investors to gain exposure to the Sui ecosystem. Franklin Templeton partnered with Sui to support ecosystem builders and deploy cutting-edge blockchain solutions. Additionally, Greyscale Investments, the worlds largest provider of digital asset products, launched the Greyscale Sui Trust, offering accredited investors an opportunity to participate in Suis growth. These investments highlight a growing trend of adopting Sui, driven by its innovative features such as lightning-fast architecture, cutting-edge design, and low transaction fees. These attributes make Sui particularly appealing to traditional finance entities looking to integrate blockchain products and technology.

Early last year, there were no stablecoins on Sui, but by the end of the year, four had been introduced: USDC, AUSD, FDUSD, and USDY. These stablecoins have been instrumental in driving liquidity and enabling seamless financial operations across the network.

This rapid growth in stablecoin offerings and liquidity indicates Sui's maturation as a DeFi ecosystem. With some of the most trusted stablecoin issuers now on Sui, the ecosystem has a strong foundation for more advanced DeFi applications and institutional-grade products. Sui has also made significant strides in increasing Bitcoin's liquidity within its system. Through SaltLayer's collaboration with Babylon, BTC liquidity will be unlocked for applications on Sui.

Aside from traditional finance, Sui is attracting a wave of decentralised exchange (DEX) protocols. Unlike Ethereum, Sui offers a better alternative for these DEXs, with benefits ranging from a more efficient liquidity network to an environment that supports rapid trade executions at low cost. Sui also has the potential for cross-chain transactions, which further enhances its appeal to the broader DeFi ecosystem.

NFTs and Gaming on Sui

Moving beyond DeFi, Sui is rapidly emerging as a hub for NFTs and blockchain gaming. Artists, creators, and developers are leveraging Suis ability to handle high-volume transactions and minimal fees to mint and trade new assets ranging from art to collectables, in-game items, and membership tokens. Sui's low gas costs make it an attractive choice for creators, enabling major NFT projects to explore its potential and mint without incurring exorbitant fees. Its lightning-fast speed facilitates seamless transactions for collectors.

At the start of last year, Sui did not have any stablecoins. However, by year-end, four stablecoins had been introduced: USDC, AUSD, FDUSD, and USDY. These stablecoins have played a vital role in enhancing liquidity and facilitating smooth financial operations across the network.

Parallel execution and distributed computing functionality make Sui an excellent choice for blockchain games. Sui enables the use of digital assets, which is a feature of blockchain technology, as in-game items give both players and game studios control. Users can store their digital assets on-chain instead of on the studio's servers, making the assets accessible both in-game and out-of-game. This allows users to transfer assets as they see fit, ensuring their availability even if the game shuts down. Suis low latency and scalability allow complex, real-time interactions in decentralised games, a game changer that wasnt feasible on more congested networks.

Web3 Applications on Sui

Suis potential reaches far beyond finance, NFTs, and gaming. Developers are exploring a wide array of innovative applications on Sui, from decentralised social media platforms and metaverse projects to robust decentralised autonomous organisations, showcasing its versatility as a foundational layer for the future of Web3. Sui's scalable infrastructure and capacity to handle complex transactions make it an ideal choice for utility applications such as decentralised social media platforms and subscription-based model dApps. Sui's versatility extends to a wide array of web3 applications, ranging from decentralised autonomous organisations (DAOs) to enterprise-grade dApps.

Challenges and Future Outlook

Sui's future holds great promise, but it also faces several challenges. The competition from established and emerging blockchains is intense, while security remains a paramount concern. The Sui community must remain vigilant in identifying and addressing potential vulnerabilities. Additionally, regulatory uncertainty poses a challenge for the broader blockchain industry, and Sui is not immune to these external pressures.

Despite these challenges, the opportunities for Sui are significant. Continued development, strategic partnerships, and a strong community focus will be crucial for realising Sui's full potential. While scalability is one of Suis strong suits, it must be maintained as adoption grows. Widespread adoption will depend on overcoming the plethora of established blockchains and convincing developers and users to migrate to a new platform.

With a clear roadmap that includes expanding cross-chain support, enhancing security features, and developing innovative developer tools, the future is bright and full of potential for Sui. As more projects build on Sui and demonstrate its capabilities, it is well-positioned to become a strong pillar of the Web3 ecosystem.

Conclusion

Sui has emerged as an innovative blockchain known for its atomic speed, low gas fees, and exceptional scalability. The ecosystem is experiencing rapid growth, fuelled by cutting-edge technology and robust developer tools. This has led to significant advancements in DeFi, NFTs, gaming, and other Web3 technologies. While challenges persist, the platform's technical advantages and focus on user experience position it as a significant player in the blockchain space. As the ecosystem continues to mature, Sui has the potential to reshape the future of digital ownership, finance, and online interaction, offering a glimpse into the next generation of the internet. Its an ecosystem worth watching, and one that promises to deliver exciting new developments in the months and years to come.

Source: https://blog.sui.io/sui-defi-in-2024/, https://www.rapidinnovation.io/post/the-sui-blockchain-guiding-the-way-in-web3, https://blog.sui.io/whats-next-in-games/#:~:text=Sui%20is%20the%20only%20blockchain,game%20without%20breaking%20the%20bank.

]]>

Achieving Responsive Design with CSS Units

Emmanuel Amoo — Thu, 21 Sep 2023 16:22:16 +0000

CSS brings out the beauty of HTML elements. CSS rules enable the specification of various properties like colour, font, margin, padding and other properties for HTML elements. Units for the respective properties can be defined and set, hence the term CSS Unit is used to describe the values of the respective properties.

Building responsive sites requires specifying values that can adapt or be scaled for the different CSS properties. There are different ways to add values to properties but two stand out amongst the rest in relation to the parent and html elements.

Adaptability is a major component while building responsive websites, the ability to scale HTML elements up and down easily and across multiple screens is greatly desired. With easy manipulation of HTML through CSS units, its easy to create adaptive and responsive designs using rem and em which are scalable CSS units. CSS units can also be called values.

Well be exploring the basics of CSS units, understanding em and rem units, how they work and their use case.

Introduction

To style HTML elements, simply apply a CSS properties-value pair to the HTML elements. The property-value relationship is known as a CSS declaration.

There are various types of units which can be applied to CSS declarations and those units affect the scalability, adaptability, responsiveness and accessibility of elements.

Adaptability and scalability apply mostly, if not entirely to length units of CSS properties which are; weight, height, length, margin, padding and font size. These units can either be absolute or relative.

Absolute units are fixed. They are the standard unit and they do not depend on other units and neither are they relative to anything. The only example is px

Relative units on the other hand are relative to something else, they are not fixed. They might be relative to their parent or root elements, browser default, device and others. Examples include; em, rem, vhand vw. They are scalable and responsive unlike the rigid and fixed px, These properties make them preferred for web development eliminating the need for massive coding of media queries for various devices.

`rem` units

Rem is a CSS unit relative to the font size of the root element. remstands for root em. The default font size for modern browsers is 16px. Rem is calculated relative to the font size of root elements which in most cases are browsers default but the default can also be set by setting the font size of the root. So, 1rem is 16px using the browser default.

Rem units are very scalable and are compatible with CSS properties that accept length as a value.

Since rem value is directly dependent on the root element, it doesnt change throughout your code no matter where its used. 1remremains 1 rem, unlike emwhich well discuss later.

Lets write a simple code:

We will analyze the correlation between parent-sibling relationships and rem implications.

Create an index.html file

<!DOCTYPE html>
<html lang="en">
<head>
    <style>
        html {
            font-size: 30px;
        }
        .container {
            display: flex;
            align-items: center;
            background-color: aquamarine;
            height: 100vh;
            width: 100wh;
        }
        .parent-rem {
            font-size: 20px;
        }
        .child-rem {
            font-size: 1rem;
        }
    </style>
    <title>Scalability</title>
</head>
<body>
    <div class="container">
    <div class="parent-rem">
        This is the parent rem
        <div class="child-rem">
            This is the child rem
            <div class="child-rem">
                This is the second child rem
            </div>
        </div>
    </div>
</div>

</body>
</html>

The remvalue responds only to the root value, which is font-size given to the HTML element. Since rem unit is only dependent on the root value which is set at 30px, the child element which is set to 1 rem takes the value of 30pxinstead of 20px , which is the value of its parent element.

`em` units

While the rem unit depends on the root element or browser default, the em unit is directly dependent on its parent element. The font-size of the parent element determines the childs em value.

Using em increases versatility in code, enabling children elements adapt to the relative sizes of their parent element. However, it is advisable to refrain from declaring font sizes anywhere apart from the root element.

The ability of em units to scale with respect to its parent element makes it ideal for responsive design, especially when building layouts, navbars and side menus.

Lets look at an example code of em units and its inheritance property

<!DOCTYPE html>
<html lang="en">
<head>
    <style>
        html {
            font-size: 30px;
        }
        .container {
            display: flex;
            align-items: center;
            justify-content: center;
            background-color: aquamarine;
            height: 100vh;
            width: 100wh;
        }
        .parent-em {
            font-size: 20px;
        }
        .child-em {
            font-size: 2em;
        }
    </style>
    <title>Scalability</title>
</head>
<body>
    <div class="container">
    <div class="parent-em">
        This is the parent em
        <div class="child-em">
            This is the child em
            <div class="child-em">
                This is the second child em
            </div>
        </div>
    </div>
</div>

</body>
</html>

em units scale according to the parent element, each individual div situated inside another div assumes a child-parent relationship and the font size is inherited, in our code, the first child em has a value of 2em which is 2*20 = 40px. The second child em assumes a parent-child relationship with the child em div. The second child em which is also 2rem is bigger than the child rem , this is because the child rem assumes a value of 40px according to its em value which was inherited from its own parent element. So, the base value em is 40px, making our second child em font size which is 2em 80px relative to its parent(child em ).

Problems associated with using em units

The problem associated with em units is its inheritance property which can lead to multiple multiplication or division of relative sizes. em should be used when modularity is required with its parent having a rem unit rather than a pxunit, any pxunit should be declared in the root element. This will ensure better responsiveness and scalability compared to when a rigid size is declared.

rem units have few problems and is the preferred unit by modern libraries and websites.

Apply and Scale

There are various use cases and applications of rem and em size unit that enable the building of highly responsive and scalable web apps, some of them are:

When designing, to ensure consistent sizes and spacing use rem, while media queries should use em.
When creating elements that function based on users' perceptions use rem otherwise, use em for elements that rely on the relative size of their parent element.
For easily accessible and customizable websites, use rem instead of the rigid px unit.
em units should only be used when modularity and precision are desired and required.

Libraries using rem

Currently, rem units are preferred for modern UI kits and CSS libraries. Some of them include:

Bootstrap 5
Tailwind CSS

Conclusion

rem and em units are scalable units and are very useful when building responsive websites that adapt to all screen sizes, they have universal support by major browsers and are used by major libraries and UI kits.

Their use cases differ but they can prove quite useful when applied correctly. This article provides use cases that can be helpful while using the units. Happy coding!

The Web Developer's Roadmap

Emmanuel Amoo — Wed, 06 Sep 2023 22:21:02 +0000

Introduction

In this quick guide, were going to explore how you can kickstart your web development career. Starting a career in web development might be tricky because of the several languages and frameworks available which can serve as a dilemma when you're just getting started. Sometimes, you learn languages and frameworks you don't have to just because you lack information in that field. This guide will point you to just what you need to know to get started as a web developer.

By the end of this guide, you'll understand the basics of web development, tools and frameworks necessary for you to get started. In all, you'll learn about:

Who is a web developer?
What is web development?
Front-end development
Back-end development
Tools & Packages
Conclusion

So, lets get started

1: Who is a Web Developer?

A web developer is a professional who builds and manages websites. A web developer can either be a front-end developer, a back-end developer or a full-stack developer.

A front-end developer is responsible for the user interface of a website or web application. They use HTML, CSS, and JavaScript to create the user interface that website visitors see and interact with. They use technologies such as HTML, CSS, JavaScript and other frameworks to create user interfaces.

A back-end developer is responsible for creating the server side of the web application. It includes the logic, functionality and data that make the website work. They use technologies like JavaScript, Java, Python, PHP and other frameworks to create web applications.

A full-stack developer is a web developer who can work on all aspects of a web application, from the user interface to the back-end code. They are skilled in both front-end and back-end development, which allows them to build complete web applications from scratch.

2: What is Web Development?

Web development is the art of developing a website, it constitutes the processes involved in the development of a website. Here, you'll learn how websites work and the differences between the front-end and back-end of a website.

How websites work

All websites are just a bunch of files stored on a computer called the server. When connected to the internet, information can be retrieved from the server through your browser. Your browser (called the client) sends a request to a server which then responds in the form of webpages. The Internet is a network of networks, connecting computers all over the world. It works through the client-server process, where clients request information from servers and servers provide that information to clients.

3: Front-end Development

Front-end is the user interface of the website, it is the part of the website that a user interacts with. To be a front-end developer, you must learn HTML, CSS and JavaScript.

HTML: HTML which stands for Hyper Text Markup Language is used to create the sites. HTML structures the document, allowing it to be displayed by the browser. HTML comprises elements that describe the order and structure of the content to be displayed by the browser. HTML is fairly easy to learn and should take you a few weeks to master along with CSS which well talk about shortly. It is however important for all web developers regardless of their stack to know HTML and its styling partner CSS which might come in handy sometimes.
CSS: CSS called Cascading Style Sheets is used for styling HTML documents. CSS allows us to use several styles, formatting and to better organize our HTML documents and give visual aesthetics. With CSS, we can add colour, and fonts, and organize the layout of our pages, making them much more presentable to our viewers. HTML and CSS go together just like brick and mortar in construction.
JavaScript: JavaScript is the language of interactivity of the web. It is the language on which the web runs. The addition of JavaScript to web design gives a dynamic overlay to the website. JavaScript equips the developer with tools to make a website and a user interact. For instance, alerts, dynamic forms, and location trackers amongst others are dynamic elements that foster interactivity.

Also, JavaScript allows us to create complex websites with plain JavaScript called vanilla JavaScript and the use of JavaScript libraries which simplify the process. Libraries like React, jQuery, Angular and Vue are popular in the front-end developers space and can be used to create several dynamic websites.

Places to Learn

To begin training as a front-end developer, there are various resources and sites to explore to get started. Websites like w3schools, freeCodeCamp, Mdn. You can also take courses on Udemy and Odin Project. There are also communities of seasoned developers with several videos on YouTube dedicated to teaching for free, just a simple search of html and css tutorial for beginners on YouTube will give loads of videos you can choose from.

4: Back-end Development

The back-end is where the logic, files and other server operation processes take place. It also contains the database which handles the user files, data and other information. The backend consists of the server, database and the application. Developers write code that moves data between the database and the client. Backend developers need the following skills:

Servers: A server is a computer where files are stored as previously mentioned. It is also the system that handles network requests.
Programming Languages: There are various programming languages backend developers can learn, unlike frontend which is very limited. Choosing a programming language for backend development will depend on the needs of the organization/developer. Languages available are Java, Python, Ruby, PHP, JavaScript, and C#. As we can see, JavaScript can be used for both frontend and backend applications. Node.js is a JavaScript run-time environment, it runs JavaScript on the server and is majorly used for backend applications.
Databases: Databases are systems for storing and handling data. Examples of databases are MongoDB, MySQL, etc.
Frameworks: Similar to the frontend, the backend developer is presented with several frameworks to allow easy and smooth development. The frameworks are available in the different backend programming languages. Frameworks contain tools and libraries that shorten development time whilst still ensuring clean and quality code. Examples are the Laravel framework, Django, Ruby on Rails, etc.
API: APIs called Application Programming Interfaces are software that allows two applications to interact with each other. APIs allow the frontend and backend applications to interact, extract and store data on the database amongst various functions.

5: Tools & Packages

There are various tools and packages you need while getting started as a web developer. They are:

Text Editors and IDEs: Text editors are software programs that enable developers to write and edit plain text. Examples are Notepad and TextEdit. With text editors, you can write HTML codes. However, text editors are limited in performance.
Version Control: Version control is a system responsible for recording changes to a file so that specific versions can be recorded over time. It keeps track of changes in your code so you can retrieve certain sections over time if you want.
Package Managers: Package managers are a collection of open-source software used to track software executables, scripts, libraries, etc. Packages managers automate the installation, configuration and removal of software packages.

6: Conclusion

Learning tech is not easy and cannot be smooth sailing. Resilience, perseverance, and grit are essential in this journey. Be prepared to spend hours debugging, reviewing code for hours, and checking for errors in your code. Patience is also required, sometimes you run into errors due to misspelt words. For backend developers, you can get courses on Udemy. Udemy has a lot of great courses taught by amazing individuals, you can read the reviews if you're unsure which to pick. So, happy coding.

Creating forms in React

Emmanuel Amoo — Wed, 23 Aug 2023 21:51:42 +0000

Introduction

Forms are essential components of the web, whether created with just HTML or with frameworks like React. Forms allow users to send data, perform basic tasks on the internet such as posting a tweet, sending a message, or online shopping, and also retrieve data. Forms are the web's foundation, and networking would not be possible without them.

Creating effectual forms is a necessity for developers because it allows them to collect data from users in a way that is efficient and easy to understand. When forms are well-designed, they can help developers avoid errors and ensure they are collecting the data they need. Additionally, effective forms can help improve the user experience by making it easy for users to provide the needed information.

Unlike HTML forms, React allows for the dynamic handling of form data. When working with forms in HTML or vanilla Javascript, it's essential to remember that the inputs can only be processed after submitting the form. This means that any changes made by the user won't be monitored until the very end of the process. However, in React, we have the ability to create states that can track every change made during the user's interaction with the form. This is a powerful tool that can significantly improve the user experience and make the process much more efficient. Information processing starts as soon as the user begins interacting with the form. This means that after submitting the form, we submit the data and pass the state that we have been tracking all along.

React presents two ways to handle data in forms: The first way is through uncontrolled components, which allow the form elements and data to be handled by the DOM. The second way is through controlled components, where the data is fully handled by React through hooks.

Prerequisites

Proficiency in HTML, particularly HTML forms and form elements, and CSS.
Knowledge of Javascript
Knowledge of the DOM
Basic knowledge of React and useState hook
A text editor for writing code

Creating Forms Through Uncontrolled Components

In uncontrolled components, the state of form elements is not managed by React, but rather by the DOM. When users input text into form fields in uncontrolled components, the browser controls the state of those elements and updates the DOM for that element.

Here, no value property is set for form elements, instead, we use the onChange event handler to receive users' input. Moving on in this tutorial, we will:

Create basic forms
Manage the state of our input with the useState hook

Creating Simple Forms

First, create a Form.js file and import react and useState

import React, { useState } from "react"

Then, export a default Form function, returning a form element within it

export default function Form () {
    return (
        <form>

        </form>
    )
}

Then, create an input element inside the form with a type and placeholder of First name and an onChange event while passing in a handleChange function. Like below

import React, { useState } from "react"

export default function Form () {
    return (
        <form>
            <input type="text" placeholder="First Name" onChange={handleChange} />
        </form>
    )
}

So, let's handle changes in the First name input using the useState hook. Lets just create a handleChange function and console.log to check for changes in our input.

The handleChange function must be nested inside the form component like below

import React, { useState } from "react"

export default function Form () {

    function handleChange() {
        console.log("Changed!")
    }

    return (
        <form>
            <input type="text" placeholder="First Name" onChange={handleChange} />
        </form>
    )
}

So, we can test and see that as we type into our input field, Changed! is printed to the console

Next, we use let to declare a firstName variable and console.log firstName to see the changes in the users input as they type

import React, { useState } from "react"

export default function Form () {

    let firstName

    console.log(firstName)

    function handleChange() {
        console.log("Changed!")
    }

    return (
        <form>
            <input type="text" placeholder="First Name" onChange={handleChange} />
        </form>
    )
}

In our onClick handler function, we pass event to our function, then we remove the console.log there, replacing it with the code

function handleChange(event) {
        firstName = event.target.value
    }

The code would appear as follows

import React, { useState } from "react"

export default function Form () {

    let firstName

    console.log(firstName)

    function handleChange(event) {
        firstName = event.target.value
    }

    return (
        <form>
            <input type="text" placeholder="First Name" onChange={handleChange} />
        </form>
    )
}

Let's execute the file and see the output in the console

We can see that despite typing repeatedly, nothing happens in our console because React cannot detect changes in firstName, so we use the useState hook to declare our variable and set a state to allow for changes in firstName.

First, we declare an array of firstName and setFirstName equal to useState which is set to an empty string

    const [firstName, setFirstName] = useState("")

Next, we pass an event object from the onClick event handler to our handleClick function, and then we replace the console.log to update the firstName state on every keystroke

function handleChange(event) {
        setFirstName(event.target.value)
    }

Then add a console.log in the body of the Form function to see the changes in user input as they type

import React, { useState } from "react"

export default function Form () {

    const [firstName, setFirstName] = useState("")

    console.log(firstName)

    function handleChange(event) {
        setFirstName(event.target.value)
    }

    return (
        <form>
            <input type="text" placeholder="First Name" onChange={handleChange} />
        </form>
    )
}

We can see that, unlike the previous attempt, React is able to detect changes in its input and update firstName accordingly.

Adding another input field to the form

We can add another input field to the form in two ways and well explore both ways in this section

A. Duplicating Our Former Code By Adding Another Hook

By duplicating our former code and editing it accurately, we can add another input field, and track and update its state in React as we formerly did.

First, we create another input field with an onChange event listener with a handleSurName function

<input type="text" placeholder="surName" onchange={handleSurName} />

We create our surName state variable with the useState hook

    const [surName, setSurName] = useState("")

The next step is to create the handleSurName function using the handleChange function as a model

import React, { useState } from "react"

export default function Form () {

    const [firstName, setFirstName] = useState("")
    const [surName, setSurName] = useState("")

    function handleChange(event) {
        setFirstName(event.target.value)
    }

    function handleSurName(event) {
        setSurName(event.target.value)
    }

    return (
        <form>
            <input type="text" placeholder="First Name" onChange={handleChange} />
            <input type="text" placeholder="surName" onchange={handleSurName} />

        </form>
    )
}

Then console.log the firstName and surName to allow us to see the output

However, if we have more inputs, we will duplicate more code, leading to poor-quality code that may make it difficult to maintain. In the next section, we will learn how to do the same thing in a cleaner and more acceptable format.

B. Combining State into Object

By combining states, we can create and maintain a single state to manage multiple inputs. This allows us to use a single state to control and manage multiple inputs, checkboxes, and radio elements. It gives us greater control, simplifies the code, and improves code quality, especially if the code is to be used by other developers.

First, we the duplicate handleSurName and state variable and replace the placeholder surName with lastName since that's easily understandable, and we pass handleChange to it

import React, { useState } from "react"

export default function Form () {

    const [firstName, setFirstName] = useState("")

    function handleChange(event) {
    }

    return (
        <form>
            <input type="text" placeholder="First Name" onChange={handleChange} />
            <input type="text" placeholder="lastName" onchange={handleChange} />

        </form>
    )
}

To create a single state that can be used by all types of input, we need to create an object in the state. A state variable can accept multiple data types, so we create the object in the state. We need to change the name of the variable from firstName to something more generic, like formFields

import React, { useState } from "react"

export default function Form () {

    const [formFields, setFormFields] = useState({
        firstName: "",
        lastName: ""
    })

    function handleChange(event) {
    }

    return (
        <form>
            <input type="text" placeholder="First Name" onChange={handleChange} />
            <input type="text" placeholder="lastName" onchange={handleChange} />

        </form>
    )
}

Unfortunately, we cannot use event.target.value to get the data from the form fields because rather than giving us our data in object form, our object will be erased and the output will be a string, which is not helpful. Since we are using the same handleChange function on both inputs, we need a way to identify which input triggered the event. To do this, we give the inputs a name property that matches the property name that we are storing


          <input 
                type="text" 
                placeholder="First Name" 
                onChange={handleChange} 
                name="firstName" 
                />

            <input 
                type="text" 
                placeholder="Last Name" 
                onChange={handleChange} 
                name="lastName" 
                />

To check if our code is working, well console.log event.target.name to check which input field is triggering the event listener. Lets test our code

With this, we have everything we need to call formFields and update our object correctly. To do this, we call setFormFields to accept changes in state and update our formFields variable respectively. Well call setFormFields in our onChange function, and then well pass our previous state (we didnt do that with strings because overwriting our file doesnt actually change anything) preventing outright overwriting of our earlier state, passing a callback function which will then return an object. The object takes in a copy of the previous state, then the specific property we want to change in the object is passed to it. This causes only the value of the property we want to change to be overwritten whilst preserving the other components of the object

import React, { useState } from "react"

export default function Form () {

    const [formFields, setFormFields] = useState({
        firstName: "",
        lastName: ""
    })

    function handleChange(event) {
        setFormFields(prevState => {
            return {
                ...prevState,
                [event.target.name]: event.target.value
            }
        })
    }

    return (
        <form>
            <input 
                type="text" 
                placeholder="First Name" 
                onChange={handleChange} 
                name="firstName" 
                />

            <input 
                type="text" 
                placeholder="Last Name" 
                onChange={handleChange} 
                name="lastName" 
                />
        </form>
    )
}

Computed properties was used to turn the dynamic string event.target.name and use it as the property name for the object. Console.log formFields to see our state as it changes

The object is initially empty but as we start typing, the object starts changing and our state remains intact.

Adding Another Input

Adding another input field will be very easy since we just have to add a new field to our state object rather than adding another event handler function and a new state.

Lets demonstrate that by adding a Username field in our state object. Kindly ensure that the name of the property in the state object is the same as the one in the input tag

import React, { useState } from "react"

export default function Form () {

    const [formFields, setFormFields] = useState({
        firstName: "",
        lastName: "",
        userName: ""
    })

    function handleChange(event) {
        setFormFields(prevState => {
            return {
                ...prevState,
                [event.target.name]: event.target.value
            }
        })
    }

    return (
        <form>
            <input 
                type="text" 
                placeholder="First Name" 
                onChange={handleChange} 
                name="firstName" 
                />

            <input 
                type="text" 
                placeholder="Last Name" 
                onChange={handleChange} 
                name="lastName" 
                />

            <input 
                type="text" 
                placeholder="Username" 
                onChange={handleChange} 
                   name="userName" 
                  />

        </form>
    )
}

Lets add favColour to the state object

const [formFields, setFormFields] = useState({
        firstName: "",
        lastName: "",
        userName: "",
        description: "",
        isTrue: true,
        tiers: "",
        favColour: ""
    })

Then, we add a name, value and the onChange event handler to the select element

<select 
                    id="favColour"
                    name="favColour"
                    value={formFields.favColour}
                    onChange={handleChange}
                    >

With those lines of code, the dropdown works as expected

However, the initial value of the select element is an empty string, but there is no option that represents the empty string. We can resolve that by creating an option element with an empty string value

<option value="">-- Choose --</option>

And this is the total code

import React, { useState } from "react"

export default function Form () {

    const [formFields, setFormFields] = useState({
        firstName: "",
        lastName: "",
        userName: "",
        description: "",
        isTrue: true,
        tiers: "",
        favColour: ""
    })

    function handleChange(event) {
        const {name, value, type, checked} = event.target
        setFormFields(prevState => {
            return {
                ...prevState,
                [name]: type === "checkbox" ? checked : value
            }
        })

    }

    return (
        <form>
            <input 
                type="text" 
                placeholder="First Name" 
                onChange={handleChange} 
                name="firstName" 
                value={formFields.firstName}
                />

            <input 
                type="text" 
                placeholder="Last Name" 
                onChange={handleChange} 
                name="lastName" 
                value={formFields.lastName}
                />

            <input 
                type="text" 
                placeholder="Username" 
                onChange={handleChange} 
                name="userName" 
                value={formFields.userName}
                />

            <textarea 
                placeholder="description"
                onChange={handleChange}
                name="description"
                value={formFields.description}
                />

            <input
                type="checkbox"
                id="isTrue"
                checked={formFields.isTrue}
                onChange={handleChange}
                name="isTrue"
                    />
                <label htmlFor="isTrue">Subscribing</label>

                <select 
                    id="favColour"
                    name="favColour"
                    value={formFields.favColour}
                    onChange={handleChange}
                    >
                    <option value="">-- Choose --</option>
                    <option value="red">Red</option>
                    <option value="blue">Blue</option>
                    <option value="yellow">Yellow</option>
                    <option value="indigo">Indigo</option>
                    <option value="orange">Orange</option>
                    <option value="violet">Violet</option>

                </select>

        </form>
    )
}

Submitting Forms

In React, the button element is used to handle the submit. By default the button element is of type submit, so well use this in our code

<button>Submit</button>

Clicking the button will cause the form to trigger the onSubmit event handler. So, we add the onSubmit event handler prop to our form with the handleSubmit function which well create

<form onSubmit={handleSubmit}>

Next, create the handleSubmit function and pass the event to it. In the body of the function, run event.preventDefault to prevent the page from refreshing, causing React to rerender the component

function handleSubmit(event) {
        event.preventDefault()
    }

This is the whole code, you can style it way you want to

import React, { useState } from "react"

export default function Form () {
    const [formFields, setFormFields] = useState({
        firstName: "",
        lastName: "",
        userName: "",
        description: "",
        isTrue: true,
        tiers: "",
        favColour: ""
    })

    function handleChange(event) {
        const {name, value, type, checked} = event.target
        setFormFields(prevState => {
            return {
                ...prevState,
                [name]: type === "checkbox" ? checked : value
            }
        })
    }

    function handleSubmit(event) {
        event.preventDefault()
    }

    return (
        <form onSubmit={handleSubmit}>
            <input type="text" 
            placeholder="First Name" 
            onChange={handleChange} 
            name="firstName" 
            value={formFields.firstName}
            />

            <input type="text" 
            placeholder="Last Name" 
            onChange={handleChange} 
            name="lastName" 
            value={formFields.lastName}
            />

            <input type="text" 
            placeholder="Username" 
            onChange={handleChange} 
            name="userName" 
            value={formFields.userName}
            />

            <textarea 
                placeholder="description"
                onChange={handleChange}
                name="description"
                value={formFields.description}
                />

              <input
                    type="checkbox"
                    id="isTrue"
                    checked={formFields.isTrue}
                    onChange={handleChange}
                    name="isTrue"
                    />
                <label htmlFor="isTrue">Subscribing</label>
                <br />

                <fieldset>

                    <legend>Choose Subscription Plan</legend>

                    <input 
                        type="radio"
                        id="tier1"
                        name="tiers"
                        value="tier1"
                        onChange={handleChange}
                        checked={formFields.tiers === "tier1"}
                    />
                    <label htmlFor="tier1">Tier 1</label>
                    <br />
                    <input 
                        type="radio"
                        id="tier2"
                        name="tiers"
                        value="tier2"
                        onChange={handleChange}
                        checked={formFields.tiers === "tier2"}
                    />
                    <label htmlFor="tier2">Tier 2</label>
                    <br />
                    <input 
                        type="radio"
                        id="tier3"
                        name="tiers"
                        value="tier3"
                        onChange={handleChange}
                        checked={formFields.tiers === "tier3"}
                    />
                    <label htmlFor="tier3">Tier 3</label>
                    <br />
                </fieldset>
                <br />

                <label htmlFor="favColour">What is your favourite colour</label>
                <br />

                <select 
                    id="favColour"
                    name="favColour"
                    value={formFields.favColour}
                    onChange={handleChange}
                    >
                    <option value="">-- Choose --</option>
                    <option value="red">Red</option>
                    <option value="blue">Blue</option>
                    <option value="yellow">Yellow</option>
                    <option value="indigo">Indigo</option>
                    <option value="orange">Orange</option>
                    <option value="violet">Violet</option>

                </select>
                <br />
                <br />

                <button>Submit</button>

        </form>
    )
}

With that, weve come to the end of this how-to guide.

Conclusion

Congratulations! You can now create forms in React. To access the source code used in this tutorial, head over to the repository to get it.

Create a Web Server in Node.js using Express and the ES6 Module

Emmanuel Amoo — Wed, 23 Aug 2023 12:12:28 +0000

When viewing a webpage in a browser, a request is made to another computer, which then generates a webpage for you as a response. The computer you send your request to is known as a web server. When you type a URL into your web browser, your computer sends a request to a web server. The web server then sends back the requested information, which is usually an HTML page or a JSON object. Node.js allows us to write backend codes in Javascript, even though Javascript has traditionally been used to write frontend codes. For this article, well be learning how to build web servers using the ES6 syntax and Express with Node.js.

Prerequisites

To run npm commands on your machine, you must first install Node.js. You can also visit here to download and install Node.js on your machine. In addition, you need to have a good grasp of JavaScript and how to create Node.js applications in particular.

What is ES6?

ES6 is the newly released version of the javascript programming language whose proper name is ECMAScript. ES6 succeeds the previous ES5 version and it was released in 2011. It adds several features to javascript such as classes and others to make development easier. You can read more here

Initializing npm and setting up your package.json to accept ES6

We need to initialize a new package.json file in the root directory of our project file by running the command below in your terminal

npm init -y

With that, wed have initialized a npm package, youll see the package.json file in your folder

In the package.json file, add "type": "module" beneath the main. Adding that line enables the ES6 modules and your package.json file should look like this:

{
  "name": "simple-server",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "type": "module",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1",
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "dependencies": {
    "express": "^4.18.2"
  },
  "devDependencies": {
    "nodemon": "^3.0.1"
  }
}

Also, install Nodemon by

npm i -save-dev nodemon

Then, add the following line as a start script in your package.json file

    "start": "nodemon --experimental-modules --es-module-specifier-resolution=node index.js"

Your code should look like this

{
  "name": "simple-server",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "type": "module",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1",
    "start": "nodemon --experimental-modules --es-module-specifier-resolution=node index.js"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "dependencies": {
    "express": "^4.18.2"
  },
  "devDependencies": {
    "nodemon": "^3.0.1"
  }
}

Installing Express

To install the express framework to create our servers, run the code below in your terminal

npm i express

Setting up your Index.js file and creating a basic server

The next thing we have to do is to create our index.js file, set up our web server by importing express using the ES6 import syntax, listen to our port and then create a get route to test if our code is working.

First, we import express using the ES6 import option and set up our app

import express from "express";
const app = express();

Next, we create our port and listen to it to get our server running

const PORT = 5000;

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

Then, we create a route to test if our server is up and running

app.get('/', (req, res) => {
    res.send('This is my server using the ES6 syntax')
});

Running the Server

Once everything has been set, we need to run our server to check if it actually worked. Run npm start in your terminal and the web server will start listening on port 5000.

Open your browser, then go to http://localhost:5000, you should see a successful response with the message: This is my server using the ES6 syntax.

If you have any issues, please double-check that you followed all of the steps correctly. This article should help you to start writing Node.js applications using the ES6 syntax, especially if you are also writing React and switching between ES5 for Node.js and ES6 for React.

Conclusion

This article teaches you how to write ES6 node.js applications without using Babel or other complex dependencies. Node does not directly support ES6 imports and will throw an error if you try to use them. However, by adding the module type and the start script, you can use Node's experimental support for ES modules, which supports ES6 syntax and allows you to type and run your code.

DEV Community: Emmanuel Amoo

Intent-Based Trading: The Next Evolution of DeFi?

What is intent-based trading?

How does it work?

Benefits of intent-based trading

Challenges and Considerations

The Future of DeFi?

WTF is Pessimistic Proof? 🤔

The Evolution of Blockchain and Aggregated Solutions

Aggregated Blockchains: A Recap

Challenges with Existing Mechanisms

How Pessimistic Proofs Address These Issues

Conclusion

Chainlink CCIP: A Secure Cross-Chain Communication Protocol

Introduction

Introducing Chainlink CCIP

CCIP Architecture and Features

CCIP Use Cases

Cross-Chain DeFi

Cross-Chain Gaming

Cross-Chain NFTs

Cross-Chain Daos

Advantages of CCIP

Security

Reliability

Scalability

Programmability

Comparing CCIP and other Cross-Chain Solutions

The Future of Cross-Chain Communication with CCIP

Architecting Scalability: Exploring AggLayer's zk-Rollup Aggregation

Introduction

Understanding Polygon

Introducing the AggLayer

Ethereum scaling challenge

Optimistic rollups

ZK rollups

AggLayer Explained

Features of the AggLayer

Use Cases and Applications

Conclusion

Checkout my new post on oracle networks

Decentralized Oracles vs. Centralized Oracles: A Deep Dive into Trust Models

Emmanuel Amoo ・ Jan 31

Decentralized Oracles vs. Centralized Oracles: A Deep Dive into Trust Models

1. Table of Contents

2. Introduction

3. Centralised Oracles and Decentralised Oracles

4. Centralized Oracles: The Trust Dilemma

5. Decentralized Oracles: A Trustless Model

6. BlockChain Oracles Use Cases

7. Comparing Leading Decentralized Oracle Networks (DONs)

8. Chainlink

9. Hybrid Smart Contracts

10. Node Reputation System

11. Data Aggregation

12. DIA (Decentralized Information Asset)

13. Pyth Network

14. API3

15. Airnodes

16. Ensuring Data Integrity in Decentralized Networks

17. Data Aggregation and Verification

18. Reputation and Staking Models

19. Conclusion

The Growing Sui Ecosystem: DeFi, NFTs, and Web3 Applications

Introduction

History

Suis Technology and Advantages

Architecture

Move Programming Language

DeFi on Sui

NFTs and Gaming on Sui

Web3 Applications on Sui

Challenges and Future Outlook

Conclusion

Achieving Responsive Design with CSS Units

Introduction

rem units

em units

Problems associated with using em units

Apply and Scale

`rem` units

`em` units