The Sui blockchain is redefining the standards of decentralized application development with its high scalability, low latency, and developer-friendly ecosystem. Built by Mysten Labs, Sui leverages a Directed Acyclic Graph (DAG)-based consensus mechanism that enables parallel transaction execution, making it one of the fastest and most efficient Layer 1 blockchains available.

Why Developers Choose Sui

Sui’s architecture is designed to overcome the limitations of traditional blockchains, such as congestion and high fees. Its ability to process independent transactions simultaneously ensures unmatched throughput and cost efficiency. For developers, Sui offers a fertile ground for building innovative decentralized applications (dApps) with minimal friction.

Resources

If you want to learn Move and Sui in-depth, check out my full course on building real projects with Move and React: academy.eincode.com.

Key Strengths of Sui:

• Scalability: Horizontal scaling allows the network to handle increasing workloads seamlessly.
• Low Latency: Transactions achieve sub-second finality, ideal for high-performance applications.
• Developer-Friendly Tools: A robust set of APIs and frameworks simplifies the dApp development process.

Move Programming Language: A Developer’s Ally

At the core of Sui’s developer ecosystem is the Move programming language. Designed specifically for blockchain use cases, Move emphasizes security and flexibility, making it an ideal choice for building smart contracts.

Why Move Stands Out:

• Resource-Oriented Design: Prevents common vulnerabilities like reentrancy attacks by treating assets as resources that cannot be duplicated or destroyed.
• Customizability: Allows developers to create tailored assets and logic for their applications.
• Efficiency: Lightweight and optimized for Sui’s high-speed infrastructure.

Move not only enhances security but also reduces complexity in building robust dApps, making it a favorite among developers.

Top Protocols on Sui That Developers Should Know

Sui’s ecosystem is rapidly expanding with innovative protocols that leverage its technical strengths. Here are some standout projects that offer exciting opportunities for developers:

1. DeepBook Protocol

https://docs.sui.io/standards/deepbook

DeepBook is a decentralized Central Limit Order Book (CLOB) designed to provide efficient and transparent trading on the blockchain. Unlike Automated Market Makers (AMMs), DeepBook enables traders to place buy and sell orders directly on-chain, ensuring precise price discovery.

• Developer Opportunities:
• Integrate DeepBook as a liquidity source for DeFi applications.
• Build advanced trading tools such as algorithmic trading bots or market-making strategies.
• Technical Highlights:
• Leverages Sui’s parallel transaction processing for high-frequency trading.
• Supports market and limit orders with sub-second settlement speeds.

2. Bluefin

https://learn.bluefin.io/bluefin

Bluefin is a decentralized exchange (DEX) specializing in derivatives trading, including perpetual futures. It combines the user experience of centralized exchanges with the transparency and security of decentralized platforms.

• Developer Opportunities:
• Create custom trading interfaces or analytics tools using Bluefin’s API.
• Build financial products like delta-neutral strategies or staking mechanisms around Bluefin’s $BLUE token.
• Technical Highlights:
• Achieves sub-second transaction finality using Sui’s high-performance infrastructure.
• Features zkLogin for seamless user onboarding without requiring wallets.

3. NAVI Protocol

https://naviprotocol.gitbook.io/navi-protocol-docs

NAVI is a decentralized liquidity protocol focused on lending and borrowing. It offers dynamic interest rates based on market conditions, making it an essential component of Sui’s DeFi ecosystem.

• Developer Opportunities:
• Build dApps that integrate NAVI’s lending pools to offer users passive income opportunities.
• Leverage NAVI’s composability to create interconnected financial solutions.
• Technical Highlights:
• Fully audited smart contracts ensure security and reliability.
• Optimized for low-latency operations on the Sui blockchain.

4. Suilend

https://docs.suilend.fi/

Suilend is another leading DeFi protocol offering decentralized lending and borrowing services. It features dual lending pools — main pools for stable assets and isolated pools for riskier tokens.

• Developer Opportunities:
• Integrate lending functionalities into multi-purpose DeFi platforms.
• Use its swap feature to enhance user experience in financial dApps.
• Technical Highlights:
• Built with Move for enhanced security and flexibility.
• Utilizes Sui’s scalability for fast and cost-effective transactions.

5. Cetus Protocol

https://cetus-1.gitbook.io/cetus-docs

Cetus is a DEX that uses a Concentrated Liquidity Market Maker (CLMM) model, enabling liquidity providers to allocate capital efficiently within specific price ranges.

• Developer Opportunities:
• Build advanced trading tools using Cetus’ SDK.
• Develop automated strategies like range orders or limit orders leveraging Cetus’ programmable liquidity features.
• Technical Highlights:
• High composability with other DeFi protocols on Sui.
• Double-token model (CETUS and xCETUS) incentivizes participation sustainably.

6. Axelar

https://docs.axelar.dev/

Axelar brings cross-chain interoperability to Sui, enabling seamless communication between different blockchains. Developers can build applications that interact with multiple ecosystems without complex bridging mechanisms.

• Developer Opportunities:
• Create multi-chain dApps that leverage assets or data from other blockchains.
• Build cross-chain DeFi platforms or NFT marketplaces with ease.
• Technical Highlights:
• Fully interoperable with major blockchain networks like Ethereum and Solana.
• Simplifies cross-chain asset transfers through its unified API.

7. Wormhole

https://wormhole.com/docs/

Wormhole is another cross-chain protocol integrated with Sui, enabling asset transfers and communication across blockchains. Its focus on interoperability makes it an invaluable tool for developers building multi-chain applications.

• Developer Opportunities:
• Enable users to move tokens seamlessly between ecosystems while leveraging Sui’s performance advantages.
• Build applications that utilize data or functionality from other chains through Wormhole integration.
• Technical Highlights:
• Supports a wide range of blockchain networks, enhancing versatility.
• Offers low-latency operations thanks to its integration with Sui.

Conclusion

The combination of Sui’s high-performance infrastructure, the secure Move programming language, and a growing ecosystem of innovative protocols creates an unparalleled environment for developers. Projects like DeepBook, Bluefin, NAVI Protocol, Cetus, Axelar, Wormhole, and Suilend showcase the vast opportunities available on this blockchain. Whether you’re interested in DeFi, cross-chain interoperability, or building entirely new use cases, Sui provides all the tools you need to succeed in today’s competitive blockchain landscape.

For developers eager to shape the future of Web3, there has never been a better time to start building on Sui!

Exploring Sui and Its Most Exciting Projects for Developers was originally published in Eincode on Medium, where people are continuing the conversation by highlighting and responding to this story.

In this article, we’ll explore how to implement time-locked coins on the Sui blockchain using the Move programming language. Time-locked coins are a crucial primitive for building secure and transparent applications, enabling functionality like vesting schedules, rewards, or governance systems. This guide focuses exclusively on the locking and unlocking mechanism, breaking it down line-by-line to ensure you fully understand the implementation.

Resources

If you want to learn Move and Sui in-depth, check out my full course on building real projects with Move and React: academy.eincode.com.

Full Contract Code: https://github.com/Jerga99/sui-jelo-coin/blob/main/contracts/jelo_coin/sources/jelo_coin.move

1. The Locker Object — Your Time-Locked Container

To enable time-locking, we need a specialized object that securely holds coins until they are eligible for release. Enter the Locker object:

public struct Locker has key, store {
 id: UID,
 unlock_date: u64,
 balance: Balance<JELO>,
}

Key Fields and Attributes:

• key: This is an “ability” in Move that enforces the addition of an id field in the struct. The id acts as a unique identifier, ensuring that the object can be stored on the blockchain.
• store: This ability allows the struct to be stored within another struct, making it suitable for hierarchical or compositional object designs.
• id: The UID field provides the Locker with a unique identifier, ensuring it is distinguishable as an independent object. This unique identifier allows the Locker to be stored and tracked on the blockchain.
• unlock_date: This field is a Unix timestamp (in milliseconds) that specifies when the coins inside the Locker can be accessed.
• balance: Instead of using Coin, we use Balance for efficient storage. Balance acts as a container for locked funds that can later be converted back to a spendable Coin.

Why Use Balance Instead of Coin?

• Coin: Represents a spendable coin, optimized for immediate transactions.
• Balance: Optimized for storage and used in scenarios where the coins are not immediately accessible, such as time-locking.

2. Minting Locked Coins

The mint_locked function handles the minting of new coin and encapsulates it in a Locker object before sending it to the recipient. Here's the implementation:

public fun mint_locked(
    mint_cap: &mut MintCapability,
    amount: u64,
    recipient: address,
    duration: u64,
    clock: &Clock,
    ctx: &mut TxContext
) {
    // 1. Mint coin
    let coin = mint_internal(mint_cap, amount, ctx);
    
    // 2. Calculate unlock time
    let start_date = clock.timestamp_ms();
    let unlock_date = start_date + duration;

    // 3. Create locked container
    let locker = Locker {
        id: object::new(ctx),
        unlock_date,
        balance: coin::into_balance(coin) // Convert Coin → Balance
    };

    // 4. Send Locker to recipient
    transfer::public_transfer(locker, recipient);
}

Key Steps Explained:

1. Mint Coin: The mint_internal function creates coins in the form of a Coin object. It ensures the minted amount does not exceed the defined supply limits for the coin.
2. Calculate Unlock Time: The current timestamp is obtained from Sui’s decentralized Clock object. Adding the specified duration to this timestamp gives us the unlock_date.
3. Create the Locker:

• A new Locker object is created, with its id generated using the object::new() function.
• The Coin object is converted into a Balance using coin::into_balance(). This makes the coins storable in the Locker.

4. Transfer the Locker: Finally, the Locker object is transferred to the specified recipient, effectively locking the coins in their account until the unlock date.

3. Withdrawing Locked Funds

The withdraw_locked function enables users to retrieve their locked coins once the specified time has passed. Here’s how it works:

entry fun withdraw_locked(locker: Locker, clock: &Clock, ctx: &mut TxContext): u64 {
    // Unwrap Locker object
    let Locker { id, mut balance, unlock_date } = locker;

    // 1. Check lock expiration
    assert!(clock.timestamp_ms() >= unlock_date, ETokenLocked);

    // 2. Convert Balance → Coin
    let locked_balance_value = balance.value();
    transfer::public_transfer(
        coin::take(&mut balance, locked_balance_value, ctx), // Magic happens here
        ctx.sender()
    );

    // 3. Cleanup empty Balance
    balance.destroy_zero();
    object::delete(id);

    // Return withdrawn amount
    locked_balance_value
}

Key Steps and Security Measures:

1. Validate Unlock Time:

• The function first checks whether the current timestamp (from the Clock) is greater than or equal to the unlock_date. If not, it throws an error (ETokenLocked), preventing premature access.

2. Convert Balance to Spendable Coin:

• The coin::take() function extracts the full value of the Balance and converts it into a spendable Coin.
• This Coin is then transferred to the sender’s account (ctx.sender()).

3. Clean Up Resources:

• The destroy_zero() function ensures that the Balance is empty after the transfer, preventing any residual values.
• The Locker’s unique ID is deleted using object::delete(), removing it from the system entirely.

Key Concepts Explained

Why Use Balance for Locked Funds?

• Efficiency: Balance is designed for storage, making it ideal for coins that are not immediately accessible.
• Security: By separating locked funds from spendable assets, it ensures strict enforcement of access restrictions.

Decentralized Clock

• Sui’s Clock object provides a globally agreed-upon timestamp, ensuring users cannot manipulate local time to unlock coins prematurely.

Safety Mechanisms

• destroy_zero: Ensures no residual value remains in the Balance after withdrawal.
• Object Deletion: Prevents reuse or duplication of the Locker object, maintaining system integrity.
• entry Modifier: Exposes the function as a transaction endpoint, allowing users to call it directly via transactions.

Visualizing the Flow

Here’s a high-level summary of the process:

1. Mint Tokens: Create coins using standard minting procedures.
2. Convert to Balance: Prepare the coins for storage by converting them into a non-spendable Balance.
3. Lock in Container: Store the Balance in a Locker with an unlock date.
4. Wait for Unlock Date: The Locker remains inaccessible until the specified time passes.
5. Validate and Unlock: Once the unlock date is reached, validate the time and convert the Balance back into spendable Coin.

Why This Matters

Time-locked coins are a versatile building block for decentralized applications. Here are some real-world use cases:

• Vesting Schedules: Founders’ coins allocations can be locked to ensure long-term commitment.
• Time-Locked Rewards: GameFi platforms can use this mechanism to reward users after achieving milestones.
• DAO Governance: Voting power can be time-locked to prevent sudden sell-offs or manipulation.

By leveraging Move’s strict type system and Sui’s decentralized architecture, this pattern ensures secure and flexible asset management.

Demystifying Coin Locking in Move on Sui: A Deep Dive was originally published in Eincode on Medium, where people are continuing the conversation by highlighting and responding to this story.

In this tutorial, we’ll break down how to create your own meme coin on Sui using Move — the blockchain’s native smart contract language. Sui’s object-centric model and developer-friendly approach make it special, and we’ll demonstrate this with actual code. By the end, you’ll understand why Sui is becoming a favorite for Web3 projects.

Complete Meme Coin Code

Full Project: https://github.com/Jerga99/sui-jelo-coin

module jelo_coin::jelo;
use sui::coin::{Self, TreasuryCap};
use sui::url::new_unsafe_from_bytes;

public struct JELO has drop {}

const TOTAL_SUPPLY: u64 = 1_000_000_000_000_000_000;

fun init(otw: JELO, ctx: &mut TxContext) {
    let (mut treasury, metadata) = coin::create_currency(
        otw,
        9,
        b"JELO",
        b"JELO",
        b"Meet JELO the cutest jellyfish meme coin...",
        option::some(new_unsafe_from_bytes(b"data:image/jpeg;base64,...")),
        ctx
    );
    mint(&mut treasury, TOTAL_SUPPLY, ctx.sender(), ctx);
    transfer::public_freeze_object(metadata);
    transfer::public_freeze_object(treasury);
}

public fun mint(
    treasury_cap: &mut TreasuryCap<JELO>,
    amount: u64,
    recipient: address,
    ctx: &mut TxContext
) {
    let coin = coin::mint(treasury_cap, amount, ctx);
    transfer::public_transfer(coin, recipient);
}

Key Components Explained

1. Module Initialization

module jelo_coin::jelo;
use sui::coin::{Self, TreasuryCap};

• Package Structure: The jelo_coin package contains the jelo module, where the logic for creating and managing the meme coin resides.
• Core Imports: The module uses Sui’s built-in coin module for token standards, simplifying development and ensuring compatibility with the Sui ecosystem.

2. Coin Configuration

public struct JELO has drop {}
const TOTAL_SUPPLY: u64 = 1_000_000_000_000_000_000;

• Purpose:
  The JELO struct serves as the core identifier for the JELO coin. It represents the unique resource associated with the token.
• drop Ability:
  The drop ability allows instances of JELO to be destroyed or discarded without requiring explicit handling, such as transferring or unpacking. This simplifies the logic for managing the resource in certain scenarios. However, in this context, the JELO struct is primarily used as a type marker for the coin and isn't directly dropped during normal operations.
• Supply Clarification:
  While the supply is represented as 1 quintillion (1_000_000_000_000_000_000) base units, the human-readable total supply is 1 billion (1_000_000_000) JELO due to the 9 decimal places defined for precision. Each JELO is divisible into 1 billion base units, meaning 1 JELO = 1 billion base units. This design follows a common pattern in meme coins, allowing for small transaction values and mimicking fiat currency subdivisions, such as cents.

3. Smart Initialization

fun init(otw: JELO, ctx: &mut TxContext) {
  let (mut treasury, metadata) = coin::create_currency(
    otw, // One-time witness
    9,   // Decimals
    b"JELO", // Symbol
    b"JELO", // Name
    b"Description...", // Description
    option::some(image_url), // Base64 image
    ctx
  );

• coin::create_currency:
  This function abstracts the complex process of creating a token by:
• Managing metadata (name, symbol, description, and logo).
• Configuring decimal precision, allowing transactions in fractional amounts.
• Ensuring the token’s properties (like its name and symbol) are immutable after initialization.
• One-Time Witness (OTW) Pattern:
  The otw parameter ensures that the initialization function is executed only once. This prevents unauthorized creation of duplicate currencies.
• Freezing Objects:
  Freezing the metadata and treasury ensures that they cannot be altered post-deployment, adding security and trustworthiness to the token.

4. Supply Management

mint(&mut treasury, TOTAL_SUPPLY, ctx.sender(), ctx);
transfer::public_freeze_object(metadata);
transfer::public_freeze_object(treasury);

• Initial Minting:
  The entire token supply is minted at the time of deployment and sent to the creator’s wallet. This is a common pattern for meme coins, allowing the creator to control initial distribution.
• Post-Deployment Immutability:
  By freezing the metadata and treasury, the token’s core properties and minting authority cannot be altered, providing assurance to users and investors that the maximum supply can ever be 1 billion coins, ensuring scarcity and value retention over time.

5. Mint Function

public fun mint(
    treasury_cap: &mut TreasuryCap<JELO>,
    amount: u64,
    recipient: address,
    ctx: &mut TxContext
) {
    let coin = coin::mint(treasury_cap, amount, ctx);
    transfer::public_transfer(coin, recipient);
}

• Controlled Minting:
  The mint function requires the TreasuryCap, which acts as the authority for minting and burning. This function is called initially in the init process, and once the treasury is frozen, it cannot be called again, preventing unauthorized inflation by ensuring no additional tokens can be created.
• Native Transfers:
  Transfers use Sui’s built-in transfer system, ensuring secure and gas-efficient token movement.

Why This Matters for Developers

Battery-Included Design

Sui provides robust, built-in modules and standards, making token creation straightforward:

• No need to write custom token standards like ERC-20.
• Automatic metadata handling, so developers don’t have to manage JSON-based metadata manually.
• Built-in support for decimals, making fractional transactions seamless.

Object Security Model

• TreasuryCap: Controls minting and burning, reducing the risk of unauthorized inflation.
• Frozen Objects: Prevent changes to critical components like metadata and supply settings.
• Ownership Rules: Enforced at the protocol level to enhance security and reduce bugs.

Gas Efficiency

• Token initialization requires only a single transaction, reducing deployment costs.
• Transactions can be batched, allowing multiple operations within a single block.
• Sui’s predictable fee structure ensures consistent and low costs.

From Code to Production

While this shows core token creation, real-world projects need:

1. Tokenomics strategies
2. Liquidity pool integration
3. Frontend with React.js (or other lib)
4. Unit testing & security audits
5. Mainnet deployment

Want to master these aspects? My Udemy course Sui Blockchain with Move & React.js — The Complete Guide covers:

✅ Full-stack dApp development
✅ Advanced tokenomics design
✅ Voting systems with shared objects
✅ React frontend integration
✅ Testnet/Devnet/Local deployment
✅ Real-world project

// Enroll today and bootstrap your career
module education::sui_development;

public fun launch_career(student: &mut Developer) {
    student.skill_level = Level::Professional;
}

Sui’s combination of Move’s safety and React’s flexibility creates perfect conditions for blockchain developers. Whether you’re building the next viral meme coin or enterprise-grade dApps, these tools provide the foundation you need.

Creating a Meme Coin on Sui Blockchain: Simplicity Meets Power was originally published in Eincode on Medium, where people are continuing the conversation by highlighting and responding to this story.

Move is a powerful and secure programming language designed specifically for building on blockchain platforms like Sui. If you’re eager to start developing on Sui, understanding Move is absolutely essential. This guide covers 11 fundamental concepts that will give you a solid foundation in Move and set you on the path to building your own Sui dApps. We’ll explain each topic concisely with practical examples.

Additional Resources

Docs: https://move-language.github.io/move/

Full Course: https://academy.eincode.com/courses/sui-dapps-with-move-react-build-real-projects

1. Modules: Organizing Your Code

Every Move source file must start with a module declaration. Modules are fundamental to how Move code is organized, acting like containers or namespaces. They help structure your project and prevent naming collisions.

module voting_system::game;

use std::string::String;

...rest of code

module voting_system::game; declares the module. voting_system is the package name (the on-chain address after deployment), and game is the module name. The combination voting_system::game uniquely identifies your code on the Sui network. The use statements import code from other modules, making it available in your module. Modules are essential for organizing your Move code and managing dependencies.

2. Structs: Defining Your Data

Structs are used to define the structure of your data. Think of them as blueprints for creating objects.

public struct Player{
    name: String,
    health: u64,
    strength: u64,
    hasWeapon: bool,
}

This defines a Player struct with a name, health, strength and hasWeapon.

To create an instance of a struct, you write:

let player = Player {
    name: b"Filip".to_string(),
    health: 100,
    strength: 2,
    hasWeapon: false,
}

3. key Ability: Storing Objects On-Chain

The key ability is essential for storing objects on the Sui blockchain. It signifies that the struct has a unique ID, which is crucial for on-chain identification and management. In Sui, almost everything is an NFT, meaning it's unique and has a unique ID.

public struct Player has key {
    id: UID, // UID is the unique identifier
    // ... other fields
}

To create an instance of a struct with key ability, you write:

let player = Player {
    id: object::new(ctx)
    // ...other fields
}

The ctx is a transaction context, we will talk about it next.

4. init Function: Initializing Your Module

The init function is special: it's automatically called once when your module is published on the blockchain. It's the ideal place to set up the initial state of your module. It must take a TxContext argument.

public struct Game has key {
    id: UID,
    max_players: u64,
    current_players: u64,
}

fun init(ctx: &mut TxContext) {
    let game = Game {
        id: object::new(ctx),
        max_players: 10,
        current_players: 0,
    };
    transfer::share_object(game); // Make the game accessible to everyone.
}

This example creates a Game object with some initial configuration (max_players, current_players) and then makes it shared using transfer::share_object. This means anyone can interact with the game, following the rules you define in your module.

The TxContext is provided by the Sui network when the module is published. It contains information about the transaction that's publishing the module, including the sender's address (ctx.sender()), which is crucial for setting up ownership and permissions. Think of it as the environment your module is running in when it's first deployed. The &mut means the init function can modify the context if needed (though it's not usually usually required). object::new(ctx) generates a unique ID for the new Game object.

5. Owned vs. Shared Objects

Sui distinguishes between owned and shared objects, which determines how they can be accessed and modified. Think of it like owning a car: if it’s owned, only you have the keys. If it’s shared, like a taxi, multiple people can use it. A frozen object is like a car in a museum — everyone can look, but no one can touch.

• Owned: Only the owner can modify an owned object.
• Shared: Anyone can modify a shared object, following the module’s rules.
• Frozen: Immutable. Everyone can view, but no one can modify.

public struct Car has key {
    id: UID,
    mileage: u64,
}

fun init(ctx: &mut TxContext) {
    let owned_car = Car { id: object::new(ctx), mileage: 0 };
    let shared_car = Car { id: object::new(ctx), mileage: 0 };

    transfer::transfer(owned_car, ctx.sender()); // Transfer ownership
    transfer::share_object(shared_car);          // Make it shared
}

• transfer::transfer(owned_car, ctx.sender()); transfers ownership of the owned_car to the transaction sender (the one who initiated the transaction). After this line executes, the sender is the sole owner of owned_car.
• transfer::share_object(shared_car); makes the shared_car a shared object. This means that anyone can interact with shared_car according to the rules defined in your smart contract. It's no longer owned by a single entity.

6. Object Handling: Managing Object Lifecycles

Move has strict rules about object management. To simulate “real-world” objects and ensure security, every object must be explicitly handled (consumed, transferred, or destroyed) before a function finishes. You can’t just create an object and let it disappear. This prevents resource leaks and ensures predictable behavior.

Let’s illustrate with an example. Imagine you want to create a Car object:

public struct Car has key {
    id: UID,
    mileage: u64,
}

fun create_car(ctx: &mut TxContext) {
    let car = Car { id: object::new(ctx), mileage: 0 };
    // This code would cause a compilation error!
    // The car object is created but not handled.
}

The previous code will not compile. Let’s fix it:

fun create_car(ctx: &mut TxContext) {
    let car = Car { id: object::new(ctx), mileage: 0 };
    transfer::transfer(car, ctx.sender()); // Transfer ownership to the sender. This fixes the error.
}

The original (incorrect) create_car function created a Car object but didn't do anything with it. Move's ownership rules require that every object be either transferred, shared, or destroyed.

The corrected create_car function uses transfer::transfer(car, ctx.sender()). ctx.sender() retrieves the address of the transaction sender (the one calling the function). transfer::transfer(car, ctx.sender()) then transfers ownership of the newly created car to that sender. This satisfies Move's ownership rules, and the code will now compile. The key is that the car object is now handled—it has an owner.

7. Capability Pattern: Secure Access Control

The capability pattern is a powerful way to manage permissions in Move. You create a special "capability" object and grant it to specific addresses. Only those holding the capability can perform certain actions.

public struct AdminCap has key {
    id: UID,
}

fun init(ctx: &mut TxContext) {
    let admin_cap = AdminCap { id: object::new(ctx) };
    transfer::transfer(admin_cap, ctx.sender()); // Give admin capability to the deployer
}

// Example usage (only the owner of AdminCap can call this)
fun sell_car(car: &mut Car, _admin_cap: &AdminCap) {
    // ... selling logic ...
}

In this example, AdminCap is a capability. The init function creates an AdminCap and gives it to the transaction sender (likely the one deploying the module). Now, only the owner of that AdminCap can successfully call the sell_car function.

Here’s why: When someone tries to call sell_car, Move's runtime automatically checks if the caller owns an AdminCap object. If the caller does NOT own the AdminCap, the transaction will fail before the sell_car function even begins to execute. No explicit checks within sell_car are required. Move's type system and ownership rules enforce this automatically. This is what makes the capability pattern so clean and secure. It shifts access control to the Move runtime, making your smart contracts more concise and less prone to errors. It's a very elegant solution for access control.

8. Dropping: Explicitly Discarding Values

Move requires you to handle all values. If you create a value, you must do something with it. Let’s see what happens if you don’t:

public struct Book {} // No 'drop' ability

fun create_book(ctx: &mut TxContext) {
    let book = Book {}; // Creates a Book object
    // This will cause a compilation error! Book must be handled.
}

This code will not compile. Because Book does not have the drop ability, Move requires you to explicitly handle the book value. You can't just create it and let it go out of scope. The compiler will complain about an unused value.

To fix this, you have two main options. If you intend to discard the value, you can give the struct the drop ability:

public struct Book has drop {} // Now has the 'drop' ability

fun create_book(ctx: &mut TxContext) {
    let book = Book {}; // Creates a Book object
    // Because Book has 'drop', it's automatically discarded 
    // at the end of the function.
}

Now the code compiles. Because Book has the drop ability, Move knows it's okay to discard it. The book value is implicitly dropped at the end of the moving function.

The other option, if you don’t want to give the struct the drop ability for some reason, is to "unpack" it:

public struct Book {} // No 'drop' ability

fun create_book(ctx: &mut TxContext) {
    let book = Book {};
    let Book {} = book; // "Unpack" the book.  This tells Move you've handled it.
}

This also compiles. The let Book {} = book; line "unpacks" the book value. Even though we're not using any of the fields within the Book struct, this line tells Move that we've acknowledged the book's existence and handled it (by effectively discarding it). This is necessary for structs without drop to avoid compiler errors.

9. Moving vs. Copying: Ownership Semantics

Move has strict ownership rules that dictate how values are handled. This is crucial for security and preventing double spending. Let’s explore the difference between copying and moving.

Copying (Primitive Types):

Primitive types like integers are copied. This means when you assign one primitive variable to another, a completely new, independent copy is created. Changes to one copy don’t affect the other.

let a = 10;
let b = a; // 'a' is copied to 'b'. 'a' and 'b' are independent.
let b = b + 2; // Modifying 'b' does not affect 'a'. 'a' is 10, 'b' is 12.

In this example, b is a copy of a. They are completely separate values in memory.

Moving (Structs — Default Behavior):

Structs, by default, are moved. When you assign one struct variable to another, the original variable becomes unusable. The value is transferred, not duplicated.

public struct Book has drop {}
let book1 = Book {};
let book2 = book1; // 'book1' is moved to 'book2'. 'book1' is no longer valid!

// Trying to use a moved value (will cause a compile error)
debug::print(&book1); // This will NOT compile! 'book1' has been moved.

Here, book1 is moved to book2. book1 is no longer a valid variable. Trying to use it will result in a compile-time error. You should write:

debug::print(&book2);

Moving and Function Arguments:

Moving also applies to function arguments. When you pass a struct to a function, it’s moved into the function’s scope.

public struct Book has key { id: UID }

fun pay(book: Book, ctx: &TxContext) {
    //... pay functionality...
    transfer::transfer(book, ctx.sender()); // Transfer book to payer
}
fun buy(ctx: &mut TxContext) {
    let book = Book { id: object::new(ctx) };
    pay(book, ctx); // 'book' is moved into the 'pay' function.

    debug::print(&book); // This will NOT compile! 'book' has been moved.
}

In this case, the book object is moved into the pay function. After the pay function is called, you can no longer use the original book variable in the buy function.

Copying Structs (Using the copy Ability):

You can enable copying for structs by giving them the copy ability. This allows you to create independent copies of structs, just like with primitive types.

public struct Book has drop, copy { 
    pages: u64 
}

let book3 = Book { pages: 100 };
let book4 = book3; // 'book3' is copied to 'book4'. Both are valid.

book4.pages = 200; // Modifying book4 does not modify book3.

debug::print(&book3.pages); // Prints 100.
debug::print(&book4.pages); // Prints 200.

Now, book4 is a copy of book3. They are independent, and changes to one don't affect the other. The copy ability is essential when you want multiple independent instances of a struct.

10. store Ability: Nesting Structs

Structs with the key ability cannot directly contain other structs. The store ability solves this.

public struct Book has key {  // Book has the 'key' ability
    id: UID,
}

public struct Shelf has key {  // Shelf also has the 'key' ability
    id: UID,
    book: Book, // Trying to store a Book in a Shelf
}

This code will not compile. Move will throw an error because Shelf (which has the key ability) is trying to contain Book (which also has the key ability, but not the store ability).

A struct with store can be contained within another struct.

public struct Book has key, store {
    id: UID,
}

public struct Shelf has key {
    id: UID,
    book: Book, // Now allowed because Book has the 'store' ability
}

11. References: Borrowing Data

References allow you to access data without taking ownership. They “borrow” the data. This is useful when you want to use a value without preventing other parts of your code from using it as well.

Basic Reference:

public struct Book has drop {}

public fun borrowing() {
    let book = Book {};
    let book_ref = &book; // 'book_ref' is a reference to 'book'
    
    // Prints the Book value.
    debug::print(book_ref); 

    // Prints the Book value (because 'book_ref' and '&book' both refer to the same data).
    debug::print(&book);    
}

Here, book_ref is a reference to book. It points to the same data in memory. No new Book object is created. Both book_ref and book can be used.

Mutable References:

You can also create mutable references, which allow you to modify the original data:

public struct Book has drop {
    pages: u64,
}

public fun borrowing_mut() {
    let mut book = Book { pages: 100 }; // 'book' is mutable
    let book_ref = &mut book; // 'book_ref' is a mutable reference to 'book'

    book_ref.pages = 1000; // Modifying through the reference

    debug::print(&book_ref.pages); // Prints 1000
    debug::print(&book.pages);     // Prints 1000 (because it's the same book)
}

Because book_ref is a mutable reference (&mut), we can change the pages field, and this change is reflected when we access book directly because they both point to the same data.

Learn More:

To deepen your Move knowledge, explore the official documentation: https://move-language.github.io/move/ or enroll in my Sui Move development course: https://academy.eincode.com/courses/sui-dapps-with-move-react-build-real-projects

Conclusion:

Congratulations! You’ve now covered 11 essential concepts for working with Move on Sui. Understanding these fundamentals is a significant step towards becoming a proficient Sui developer. Remember that practice is key. The more you code in Move, the more comfortable you’ll become with its unique features and powerful capabilities.

Learn Move for Sui: 11 Key Concepts Explained Simply was originally published in Eincode on Medium, where people are continuing the conversation by highlighting and responding to this story.

In machine learning, one of the most fundamental tasks is image classification. Multi-Layer Perceptrons (MLPs) provide an excellent foundation to understand how neural networks work. MLPs are a type of neural network composed of multiple layers of neurons, making them capable of learning complex relationships in data. In this blog post, we’ll explore how MLPs function and how to use them to classify images from the famous MNIST dataset, which contains handwritten digits.

First, Resources!

This blog article is based on this course: https://eincode.com/courses/master-neural-networks-build-with-javascript-and-react

Github Repo (Full Code): https://github.com/Jerga99/neural-network-course

What is a Multi-Layer Perceptron (MLP)?

A Multi-Layer Perceptron (MLP) is a type of artificial neural network consisting of multiple layers of neurons. It’s called “multi-layer” because it includes an input layer, one or more hidden layers, and an output layer.

• Input Layer: This layer receives the raw data. In the case of image classification, each neuron in the input layer represents one pixel. For a 28x28 image, the input layer would have 784 neurons. This layer simply passes the data to the next layer without modification.
• Hidden Layers: These layers perform the heavy lifting of the model. Each neuron in a hidden layer receives input from the previous layer, computes a weighted sum of these inputs, adds a bias, and passes the result through an activation function like ReLU. ReLU introduces non-linearity, allowing the network to capture complex patterns.
• Output Layer: The output layer generates the final prediction. For classification tasks, the output layer has one neuron per class (e.g., 10 neurons for digits 0–9 in MNIST). The softmax function converts the raw scores into probabilities, and the class with the highest probability is chosen as the prediction.

MLPs are fully connected, meaning each neuron in one layer is connected to every neuron in the next. The goal of training an MLP is to adjust the weights and biases to minimize the prediction error.

Practical Example: Classifying MNIST Digits

To demonstrate how MLPs work in practice, we’ll walk through a simple application: classifying handwritten digits from the MNIST dataset. MNIST consists of 28x28 grayscale images of digits (0–9), and the goal is to build a model that correctly identifies these digits.

Step 1: Preparing the Data

Data preparation is crucial before feeding the data into the MLP. Let’s look at how this works with the MNIST dataset:

1. Flatten the Images: MNIST images are 28x28 pixels. Since MLPs expect a vector as input, each image is “flattened” into a 1D array of 784 pixels.
2. Normalize Pixel Values: Pixel values in images range from 0 to 255. To make training more efficient, we normalize them to values between 0 and 1 by dividing by 255. This keeps the weights from getting too large and improves the learning process.
3. One-hot Encode the Labels: MNIST labels are digits from 0 to 9. We need to convert them into a format the network can understand for classification. One-hot encoding is a method where each label is transformed into a binary vector. For example, the digit “3” becomes [0, 0, 0, 1, 0, 0, 0, 0, 0, 0]. The network outputs probabilities for each class, and the position with the highest value corresponds to the predicted digit.

Pseudo code for normalization and one-hot encoding (Full Code in “Resources”)

Normalize data:
  for each image in dataset:
    for each pixel in image:
      pixel_value = pixel_value / 255  # Normalize pixel values to range [0, 1]

One-hot encode labels:
  for each label in dataset:
    create a vector of length 10 filled with zeros
    set the position of the correct label to 1

Step 2: Building the MLP Model

An MLP typically has multiple layers of neurons. For this task, we’ll build a model with:

1. Input Layer: 784 neurons (one for each pixel in the flattened image).
2. Hidden Layer: 64 neurons. This layer uses an activation function called ReLU (Rectified Linear Unit). ReLU introduces non-linearity to the model, which is important for learning complex patterns in the data.
3. Output Layer: 10 neurons, one for each possible digit (0–9). This layer uses the softmax activation function, which converts the raw output into probabilities that sum to 1. The class with the highest probability is chosen as the predicted label.

Pseudo code for model structure (Full Code in “Resources”):

MLP structure:
  Input Layer: 784 neurons
  Hidden Layer: 64 neurons, activation = ReLU
  Output Layer: 10 neurons, activation = Softmax

What is ReLU?

The ReLU activation function is defined as f(x) = max(0, x). It helps introduce non-linearity into the network because without it, the MLP would just be a linear model, which wouldn’t be able to solve complex problems. ReLU keeps all negative values at 0 and passes through positive values, which helps the network focus on important features.

Softmax ensures that the output values represent probabilities, i.e., values between 0 and 1 that sum to 1.

Step 3: Forward Propagation (Making Predictions)

Forward propagation is the process by which the network makes a prediction. During this step, the input data is passed through the network, and the model computes the output probabilities.

1. Input to Hidden Layer: The input data (a flattened image) is multiplied by the weights and biases of the hidden layer, and the result is passed through the ReLU activation function. This creates the hidden layer’s activation values.
2. Hidden Layer to Output Layer: The output of the hidden layer is passed to the output layer, where a similar process occurs. The final output is passed through the softmax activation function, which produces a probability distribution across the 10 possible classes (0–9).

Pseudo code for forward propagation:

Forward pass:
  for each neuron in hidden layer:
    hidden_sum = sum(input[i] * weight[i]) + bias
    hidden_activation = ReLU(hidden_sum)

  for each neuron in output layer:
    output_sum = sum(hidden_activation[j] * weight[j]) + bias
    output_probabilities = Softmax(output_sum)

The result of forward propagation is the network’s prediction, which is a probability distribution across the 10 possible digits.

Step 4: Backpropagation (Learning from Errors)

Backpropagation is the learning phase of the network. After making a prediction in the forward pass, the network calculates the error by comparing the prediction to the actual label. It then “propagates” this error backward through the network to update the weights and biases, minimizing future errors.

1. Calculate the Error: The error (or loss) is calculated by comparing the predicted output with the actual label. One commonly used loss function for classification is Mean Squared Error (MSE), which measures how far the predictions are from the correct values.
2. Compute Gradients: Backpropagation uses a method called gradient descent to adjust the weights and biases. The gradient tells us how much to change each weight to reduce the error. The network computes these gradients by calculating the partial derivatives of the loss function with respect to each weight and bias.
3. Update Weights and Biases: Once the gradients are computed, the network updates the weights and biases to reduce the error. The learning rate controls how large these updates are. A smaller learning rate results in slower but more precise adjustments, while a larger learning rate speeds up learning but can overshoot the optimal weights.

Pseudo code for backpropagation:

Backward pass:
  for each output neuron:
    calculate output error = predicted - target
    compute gradient for output weights and biases using the error

  for each hidden neuron:
    calculate hidden error = sum(output errors * weights)
    compute gradient for hidden weights and biases using hidden error

Update weights:
  for each weight:
    weight = weight - learning_rate * gradient

This process is repeated for each training sample. Over time, as the network adjusts its weights and biases, it learns to make better predictions.

Step 5: Training the MLP

The training process involves running forward propagation and backpropagation for multiple epochs (iterations over the entire dataset). With each epoch, the network becomes better at making accurate predictions.

1. Epochs: An epoch refers to one complete pass through the entire training dataset. Typically, training is done for several epochs (e.g., 30–50).
2. Mini-batches: Instead of updating the weights after every single training example (which can be slow), the dataset is divided into smaller mini-batches. The weights are updated after each mini-batch, speeding up training while still making accurate adjustments.

Pseudo code:

Train the model:
  for each epoch:
    shuffle training data
    for each mini-batch:
      perform forward propagation
      compute the loss
      perform backpropagation
      update the weights and biases

Step 6: Testing the Model

Once the model is trained, it’s important to evaluate its performance on unseen data (the test set). This allows us to measure how well the model generalizes to new data.

Testing the model involves running forward propagation on the test set and calculating the accuracy. The model’s accuracy is the percentage of test samples it correctly classifies.

Pseudo code for testing:

Test the model:
  correct_predictions = 0
  for each test input:
    perform forward propagation
    if predicted class == actual class:
      correct_predictions++

  accuracy = correct_predictions / total_test_samples

Why Use MLPs for Image Classification?

MLPs are an excellent starting point for building neural networks, especially for beginners. While they are powerful enough to handle various tasks, including image classification, they are not as efficient for image data as Convolutional Neural Networks (CNNs). Still, mastering MLPs is crucial because they lay the groundwork for understanding more advanced architectures. Some key benefits include:

• Simplicity: MLPs are relatively straightforward to implement, making them a great choice for learning about neural networks.
• Versatility: They can be used for a wide range of tasks beyond image classification, such as regression and natural language processing.
• Foundation for Deep Learning: Understanding how MLPs work prepares you to tackle more advanced models like CNNs, RNNs, and deep learning frameworks.

Stepping Beyond MLPs

Although MLPs are powerful for learning basic neural network concepts, they are less efficient for image data, where spatial relationships between pixels are important. This is where Convolutional Neural Networks (CNNs) come in. CNNs are designed to take advantage of the 2D structure of images and are much better suited for large-scale image classification tasks.

Learn More in My Course

In this blog, we’ve covered the basics of building a Multi-Layer Perceptron for image classification.

To dive deeper , check out my complete course on neural networks.

Mastering the Multi-Layer Perceptron (MLP) for Image Classification was originally published in Eincode on Medium, where people are continuing the conversation by highlighting and responding to this story.

The Perceptron is one of the simplest types of artificial neural networks, and it’s the foundation upon which more complex neural networks are built. In this article, we’ll walk through a basic implementation of a Perceptron in JavaScript, explaining each step in plain language to help you grasp the fundamental concepts. By the end of this post, you’ll have a solid understanding of how a Perceptron works and how it can be used to classify data.

Resources First!

Complete Perceptron Code: https://github.com/Jerga99/neural-network-course/blob/main/perceptron.js

Full Neural Networks Course: https://academy.eincode.com/courses/master-neural-networks-build-with-javascript-and-react

What is a Perceptron?

At its core, a Perceptron is a simple algorithm that can make predictions based on input data. It’s used for binary classification, meaning it can decide between two classes, like yes/no, true/false, or in our case, whether an object is more like a pencil or an eraser.

The Dataset

Let’s start with the data. We have two sets of data:

• Training Data: This is the data we use to train our Perceptron. It consists of inputs (features) and labels (the correct answer for each input).
• Test Data: After training, we use this data to see how well our Perceptron can predict new, unseen inputs.

Here’s the data we’re using:

// Train Inputs [weight(g), scale size (1–10)]
const trainInputs = [
 [2, 7],
 [3, 6],
 [1, 1],
 [1, 2],
 [2, 1]
];

// Train Labels
const trainLabels = [1,1,0,0,0];
const testInputs = [
 [2, 6], // pencil-like
 [3, 7], // pencil-like
 [1, 3], // eraser-like
 [2, 2], // eraser-like
 [2, 5] // pencil-like
];
// Test Labels
const testLabels = [1, 1, 0, 0, 1];

• Inputs: Each input is a pair of numbers representing an object’s weight (in grams) and its size on a scale from 1 to 10.
• Labels: Each label is either 1 (pencil-like) or 0 (eraser-like).

The Perceptron Model

The Perceptron algorithm works by calculating a weighted sum of the input features and then applying an activation function to decide the output. Here’s the basic structure of our Perceptron class:

class Perceptron {
 constructor(learningRate = 0.01) {
 this.weights = Array(2).fill(0).map(() => Math.random() * 0.3–0.1);
 this.bias = 0;
 this.learningRate = learningRate;
 }

activationFunction(sum) {
 return sum > 0 ? 1 : 0;
 }
}

• Weights: These are numbers that determine how important each input feature is.
• Bias: This is an extra parameter that helps the Perceptron model data that isn’t perfectly centered around the origin.
• Learning Rate: This controls how much we adjust the weights in each training step.

The Training Process

Training the Perceptron involves the following steps:

1. Calculate the Weighted Sum: For each input, we multiply each feature by its corresponding weight and add them up. Then, we add the bias to this sum.

let sum = this.bias;
for (let i = 0; i < inputs.length; i++) {
  sum += inputs[i] * this.weights[i];
}

2. Apply the Activation Function: The activation function checks if the weighted sum is greater than 0. If it is, the Perceptron predicts 1, otherwise it predicts 0.

const prediction = this.activationFunction(sum);

3. Update Weights and Bias: If the prediction doesn’t match the actual label, we update the weights and bias to make the Perceptron better at predicting next time.

if (label != prediction) {
  for (let i = 0; i < this.weights.length; i++) {
    this.weights[i] += this.learningRate * (label - prediction) * inputs[i];
  }
  this.bias += this.learningRate * (label - prediction);
}

Training the Perceptron

We train the Perceptron over several epochs. An epoch means going through the entire training dataset once. Here’s the training loop:

const EPOCHS = 3;
const perceptron = new Perceptron(0.01);

for (let epoch = 0; epoch < EPOCHS; epoch++) {
  perceptron.train(trainInputs, trainLabels);

  // Calculate accuracies
  const trainingAccuracy = calculateAccuracy(trainInputs, trainLabels);
  const testingAccuracy = calculateAccuracy(testInputs, testLabels);

  console.log(`Epoch ${epoch + 1}`);
  console.log(`Training Accuracy: ${trainingAccuracy}%`);
  console.log(`Testing Accuracy: ${testingAccuracy}%`);
  console.log("-------------------------------------")
}

• After each epoch, we calculate the accuracy on both the training data and the test data. This helps us understand how well the Perceptron is learning.

Results

Finally, we print out the weights and bias after training. These values show how the Perceptron is set up to make predictions:

console.log("weights: " + perceptron.weights);
console.log("bias: " + perceptron.bias);

Training and Testing Accuracy: What Do They Mean?

After training your Perceptron, you’ll calculate the accuracy on both the training and test datasets. Here’s what these metrics tell you:

• Training Accuracy: This measures how well your Perceptron performs on the training data it has seen before. High training accuracy indicates that your model has learned the patterns in the training data effectively.
• Testing Accuracy: This measures how well your Perceptron performs on new, unseen data (the test set). High testing accuracy suggests that your model can generalize well to new data, which is crucial for any machine learning model.

Overfitting vs. Underfitting:

• Overfitting: If your training accuracy is very high but your testing accuracy is low, your model may be overfitting. This means it has learned the training data too well, including noise or irrelevant patterns, and doesn’t perform well on new data.
• Underfitting: If both training and testing accuracy are low, your model might be underfitting, meaning it hasn’t learned the data well enough. This could be due to insufficient training or a model that’s too simple.

Conclusion

In this article, we walked through a simple implementation of a Perceptron in JavaScript. We started with a basic understanding of the Perceptron, explored the training process, and then examined the results. The Perceptron is a powerful yet simple tool for binary classification tasks, and understanding it lays the groundwork for more advanced machine learning models.

Feel free to experiment with the code, tweak the learning rate, or try different datasets. Understanding the basics is key to mastering more complex concepts in machine learning!

To learn more, check the ‘Resources’ section at the beginning of this article.

Cheers,

Filip

Master Neural Networks: The Perceptron was originally published in Eincode on Medium, where people are continuing the conversation by highlighting and responding to this story.

Introduction

As developers, integrating data analysis and prediction models is crucial. Simple Linear Regression, a fundamental machine learning technique, helps us understand relationships between variables and make predictions. In this post, we’ll implement simple linear regression using React and Plotly, covering the mathematical background and providing step-by-step coding instructions.

Resources

Full Course: https://academy.eincode.com/courses/machine-learning-primer-with-js-regression

Full Code: https://github.com/Jerga99/ML-Regression-vol1

Mathematical Background of Simple Linear Regression

Simple Linear Regression is used to predict the value of a dependent variable (Y) based on the value of an independent variable (X). The relationship between X and Y is modeled by fitting a linear equation to observed data.

The linear equation can be represented as:

Where:

• Y is the dependent variable (exam scores).
• X is the independent variable (study hours).
• b0​ is the intercept of the regression line (the value of Y when X is 0).
• b1 is the slope of the regression line (the change in Y for a one-unit change in X).

Calculating the Parameters

To find the best-fitting line, we need to calculate b0​ and b1​ using the following formulas:

Where:

• Xi​ and Yi​ are the individual sample points.
• x̄ and ȳ are the means of X and Y, respectively.

Setting Up the Data

Let’s start by setting up our data in a React component. We’ll use two arrays to represent our study hours and corresponding exam scores.

const studyHoursData = [1, 2, 3, 4, 5];
const examScoresData = [55, 70, 80, 85, 90];

Calculating the Means

The next step is to calculate the means of our data sets.

const meanStudyHours = studyHoursData.reduce((sum, val) => sum + val, 0) / studyHoursData.length;
const meanExamScores = examScoresData.reduce((sum, val) => sum + val, 0) / examScoresData.length;

Building the React Component

Now, we’ll build a React component that will perform the regression calculations and display the results using Plotly for visualization.

import { useEffect, useState } from 'react';
import Plot from "react-plotly.js";

function ExamScorePrediction() {
  const [regressionLine, setRegressionLine] = useState([]);
  const [regressionParams, setRegressionParams] = useState({b0: 0, b1: 0});
  const [inputHours, setInputHours] = useState("");
  const [predictedScore, setPredictedScore] = useState(null);

  const data = [{
    x: studyHoursData,
    y: examScoresData,
    mode: "markers",
    type: "scatter",
    marker: { color: "blue" }
  }, {
    x: studyHoursData,
    y: regressionLine,
    mode: "lines",
    type: "scatter",
    name: "Regression Line",
    line: {color: "red"}
  }];

  const layout = {
    title: "Study hours vs Exam Scores",
    xaxis: {
      title: "Study hours",
      autorange: true,
    },
    yaxis: {
      title: "Exam scores",
      autorange: true,
    },
  }

  useEffect(() => {
    if (inputHours === "") {
      setPredictedScore(null);
    } else if (parseFloat(inputHours) >= 0) {
      const score = regressionParams.b0 + regressionParams.b1 * parseFloat(inputHours);
      setPredictedScore(score <= 100 ? score.toFixed(2) : 100);
    }
  }, [inputHours, regressionParams]);

  useEffect(() => {
    trainModel();
  }, []);

  useEffect(() => {
    if (regressionParams.b0 > 0 && regressionParams.b1 > 0) {
      // Model Testing
      const predictionsFromInputs = studyHoursData.map((x) => regressionParams.b0 + regressionParams.b1 * x);
      const residuals = predictionsFromInputs.map((y, i) => examScoresData[i] - y);

      const ssResiduals = residuals.reduce((sum, residual) => sum + Math.pow(residual, 2), 0);
      const ssTotal = examScoresData.reduce((sum, score) => sum + Math.pow(score - meanExamScores, 2), 0);

      const r2 = 1 - (ssResiduals / ssTotal);
      const mae = residuals.reduce((sum, residual) => sum + Math.abs(residual), 0) / residuals.length;
      const mse = residuals.reduce((sum, residual) => sum + Math.pow(residual, 2), 0) / residuals.length;

      console.log(mse);
      console.log(mae)
      console.log(r2);
    }
  }, [regressionParams]);

  const trainModel = () => {
    // Step 1 - Compute means
    // Step 2 - Compute Slope (B1, m)
    const numerator = studyHoursData.reduce((sum, hour, i) => sum + (hour - meanStudyHours) * (examScoresData[i] - meanExamScores), 0);
    const denominator = studyHoursData.reduce((sum, hour) => sum + Math.pow(hour - meanStudyHours, 2) ,0);
    const b1 = numerator / denominator;
    const b0 = meanExamScores - b1 * meanStudyHours;

    const regressionYs = studyHoursData.map(x => b0 + b1 * x);
    setRegressionLine(regressionYs);
    setRegressionParams({b0, b1});
  }


  return (
    <div>
      <div style={{textAlign: "center"}}>
        <input
          type="number"
          value={inputHours}
          onChange={(e) => {
            setInputHours(e.target.value);
          }}
          placeholder="Enter study hours"
          style={{marginBottom: 10}}
        />
        { predictedScore &&
          <div>
            Predicted exam score: {predictedScore}
          </div>
        }
        <div>b0: {regressionParams.b0}</div>
        <div>b1: {regressionParams.b1}</div>
      </div>
      <Plot
        style={{width: "100%", height: 500}}
        data={data}
        layout={layout}
      />
    </div>
  );
}

export default ExamScorePrediction;

Code Explanation

Component State and Data

• State Variables:
• regressionLine: Stores the y-values of the regression line.
• regressionParams: Holds the slope (b1) and intercept (b0) of the regression line.
• inputHours: Keeps track of the user's input for study hours.
• predictedScore: Stores the predicted exam score based on the input hours.
• Data for Plotly:
• We create two objects in the data array: one for the scatter plot of the original data points and one for the regression line.

Layout for Plotly

• Layout Object:
• Defines the title and axis labels for the plot to provide a clear and informative visualization.

useEffect Hooks

• Predicted Score Calculation:
• This hook updates the predicted score whenever inputHours or regressionParams changes. If the input is valid, it calculates the predicted score using the regression equation and updates the state.
• Model Training:
• This hook calls the trainModel function to calculate the regression parameters when the component mounts.
• Logging Metrics:
• This hook calculates and logs regression metrics (MSE, MAE, R2) whenever the regression parameters are updated, helping us evaluate the model’s performance.

Train Model Function

• Training the Model:
• Calculates the slope (b1) and intercept (b0) using the formulas for simple linear regression.
• Computes the y-values for the regression line and updates the state with these values and the regression parameters.

Explaining the trainModel Function

The trainModel function is the core part of the code where the simple linear regression model is trained. This involves calculating the slope (b1) and intercept (b0) of the regression line, which are then used to predict the dependent variable based on the independent variable. Let's break down each step of the function:

1. Compute Means

Before calculating the slope and intercept, we need the means of the independent (study hours) and dependent (exam scores) variables, which are precomputed as meanStudyHours and meanExamScores.

2. Compute the Slope (b1)

The slope (b1) indicates the change in the dependent variable for a one-unit change in the independent variable. It is calculated using the formula:

In the code:

const numerator = studyHoursData.reduce((sum, hour, i) => sum + (hour - meanStudyHours) * (examScoresData[i] - meanExamScores), 0);

• Numerator Calculation:
• This line calculates the sum of the product of the deviations of each data point from their respective means.
• hour - meanStudyHours: The deviation of each study hour from the mean study hours.
• examScoresData[i] - meanExamScores: The deviation of each exam score from the mean exam scores.
• The product of these deviations is summed up for all data points.

const denominator = studyHoursData.reduce((sum, hour) => sum + Math.pow(hour - meanStudyHours, 2), 0);

• Denominator Calculation:
• This line calculates the sum of the squared deviations of each study hour from the mean study hours.
• Math.pow(hour - meanStudyHours, 2): The square of the deviation of each study hour from the mean.
• These squared deviations are summed up for all data points.

const b1 = numerator / denominator;

• The slope b1 is then calculated as the ratio of the numerator to the denominator.

3. Compute the Intercept (b0)

The intercept (b0) is the value of the dependent variable when the independent variable is zero. It is calculated using the formula:

In the code:

const b0 = meanExamScores - b1 * meanStudyHours;

• The intercept b0 is computed by subtracting the product of the slope (b1) and the mean of the independent variable (meanStudyHours) from the mean of the dependent variable (meanExamScores).

4. Compute the Regression Line Values

Using the slope (b1) and intercept (b0), we can now calculate the predicted values (y-values) for the regression line.

const regressionYs = studyHoursData.map(x => b0 + b1 * x);

• Predicted Values:
• This line computes the predicted exam scores (regressionYs) for each study hour in the dataset.
• For each study hour x, the predicted value is calculated as b0+b1⋅x.

5. Update State

Finally, we update the state with the calculated regression line values and parameters.

setRegressionLine(regressionYs);
setRegressionParams({b0, b1});

• setRegressionLine: Updates the state with the array of predicted values (regressionYs), which will be used to plot the regression line.
• setRegressionParams: Updates the state with the calculated slope (b1) and intercept (b0).

Understanding R², MAE, and MSE in Simple Linear Regression

When evaluating the performance of a regression model, it’s crucial to understand how well the model’s predictions align with the actual data. Three common metrics used for this purpose are the R² (R-squared) value, the Mean Absolute Error (MAE), and the Mean Squared Error (MSE). Let’s break down these metrics and see how they are calculated and interpreted.

1. R-squared (R²)

R², also known as the coefficient of determination, measures the proportion of the variance in the dependent variable that is predictable from the independent variable. It ranges from 0 to 1, where:

• 0 means that the model does not explain any of the variance in the dependent variable.
• 1 means that the model explains all the variance in the dependent variable.

Calculation of R²

The formula for R² is:

Where:

• SSresidual​ is the sum of squares of residuals, which measures the variance of the residuals (the difference between observed and predicted values).
• SStotal​ is the total sum of squares, which measures the total variance in the observed data.

In the code:

const ssResiduals = residuals.reduce((sum, residual) => sum + Math.pow(residual, 2), 0);
const ssTotal = examScoresData.reduce((sum, score) => sum + Math.pow(score - meanExamScores, 2), 0);
const r2 = 1 - (ssResiduals / ssTotal);

• ssResiduals is calculated by summing the squared residuals.
• ssTotal is calculated by summing the squared differences between each observed value and the mean of the observed values.
• r2 is then computed as 1 − (ssResiduals / ssTotal​).

2. Mean Absolute Error (MAE)

MAE measures the average magnitude of the errors in a set of predictions, without considering their direction. It is the average over the absolute differences between the predicted and actual values. MAE gives an idea of how wrong the predictions were on average.

Calculation of MAE

The formula for MAE is:

Where:

• n is the number of observations.
• yi is the actual value.
• ŷi​ is the predicted value.

In the code:

const mae = residuals.reduce((sum, residual) => sum + Math.abs(residual), 0) / residuals.length;

• mae is calculated by summing the absolute values of the residuals and then dividing by the number of observations.

3. Mean Squared Error (MSE)

MSE measures the average of the squares of the errors — that is, the average squared difference between the estimated values and the actual value. It gives a sense of the variance of the prediction errors.

Calculation of MSE

The formula for MSE is:

In the code:

const mse = residuals.reduce((sum, residual) => sum + Math.pow(residual, 2), 0) / residuals.length;

• mse is calculated by summing the squared residuals and then dividing by the number of observations.

Conclusion

By following this detailed guide, you now have a comprehensive understanding of how to implement simple linear regression in a React application using Plotly for visualization. We’ve covered the mathematical background, data setup, and step-by-step code explanation to ensure you grasp the core concepts and practical implementation.

Feel free to experiment with the code and dataset to gain a deeper understanding of how linear regression works and how it can be applied in different scenarios. As developers, integrating such statistical methods into our applications can significantly enhance data analysis and predictive capabilities. Happy coding!

Machine Learning: Simple Linear Regression with React JS and Plotly was originally published in Eincode on Medium, where people are continuing the conversation by highlighting and responding to this story.

Introduction

Uploading images is a common feature in many web applications. By using Firebase and Next.js, we can create a robust and efficient image upload system. Firebase provides a scalable backend solution, while Next.js offers a powerful framework for building React applications.

In this post, we’ll cover:

• Setting up a Firebase project
• Integrating Firebase with Next.js
• Implementing the image upload functionality
• Viewing uploaded images in a gallery

Resources

Video Tutorial:https://youtu.be/Y-kwlvhR7Z0

Full Courses: https://academy.eincode.com/

Prerequisites

Before we begin, make sure you have the following:

• Basic knowledge of React and Next.js
• A Firebase account
• Node.js and npm installed on your machine

Step 1: Setting Up Firebase

First, you need to create a Firebase project. Follow these steps:

1. Go to the Firebase Console.
2. Click on “Add project” and follow the prompts to create a new project.
3. Once your project is created, navigate to the “Storage” section and click on “Get started” to enable Firebase Storage.

Next, you’ll need to add a Firebase configuration file to your Next.js project:

1. Click on the “Settings” icon in the Firebase Console and select “Project settings”.
2. Under “Your apps”, click on the web icon to create a new web app.
3. Copy the Firebase configuration object.

Step 2: Integrating Firebase with Next.js

Create a new Next.js project if you don’t already have one:

npx create-next-app next-firebase-image-upload
cd next-firebase-image-upload

Install Firebase:

npm install firebase

Create a firebaseConfig.js file in the src/app directory and add the Firebase configuration:

// src/app/firebaseConfig.js

import { initializeApp } from "firebase/app";
import { getStorage } from "firebase/storage";

// Your Firebase configuration object
const firebaseConfig = {
  apiKey: "your_api_key",
  authDomain: "your_auth_domain",
  projectId: "your_project_id",
  storageBucket: "your_storage_bucket",
  messagingSenderId: "your_messaging_sender_id",
  appId: "your_app_id"
};

// Initialize Firebase app
const app = initializeApp(firebaseConfig);

// Get a reference to the storage service
const storage = getStorage(app);

export { storage };

Step 3: Creating the Home Page

Create a page.js file in the src/app directory to serve as the home page:

import Link from "next/link";

export default function Home() {
  return (
    <main>
      <h1>Welcome to Image Upload App!</h1>
      <nav>
        <ul>
          {/* Link to the Upload Image page */}
          <li><Link href="/upload">Upload Image</Link></li>
          {/* Link to the Gallery page */}
          <li><Link href="/gallery">View Gallery</Link></li>
        </ul>
      </nav>
    </main>
  );
}

Step 4: Implementing the Image Upload Page

Create an upload/page.js file in the src/app directory to handle image uploads:

"use client"

import Image from "next/image";
import { useState } from "react";
import { ref, uploadBytes, getDownloadURL } from "firebase/storage";
import { storage } from "../firebaseConfig";

export default function Upload() {
  const [file, setFile] = useState(null); // State to store the selected file
  const [uploading, setUploading] = useState(false); // State to indicate the upload status
  const [uploadedUrl, setUploadedUrl] = useState(null); // State to store the uploaded image URL

  const handleFileChange = (event) => {
    setFile(event.target.files[0]); // Set the selected file
  };

  const handleUpload = async () => {
    if (!file) return; // Return if no file is selected

    setUploading(true); // Set uploading state to true
    const storageRef = ref(storage, `images/${file.name}`); // Create a reference to the file in Firebase Storage

    try {
      await uploadBytes(storageRef, file); // Upload the file to Firebase Storage
      const url = await getDownloadURL(storageRef); // Get the download URL of the uploaded file
      setUploadedUrl(url); // Set the uploaded image URL
      console.log("File Uploaded Successfully");
    } catch (error) {
      console.error('Error uploading the file', error);
    } finally {
      setUploading(false); // Set uploading state to false
    }
  };

  return (
    <div>
      <input type="file" onChange={handleFileChange} /> {/* File input to select the image */}
      <button onClick={handleUpload} disabled={uploading}>
        {uploading ? "Uploading..." : "Upload Image"} {/* Button to upload the image */}
      </button>
      {uploadedUrl && (
        <div>
          <p>Uploaded image:</p>
          <Image
            src={uploadedUrl}
            alt="Uploaded image"
            width={300}
            height={300}
            layout="responsive"
          />
        </div>
      )}
    </div>
  );
}

Step 5: Creating the Gallery Page

Create a gallery/page.js file in the src/app directory to display uploaded images:

"use client"

import { listAll, ref, getDownloadURL } from "firebase/storage";
import { useEffect, useState } from "react";
import { storage } from "../firebaseConfig";
import Image from "next/image";

export default function Gallery() {
  const [images, setImages] = useState([]); // State to store the list of image URLs

  useEffect(() => {
    const fetchImages = async () => {
      const imagesRef = ref(storage, "images/"); // Reference to the images directory in Firebase Storage

      try {
        const result = await listAll(imagesRef); // List all items in the images directory
        const urls = await Promise.all(result.items.map(item => getDownloadURL(item))); // Get the download URLs for all images
        setImages(urls); // Set the list of image URLs
      } catch (error) {
        console.error("Error fetching images", error);
      }
    };

    fetchImages(); // Fetch images when the component mounts
  }, []);

  return (
    <div>
      <h1>Gallery</h1>
      <div style={{ display: "flex", flexDirection: "row" }}>
        {images.map((url, index) => (
          <div key={url} style={{ margin: 10, position: 'relative', width: '300px', height: '500px' }}>
            <Image
              src={url}
              alt={`Image ${index}`}
              sizes="300px"
              fill
              style={{
                objectFit: 'contain',
              }}
            />
          </div>
        ))}
      </div>
    </div>
  );
}

Conclusion

You now have a simple image upload feature integrated into your Next.js application using Firebase. This setup includes the ability to upload images and view them in a gallery. You can expand this with additional functionality like user authentication, file metadata, and more advanced error handling.

Feel free to check out the GitHub repository for the complete code.

If you found this tutorial helpful, please give it a clap and share it with others. Stay tuned for more tutorials and tips on web development!

Simple Image Upload with Firebase in Next.js was originally published in Eincode on Medium, where people are continuing the conversation by highlighting and responding to this story.

Greetings, aspiring developers and coding enthusiasts! If you’ve ever been curious about the world of programming, I’ve got the perfect adventure lined up for you. Introducing our Python & Turtle: A Practical Guide for Beginners and Beyond— a dynamic journey designed for beginners and early-stage developers looking for a hands-on, practical introduction to Python.

Course

https://bit.ly/3R9unow

Let me start with why you should consider learning Python.

1. Python’s Readability: The Language of Clarity

One of Python’s standout features is its readability. Code is often described as “executable pseudocode,” making it clear and concise. This readability not only makes Python an excellent language for beginners but also enhances collaboration among developers. Dive into Python, and you’ll find yourself in a coding environment that feels almost like reading plain English.

2. Versatility: A Language for Every Realm

Python isn’t confined to a single domain; it’s a versatile language that transcends boundaries. Whether you’re delving into web development, data analysis, machine learning, artificial intelligence, games or automation, Python is your trusty companion. Explore how Python seamlessly adapts to various applications, opening up a world of possibilities for developers.

3. Pythonic Zen: Embracing Elegance and Simplicity

The Python community has a set of guiding principles known as the Zen of Python. These principles emphasize the beauty of simplicity, readability, and elegance in code. Discover how embracing the Pythonic way can elevate your coding experience, emphasizing the importance of clarity and straightforward solutions.

4. The Power of Libraries: A Developer’s Arsenal

Python boasts an extensive library ecosystem that empowers developers to achieve more with less effort. From Django for web development to TensorFlow for machine learning, Python libraries are a treasure trove of tools. Uncover how tapping into this rich library ecosystem can supercharge your projects and streamline your development journey.

5. Python’s Role in Cutting-Edge Technologies

Python isn’t just a language; it’s at the forefront of cutting-edge technologies. Explore its pivotal role in machine learning and artificial intelligence. Delve into how Python is driving innovation in fields like data science, where it has become the go-to language for analysis and visualization.

6. Community and Collaboration: Pythonic Bonds

Joining the Python community means stepping into a world of collaboration and support. Discover how the community’s inclusive nature fosters learning and growth. From local meetups to global conferences, Python enthusiasts come together to share knowledge, solve problems, and celebrate the beauty of coding in Python.

What’s in Store for You?

In the first leg of our journey, we’ll explore the core concepts of Python programming. We won’t bore you with mundane lectures; instead, expect engaging sessions that lay a strong foundation for your Python journey. From variables and simple data types to hands-on assignments in string manipulation and conditional statements, I am here to sharpen your coding skills.

As we progress, we’ll delve into crucial topics such as loops, iterations, functions, and debugging techniques. This isn’t just about learning the syntax; it’s about developing problem-solving skills that are crucial for becoming a proficient Python developer. Real-world Code Interview assignments, including Fibonacci sequences and sorting algorithms, will be your playground.

Next up, get ready for a deep dive into object-oriented programming. We’re dedicating a substantial part of the course to classes, methods, and inheritance — consider this your passport to the more exciting and advanced topics waiting for you later on.

Now, let’s make it visual! Explore the Turtle module for captivating visuals, graphics, and visualization. Ever dreamt of creating your own game? We’re introducing advanced concepts like update loops, delta times, and movement, all using pure Python code. It’s not just about coding; it’s about creating and bringing your ideas to life.

In the final sections of the course, user interfaces take center stage. Learn to create a simple interface, complete with text display, buttons, and event handling. Unleash the power of lambda functions in Python, adding a valuable tool to your coding toolkit. Cap it off with a hands-on final project — your chance to showcase what you’ve learned in the world of game development.

Python & Turtle: A Practical Guide for Beginners and Beyond was originally published in Eincode on Medium, where people are continuing the conversation by highlighting and responding to this story.

1. Setup

Clone or download the initial project

https://github.com/Jerga99/nextjs-chatgpt-integration

The whole setup is explained in the readme file

If you are more interested in a video tutorial, watch my youtube video explaining the same stuff.

Ok, let’s get to work! After you initialize the project, you should have this basic layout.

2. Get prompt data

All changes will be performed in src/pages/index.js

export default function Home() {
  const [prompt, setPrompt] = useState("");

  return (
    <div className="container">
      <div className="inputContainer">
        <textarea
          onChange={(e) => {
            setPrompt(e.target.value);
          }} 
          value={prompt}
          placeholder="Ask a question" 
          rows={3} 
        />
      </div>
      ... rest of the template
    </div>
  )
}

The critical part is providing onChange to textarea to store values in the prompt state. Now when a user writes to textarea, values get stored.

3. Simulate messaging

As we submit the prompt, we want to display the message in the UI. Also, we want to simulate the response from ChatGPT. For now, the response will be just some hardcoded string.

export default function Home() {
  const [prompt, setPrompt] = useState("");
  const [messages, setMessages] = useState([]);

  const handleSubmit = async () => {
    if (prompt.trim().length === 0) {
      return;
    }

    setMessages((messages) => [...messages, {
      text: prompt.trim(),
      id: new Date().toISOString(),
      author: "human"
    }]);

    setPrompt("");

    await new Promise((res) => setTimeout(res, 1000));

    setMessages((messages) => [...messages, {
      text: "Just some hardcoded response bla bla bla...",
      id: new Date().toISOString(),
      author: "ai"
    }]);
  }

  return (
    <div className="container">
      <div className="inputContainer">
        <textarea
          onChange={(e) => {
            setPrompt(e.target.value);
          }} 
          value={prompt}
          placeholder="Ask a question" 
          rows={3} 
        />
        <button 
          onClick={handleSubmit}
          className="submit">Submit
        </button>
      </div>
      ... rest of the template
    </div>
  )
}

Let’s add the state to store the messages first.

const [messages, setMessages] = useState([]);

Next, we add the function handleSubmit, which gets called when a user clicks the submit button.

Let’s talk about this function. First, we ensure that we provide the data in the prompt. If the prompt is empty, we return early from the function.

Next, we set a new message to the state of messages. The first message stored is a user prompt.

The message has this format:

{
  text: string; // message value
  id: string; // Identifier, for example new date
  author: "human" | "ai"; // author can be human or ai
}

After the first message is added, we will wait for 1000ms (1 sec) to simulate the delay of getting a response from a server.

After that, we store the AI hardcoded message. We are done in this section.

4. Display messages

We stored the messages in the state but didn’t display them.

Create a new component to display a message.

function MessageItem({message}) {
  const [text, setText] = useState(message.author === "human" ? message.text : "");

  useEffect(() => {
    setTimeout(() => {
      setText(message.text.slice(0, text.length + 1));
    }, 10);
  }, [text, message.text]);

  return (
    <div className="answer">
      <div className={`author author-${message.author}`}>
        {message.author}:
      </div>
      <div className="message">
        {text}
      </div>
    </div>
  )
}

Now map the messages and display them in the return of the Home function.

<div className="container">
  <div className="inputContainer">
    <textarea
      onChange={(e) => {
        setPrompt(e.target.value);
      }} 
      value={prompt}
      placeholder="Ask a question" 
      rows={3} 
    />
    <button 
      onClick={handleSubmit}
      className="submit">Submit
    </button>
  </div>
  <div className="answers">
    {messages.map(message => 
      <MessageItem 
        key={message.id} 
        message={message} 
      />
    )}
  </div>
</div>

5. API Endpoint

We need to create an API endpoint to send the prompt to and get a response from ChatGPT.

In pages/api/ folder add a new file called completion.js

export default async function handler(req, res) {
  if (req.method === "POST") {
    const prompt = req.body.prompt || "";

    if (!process.env.OPENAI_SECRET_KEY) {
      return res.status(500).json({error: {message: "Api key is not provided!"}});
    }

    if (prompt.trim().length === 0) {
      return res.status(400).json({error: {message: "Provide prompt value!"}});
    }

    try {
      const RESULT = "Just some hardcoded response bla bla bla...";

      return res.status(200).json({result: completion.data.choices[0].text});
    } catch (e) {
      return res.status(400).json({error: {message: e.message}});
    }

  } else {
    return res.status(500).json({error: {message: "Invalid Api Route!"}});
  }
}

A straightforward code. We first get the prompt data from the request body.

If there are non, we return the error.

Similarly, we returned the error if we didn’t set up OPENAI_SECRET_KEY (which we didn’t yet).

Finally, if all went well, we sent back a hardcoded response.

We are not calling this endpoint yet, so let’s fix it!

6. Call the endpoint

Back in pages/index.js

Call the endpoint in handleSubmit

const handleSubmit = async () => {
  if (prompt.trim().length === 0) {
    return;
  }

  setMessages((messages) => [...messages, {
    text: prompt.trim(),
    id: new Date().toISOString(),
    author: "human"
  }]);

  setPrompt("");
  const response =  await fetch("/api/completion", {
    method: "POST",
    headers: {
      "Content-type": "application/json"
    },
    body: JSON.stringify({prompt: prompt.trim()})
  });

  const json = await response.json();

  if (response.ok) {
    console.log(json.result);

    setMessages((messages) => [...messages, {
      text: json.result,
      id: new Date().toISOString(),
      author: "ai"
    }]);
  } else {
    console.warn(json?.error?.message);
  }
}

In the fetch function, we specify the URL of the endpoint and provide the prompt data.

Not let’s pass this data to the ChatGPT model.

7. Setup OpenAI API

To communicate with ChatGPT, we first need to get an API key.

Get this key on the following link: https://platform.openai.com/account/api-keys

In the project’s root folder, create a .env file and provide the API key you got from OpenAI.

OPENAI_SECRET_KEY=your_key

Then in completion.js, on top of the file, prepare the configuration.

const configuration = new Configuration({
  apiKey: process.env.OPENAI_SECRET_KEY
});

const openAi = new OpenAIApi(configuration);

8. Call the model

Here is the final part

import { Configuration, OpenAIApi } from "openai";

const configuration = new Configuration({
  apiKey: process.env.OPENAI_SECRET_KEY
});

const openAi = new OpenAIApi(configuration);

export default async function handler(req, res) {
  if (req.method === "POST") {
    const prompt = req.body.prompt || "";

    if (!process.env.OPENAI_SECRET_KEY) {
      return res.status(500).json({error: {message: "Api key is not provided!"}});
    }

    if (prompt.trim().length === 0) {
      return res.status(400).json({error: {message: "Provide prompt value!"}});
    }

    try {
      const completion = await openAi.createCompletion({
        model: "text-davinci-003",
        prompt: prompt,
        temperature: 0.7,
        max_tokens: 1024
      });

      return res.status(200).json({result: completion.data.choices[0].text});
    } catch (e) {
      return res.status(400).json({error: {message: e.message}});
    }

  } else {
    return res.status(500).json({error: {message: "Invalid Api Route!"}});
  }
}

In the try block, we call createCompletion, providing the prompt data and some other parameters (learn more about parameters).

The model will respond with an answer which we provide back in the server response; this way, we get the response back to the client application where we display it.

Now you should be able to get the actual answer:

And that’s it! To learn more, you can watch the complete course:

Next.js with ChatGPT - Development Guide

Thank you.

Next.js / React with ChatGPT was originally published in Eincode on Medium, where people are continuing the conversation by highlighting and responding to this story.