DEV Community: Bekka

AI in the 2020s

Bekka — Thu, 31 Oct 2024 20:49:47 +0000

Artificial Intelligence has changed the way we consume information, and the way many people research about subjects, projects or even ideas. Since OpenAI introduced its APIs to the public, we've witnessed a profound shift in how people approach learning and productivity, especially in fields like software development. Let's look at how far we've come and possibly what the future holds.

The Past: Foundations of Artificial Intelligence

The roots of AI trace back to Alan Turing's groundbreaking 1950 paper, "Computing Machinery and Intelligence," where he posed the now-famous question, "Can machines think?" This question sparked decades of research and set the stage for developments that would eventually lead to modern AI.

One of the most significant milestones came decades later with Geoffrey Hinton, often dubbed the "Godfather of AI." Hinton’s work in artificial neural networks laid the groundwork for many advancements, establishing neural networks as a key element in modern machine learning.

Breakthroughs: From AlexNet to Generative AI

A pivotal moment in AI's history was the development of AlexNet by Hinton and his team, which significantly advanced image recognition capabilities in 2012. This achievement helped propel the evolution of AI into the era of generative models, enabling machines to not only classify images but also create and simulate realistic content across multiple domains.
For readers interested in understanding more about AlexNet, check out the original research paper here.

Evolution of AI chatbots

As we moved into the 2010s, major tech companies began investing heavily in AI. Google initiated intensive AI research, acquiring Hinton's company, which led to collaborative breakthroughs in machine learning and neural networks. In 2010, DeepMind was founded and later acquired by Google in 2014. OpenAI was established soon after, further pushing the boundaries of what AI could achieve.

These organizations have since led AI innovation, creating popular models like Google’s Gemini and OpenAI’s ChatGPT. These chatbots, driven by advanced neural networks, demonstrate AI’s growing capacity to understand and generate human-like responses, marking a new era in human-computer interaction.

Securing AI: Trusted Execution Environments (TEEs)

As AI models continue to process massive amounts of data, security concerns regarding data privacy have intensified. Trusted Execution Environments (TEEs) offer a solution by providing secure zones within cloud infrastructures. Commonly used in both traditional cloud services and blockchain environments, TEEs protect sensitive information during computation.

A TEE functions as a secure, isolated area within a main processor, ensuring that even privileged users cannot access the data processed within. This hardware-based security layer mitigates the risk of unauthorized access and manipulation, making TEEs a vital component in AI and blockchain security today.

AI x Web3: A New Frontier

With TEEs enabling secure data processing, the integration of AI with Web3 opens up possibilities for creating transparent, autonomous agents.

Combining Web3’s transparency and decentralization with the secure computation capabilities of TEEs, developers can create systems that not only perform tasks autonomously but also uphold user privacy and data integrity. This synergy could redefine trust in AI applications and unlock new possibilities for secure, distributed AI.

Phala Network: The Largest TEE-Powered Blockchain Network

Among TEE solutions, Phala Network stands out as the largest TEE-powered network globally, setting the standard for secure and decentralized data processing. Phala’s blockchain harnesses the unique capabilities of TEE technology to create a secure, private environment for executing AI computations and other complex processes, enabling decentralized applications (dApps) to function securely without sacrificing performance.

Phala Network’s use of TEEs empowers developers to build decentralized applications that prioritize privacy, trust, and security. Unlike traditional cloud-based solutions, Phala’s network ensures that data is handled securely, without reliance on a central authority. This makes it particularly useful for applications that require confidentiality, such as:

Privacy-Preserving AI Agents: Phala supports the development of AI agents that process sensitive data securely and privately, without revealing information to external parties.
Data Marketplaces: Phala enables secure data trading platforms where users can buy and sell data without risking exposure or misuse, enhancing trust in the ecosystem.
Decentralized Finance (DeFi) Privacy: In DeFi, Phala's TEE infrastructure ensures that financial transactions and smart contract data remain confidential, which is crucial for user protection.

Phala Network is pioneering secure AI computation by integrating blockchain's transparency with the robust privacy of TEEs, positioning it as a foundational element for the future of AI and Web3.

The Future: Expanding AI’s Role

Looking ahead, the evolution of AI suggests even greater potential. Future advancements may empower AI to make more sophisticated, context-aware decisions, blending with fields like quantum computing or even mobile phones, see apple's intelligence.

Moreover, as regulatory frameworks catch up, we may see policies that enhance transparency and security, encouraging responsible AI development.

How to start your journey in Polkadot

Bekka — Thu, 20 Jun 2024 15:14:01 +0000

You might have heard about Polkadot from Twitter, an event, TV, or even a Lyft car with Polkadot's banner. Regardless of how you found out, you want to know how to join the community or stay updated.

This article is a soft guide on how you can navigate through Polkadot’s ecosystem. If you don't have much knowledge on web3 you can follow this free course by the web3 foundation.

What is Polkadot?

Polkadot is a decentralised, open-source blockchain platform designed to enable interoperability and scalability among different blockchains, it enables asset transfer between blockchains. These blockchains are built on top of it and batch in transactions like Rollups do in Ethereum.

What are its key features and philosophy?

True interoperability: This might sound cliche to you but this is provable, I'll spare you the technical details for later. It is possible to build a bridge with verifiable consensus proofs with Polkadot, check out Hyperbridge for more information.
Polkadot enables cross-blockchain transfers of any type of data or asset, not just tokens. Connecting to Polkadot gives you the ability to interoperate with a wide variety of blockchains in the Polkadot network.
User-driven governance: Polkadot features an advanced governance system that gives all stakeholders a say. Network upgrades are managed on-chain and implemented automatically, avoiding the need for network forks. This approach ensures that Polkadot's development is both forward-thinking and guided by the community.
Low cost of transactions: Transaction fees in Polkadot's ecosystem are as high as 0.05 USD😄
You can make as many transactions as you like without worrying about high fees.
Security for everyone: Polkadot's innovative data availability and validity scheme enables meaningful chain interactions. While each chain maintains its governance, they share a unified security framework.

Blockchains that are thriving on Polkadot.

There are a number of blockchains available for different purposes:

Hydration net: Hydra dx (now Hydration net) allows users to trade efficiently an abundance of assets in a single pool. You can also borrow a lot of digital assets after providing collateral in one or several accepted currencies.
Polimec: Polimec allows for decentralized, transparent, and regulatory-compliant fundraising, aligning stakeholder incentives throughout the process.
Hyperbridge: Hyperbridge pioneers a new class of coprocessors that leverage their consensus proofs to attest to the correctness of the computations performed on-chain. With this protocol, you can bridge assets and verify the computation of the bridged assets.
Tanssi: Tanssi stands as a beacon of hope for developers navigating the complex landscape of blockchain application development.
Phala network: Phala network is an AI coprocessor for blockchains it is shaping the Future of AI and Web3 with Tokenization.
Moonbeam: Moonbeam provides a strong DeFi ecosystem, allowing easy access to various decentralized finance applications. With full Ethereum compatibility and unique cross-chain features, developers and users can benefit from the Polkadot ecosystem while using familiar Ethereum tools.

Get identified with Polkadot

You can get identified with Polkadot, it is similar to having an identity ENS(Ethereum Name Service). This is a good place to start if you want to participate in the forum and the open-gov discussions. Plus you could also receive tokens through the address. You can get started here

Polimec also provides KYC features for anyone who wants their identity on-chain, it would also require you to present a means of identification, like a passport or driver's license.

Contributing to Polkadot’s Community

There are different ways to contribute to the community. You can come in as a developer or a community builder.

For Developers

To learn anything in development, start doing it for fun. This way, you would be open to exploring different parts of the protocol. There's also a free course that gives you an intro to Polkadot. You can start with something you want to learn for fun or tackle a problem you want to solve. While tackling the problem, you can ask questions if you need help.

There are different ways to start as a dev in Polkadot:

Blockchain dev
Smart contract dev
Application dev

Blockchain dev: To become a chain dev, you must already have some advanced experience with web3. If you want to build a chain without going through rigorous months of building. If you simply want to launch an MVP within days then you should learn more about Tanssi. Appchains connected to the Tanssi Network transform into ContainerChains, gaining access to a range of tools and resources.
Smart contract dev: Different smart contract environments are available for devs. You can either build your solidity smart contract on Moonbeam or Astar. You can build Ink! smart contracts on Phala network, which are called Phat contracts, these contracts allow anyone to make API requests into their smart contracts. You could also build ink smart contracts on AlephZero.
Application dev: This is the easiest way for web2 devs to build on Polkadot. This is great for people who have an existing product and want to explore or combine web3 primitives for their product. This is also a great way to explore the potential of building on web3 without going through the nitty-gritty of the protocol. One of the best places to start is Appilion.

For community builders

Community builders are an important part of the protocol. Polkadot can be described as the largest DAO. The protocol design and upgrade can also be determined by the community.

You can be a threadoor😁, a technical writer contributing to the wiki or a community builder hosting meetups to foster collaboration and community through the events bounty.

There are a number of regions which have meetups and events for community builders, you can join and follow the region closest to you. Currently, we have:

For Ambassadors

At the time of this writing, the ambassador program is undergoing a major change which will be determined by the community. There will be Head Ambassadors elected to represent and take charge of the ambassadors in various regions. You can stay updated by joining the Discord server.

Joining Polkadot's community doesn't have to be daunting. With the right guidance, you should be able to keep up and start making contributions.

Staking in Polkadot

Bekka — Fri, 20 Oct 2023 16:00:23 +0000

When you hear about staking tokens what comes to your mind? Do you think it's a gamble or an investment?

Staking in cryptocurrency is the process of actively participating in transaction validation on a proof-of-stake (PoS) blockchain. It involves holding funds in a cryptocurrency wallet to support the operations of a blockchain network. In contrast to mining, which is used in proof-of-work (PoW) systems, staking does not require high-powered hardware or significant energy consumption.

Proof of Work

Bitcoin's consensus is based on proof-of-work (PoW) and to participate you have to solve a mathematical problem. The fastest and most accurate answer gets to validate the transactions and is rewarded tokens (Bitcoin in this case). This process requires a lot of computation which leads to consuming so much computer power. You are required to have fast CPUs and unlimited access to power and internet. This is not an easy task but it is very rewarding considering the current price of Bitcoin and that's why it's called mining, it's similar to the process of searching for diamonds or gold in a cave. But not everyone can afford a 12-core, 24-thread unlocked desktop processor.

Proof of Stake

Polkadot's consensus is based on proof-of-stake (PoS), it utilizes the ground-breaking technology Nominated-Proof-of-Stake (NPoS) more specifically. In PoS, validators are selected based on the number of coins they hold and are willing to "stake" in the network. NPos is a variation of the Proof-of-Stake consensus mechanism that aims to be more democratic, and therefore more fair, than its predecessor (which is PoS in this case). It allows token holders to nominate validators to represent them in the block validation process. Only nominated validators can participate in block formation and each individual nominator can appoint a specific number of validators.

There are two major roles:

Validator role: Validators constitute a significant part of the network, they help in securing the network and validating transactions in Polkadot. This role requires you to be technical and it has great rewards too. You don't need a CPU a very high-performant CPU, you do need unlimited internet and power. You can learn more about the responsibilities of becoming a validator here
Nominator role: This is a really accommodative role. You don't need to buy any extra computer or need to have access to 24/7 internet connection. You just need a wallet and some Polkadot tokens (DOT). In this role, there are different ways to stake your dot. You can do either of the following:

Join a Nomination pool: The nomination process involves token holders selecting trustworthy and competent validators to secure the network. Nominators, who hold DOT tokens, have the ability to choose one or more validators they trust to validate transactions and produce blocks on their behalf. You can learn more here
Open a nomination pool: Opening a nomination pool requires careful consideration and active engagement with the Polkadot network. You'll need a community and reputation as an expert nominator. By nominating validators, you contribute to the security and decentralization of the network while potentially earning rewards for your participation.
Nominate directly: This is where token holders directly select and nominate validators to participate in the block production and verification process. Unlike nominating through a nominator, direct nomination involves individual token holders directly choosing the validators they trust to help secure the network. You can get started here

In essence, with a Polkadot wallet and some DOTs, you can start earning rewards from your PC.

Validators slashed when they misbehave and this affects your rewards too. You have to be careful when making your choice. Always choose experienced validators. Remember all investments require risks.

Polkadot has one of the most active development activities, apart from building innovative dApps you can also earn rewards passively and view them in real-time on the staking dashboard.

Being a dev in the 2020s

Bekka — Wed, 18 Oct 2023 08:50:19 +0000

So much has changed in the past 20 years since the year 2000 and we are still at the beginning of the 21st century😀

In the early 2000s, if you told anyone you were a software developer, they'd probably call you a hacker😄. In those times, building websites wasn't as easy as clicking a few buttons when you wanted to deploy your code to production. You had to have access to a physical server. They mainly were rented or managed by the company deploying the website. Deploying a website would typically involve using file transfer protocols(FTP) to transfer files from the local computer to remote servers. Devs were using FTP clients to upload their files. Landing pages were relatively static and there weren't many interactive websites.

In the 2010s, things were already evolving. The iPhone had already been part of the market for over 3 years and they are browsers that are now available on mobile phones like Samsung and Nokia.

This meant that we needed media queries to start displaying websites on mobile devices. There was advancement in CSS, and devs started to use Flexbox, grids, etc.

People started to build startups and there was a lot of success like Facebook and 2go. Devs had to advance their skills in CSS, HTML and Javascript. Backend development gained so much recognition, especially using Node js and PHP. A market for cloud computing services started to emerge because the demand for mobile development, websites and hosting services grew exponentially. Node js and AWS were already released at this point.

At this point, if you were a frontend developer, you probably knew HTML, CSS, Javascript/Python, WordPress or PHP. For a backend dev, you are probably focused on languages like Javascript (Node js), PHP(Laravel), and C#. Most times backend devs used SQL databases, but relational databases also started to gain popularity amongst devs. Mobile devs were mostly Java devs while system programming was mostly C and C++ (which is still relevant today).

In the mid-2010s, Frameworks like React, and Vue started to change the standard of websites. Users could literally interact with a single page and not be directed to another page. APIs and API testers started to have a place in development, like Postman. You can't be a backend dev without using any API platform. There are many hosting platforms for websites, like Netlify, Vercel and GitHub pages.

Now, we are in the 2020s and a lot has changed. People are either using an iPhone 11 or a Samsung Galaxy phone or at least any mobile phone. There are so many CSS frameworks and devs use React or Vue for almost any front-end project. Backend devs use ORMs these days for querying databases. There are more opportunities in development like Cloud Engineers and DevOps. React Native and Flutter have shaped the standard of mobile apps and you can easily deploy test environments using Expo.

There are so many social platforms and some are compulsory for developers. You do need to be able to fork someone's code.

Web3 space is now here. We've seen Bitcoin, Ethereum, Polkadot, Solana and Phala launched. To be a web3 dev you either have to choose a project and stick with it or like many devs do, learn Solidity and Rust. Reading whitepapers is an essential ritual when onboarding into any web3 project.

AI has now taken its place in the development. It has helped improve the speed at which we get accurate information on the internet. So much knowledge out there that can be easily accessed with a few clicks.

You also need to know how to toot your horn on Twitter as companies are now using Twitter as a point of contact in their recruiting process.

You definitely need to have some knowledge of database systems and sometimes provide some tolerance for maths when you're working with ZK proofs🤓

If you don't have knowledge of Git, are you really a dev in 2023?😄

There's a lot more to being a dev in 2023. There are so many perks apart from remote work, some companies have their quirks and there are irks to being a developer in these times.

Writing smart contracts in ink!

Bekka — Sun, 30 Jul 2023 12:51:31 +0000

If you are looking for a soft landing into polkadot and you don't want to bother about writing pallets yet while still enjoying solidity's style of writing smart contract. Then you have come to the right place.

In this article, you will learn how to write smart contracts in polkadot and deploy the smart contract on a Testnet.

Prerequisites

You need to know the following to be able to follow this tutorial.

Some programming knowledge working with structures.
Experience working with solidity but not compulsory.
Some programming knowledge on rust.
A polkadot account, if you don't have one you can follow this guide to create one here

With that out of the way, let's start coding.

We are going to build a simplified burger shop using ink smart contracts.

What is Ink! programming language?

Ink! is a safe, secure, and efficient language for writing smart contracts. It is based on the Rust programming language, which is known for its safety and security features.

Ink! smart contracts are also portable, which means that they can be deployed on any blockchain that supports WebAssembly.

Setting up

To run contracts, instantiate contracts and more, we need to download the Ink! CLI. Open your terminal and run rustup component add rust-src.
After the process finishes, run cargo install --force --locked cargo-contract.
To verify the package is installed in your pc, run cargo contract -V or cargo contract --version. You also run cargo contract --help to see other available commands.

Next, we install substrate-contracts-node. This is a simple substrate blockchain configured for smart contract functionality using contracts-pallets. You can use this instead of a Testnet, we will cover this in another article.
You could install the binary which is faster. This is supported for linux and Mac systems.

You could also install it using cargo instead, by running cargo install contracts-node --git https://github.com/paritytech/substrate-contracts-node.git --tag v0.23.0 --force --locked.
To verify that it is downloaded, run substrate-contracts-node -V also to check for other commands run substrate-contracts-node --help.

What are pallets?

Substrate framework is the framework used in building blockchains in polkadot which comprises of different modules. These modules make up different parts of a blockchain from the FRAME, Consensus Engines, Primitives, Libraries, etc.

FRAME stands for "Framework for Runtime Aggregation of Modularized Entities." It is designed to enable flexibility and composability in blockchain development, allowing developers to pick and choose different modules to include in their custom blockchain's runtime logic. Borrowing some of the artistic term of pallets used for drawing, I assume you know about colour pallets used in drawing. You can think of substrate pallets as different tools available for you to build the blockchain you want. For example, the substrate-contracts-node comprises of pallets configured for smart contracts. You could build a blockchain tailored for a social media platform or a staking platform.

Building the project

Ink! smart contracts relies on the use of macros which are code that generate code to achieve some function. We will use macros while working on this project, don't worry. You won't need to write a custom macro.

Let's create our project, we'll call it "burger_shop", in your project's directory, run cargo contract new burger_shop.
This should create a project and generate an ink! smart contract template. I encourage to play around or read the code first, to try to understand what's going on. You'll notice there are contract calls, tests and integration tests. We'll write our own contract calls and tests for our smart contract. To keep this tutorial short, tests will be covered in another article.

Next, let's update our .toml file with the necessary deps, copy this code.



[package]
name = "burger_shop"
version = "0.1.0"
authors = ["Ayomide Bajo <oluwashinabajo@gmail.com>"] ## replace with your name and email
edition = "2021"

[dependencies]
ink = { version = "4.0.1", default-features = false }

scale = { package = "parity-scale-codec", version = "3", default-features = false, features = ["derive"] }
scale-info = { version = "2.3", default-features = false, features = ["derive"], optional = true }

[dev-dependencies]
ink_e2e = "4.0.1"

[lib]
path = "lib.rs"

[features]
default = ["std"]
std = [
    "ink/std",
    "scale/std",
    "scale-info/std",
]
ink-as-dependency = []
e2e-tests = []

Setting up the storage

Our smart contract needs a storage to keep all the data coming from the shop, this storage will contain orders from customers.

Firstly, let's do some imports, we'll need them, so it's better to get that out of the way.

Delete everything, with mod braces, (trust me, I didn't waste your time, lol). Your file should look like this.

Add the following code within mod braces.




    use ink::prelude::vec::Vec;
    use ink::prelude::format;
    use ink::storage::Mapping;
    use scale::{Decode, Encode};

We imported from the prelude module, this includes the types, we usually use with std that are also supported for no_std compilations. We also imported from the storage module which is the storage type for storing our data. Also the scale crate for serializations properties and conversions.

Now we can setup our first storage.
Copy this code block.




   #[ink(storage)]
    pub struct BurgerShop {
        orders: Vec<(u32, Order)>,
        orders_mapping: Mapping<u32, Order>,
    }

If you notice, there is an attribute #[ink(storage)], this tells the compiler that the data structure is going to be entering the ink! storage. It also contains fields, I assume you know Vec already. There's an interesting type Mapping. This type is for storing key-value pairs, like hashmaps and it's quite different from hashmaps, you can read more here

Next we are going to create the types that will be used in interacting with the storage in our smart contract.

If, you're using rust-analyzer on your Vscode. You might be seeing some errors, saying something about a missing constructor, we will fix that soon! I recommend deactivating it for now so that it won't distract you.

Copy this code block.



// The order type
  #[derive(Encode, Decode, Debug, Clone)]
    #[cfg_attr(
        feature = "std",
        derive(scale_info::TypeInfo, ink::storage::traits::StorageLayout)
    )]
    pub struct Order {
        list_of_items: Vec<FoodItem>,
        customer: AccountId,
        total_price: Balance,
        paid: bool,
        order_id: u32,
    }

  // Food Item type, basically for each food item
    #[derive(Encode, Decode, Debug, Clone)]
    #[cfg_attr(
        feature = "std",
        derive(scale_info::TypeInfo, ink::storage::traits::StorageLayout)
    )]
    pub struct FoodItem {
        burger_menu: BurgerMenu,
        amount: u32,
    }

// Burger Type
    #[derive(Encode, Decode, Debug, Clone)]
    #[cfg_attr(
        feature = "std",
        derive(scale_info::TypeInfo, ink::storage::traits::StorageLayout)
    )]
    pub enum BurgerMenu {
        CheeseBurger,
        ChickenBurger,
        VeggieBurger,
    }

There are a bunch of attributes derived for the types we've created, #[derive(Encode, Decode, Debug, Clone)] (skipping the other traits in rust). This attribute derives the following traits, Encode and Decode. Encode makes the type encodable (i.e can be hashed) and Decode makes type decodable (i.e can be decoded for interaction in the frontend and other operations). The cfg_attr also does some derivations, in here, scale_info::TypeInfo derives the TypeInfo trait that does some serializations like serde, this helps to compile the struct Order(for example) into a Portable form. The ink::storage::traits::StorageLayout type implements StorageLayout trait, which will allow the compiler to add the type(s) into storage.

Also, notice we have types Balance and AccountId. These are special types indicating the value in tokens to be sent and the address/account of the caller, respectively. These are the expected types for our operations. You can read more about them here

We created the following types for the following reasons:

Order: This type is for each order a customer creates to buy something from the shop(which is burger in the case), it also contains the total_price for the order and other fields.
FoodItem: This type is for each food item stored in each order, it also contains the amount of food items.
BurgerMenu: This is for each type of burger available in our shop.

We are going to implement some methods for our types, as you have noticed our smart contract follows rust's standard way of writing structures and code, plus you still get to enjoy solidity's style of writing smart contract, isn't that wonderful?😀
Copy the next code blocks and put them in their appropriate positions like this.



// derive attributes skipped for brevity sake
pub struct Order {
list_of_items: Vec<FoodItem>,
// other code here...
}

impl Order {
        fn new(list_of_items: Vec<FoodItem>, customer: AccountId, id: u32) -> Self {
            let total_price = Order::total_price(&list_of_items);
            Self {
                list_of_items,
                customer,
                total_price,
                paid: false,
                order_id: id, // Default is "getting ingredients" in this case
            }
        }

        fn total_price(list_of_items: &Vec<FoodItem>) -> Balance {
            let mut total = 0;
            for item in list_of_items {
                total += item.price()
            }
            total
        }
    }



// derive attributes skipped for brevity sake
pub struct FoodItem {
burger_menu: BurgerMenu,
// other code here...
}

 impl FoodItem {
        fn price(&self) -> Balance {
            match self.burger_menu {
                BurgerMenu::CheeseBurger => BurgerMenu::CheeseBurger.price() * self.amount as u128,
                BurgerMenu::ChickenBurger => {
                    BurgerMenu::ChickenBurger.price() * self.amount as u128
                }
                BurgerMenu::VeggieBurger => BurgerMenu::VeggieBurger.price() * self.amount as u128,
            }
        }
    }




//you already guessed it, attributes skipped here😀
 pub enum BurgerMenu {
 CheeseBurger,
// Yup! other code here...
}

 impl BurgerMenu {
        fn price(&self) -> Balance {
            match self {
                Self::CheeseBurger => 12,
                Self::VeggieBurger => 10,
                Self::ChickenBurger => 15,
            }
        }
    }

Here, we set the necessary methods, for tracking prices for each burger on the menu and for food item(s) when we are adding them into storage.

Setting up events, creating error types and result type.

Events are very important in your code, especially when you want to query informations about the contract's executions and current state. We will setup different event types for our smart contract. We will also use Ink! attributes for setting up our event types. Copy the following code.




  /// Event emitted when a token transfer occurs.
    #[ink(event)]
    pub struct Transfer {
        #[ink(topic)]
        from: Option<AccountId>,
        #[ink(topic)]
        to: Option<AccountId>,
        value: Balance,
    }

    /// Event when shop owner get all orders in storage
    #[ink(event)]
    pub struct GetAllOrders {
        #[ink(topic)]
        orders: Vec<(u32, Order)>,
    }

    /// Event when shop owner gets a single order
    #[ink(event)]
    pub struct GetSingleOrder {
        #[ink(topic)]
        single_order: Order,
    }

    /// Event when the shop_owner creates his shop
    #[ink(event)]
    pub struct CreatedShopAndStorage {
        #[ink(topic)]
        orders: Vec<(u32, Order)>, // this only contains a vector because `Mapping` doesn't implement "encode" trait, this means you can't encode or decode it for operational purposes, it also means you can't return `Mapping` as a result for your contract calls
    }

We also want to handle errors by returning custom error types.




// For catching errors that happens during shop operations
    #[derive(Debug, PartialEq, Eq, scale::Encode, scale::Decode)]
    #[cfg_attr(feature = "std", derive(scale_info::TypeInfo))]
    pub enum BurgerShopError {
        /// Errors types for different errors.
        PaymentError,
        OrderNotCompleted,
    }

Now we can finally create our result type.



 // result type
    pub type Result<T> = core::result::Result<T, BurgerShopError>;

Writing smart contract call functions

We've set up the necessary types that we will need, now we can start writing functions that will interact with our smart contract.

Let's implement the function that instantiates the smart contract.




 impl BurgerShop {
        #[ink(constructor)]
       pub fn new() -> Self {
            let order_storage_vector: Vec<(u32, Order)> = Vec::new();
            let order_storage_mapping = Mapping::new();

            Self {
                orders: order_storage_vector,
                orders_mapping: order_storage_mapping,
            }
        }
}

If you noticed, there's a new attribute, this attribute basically flags the function as a special function for instantiating the smart contract, a smart contract must have at least one constructor. You can also have multiple constructors. There are also list of other attributes, we will go through the ones we use for this project, I recommend you check the others too!

Next, let's implement the function that takes in an order and also accepts payment.




   /// takes the order and makes the payment, we aren't implementing cart feature here for simplicity purposes, ideally the cart feature should be implemented in the frontend
        #[ink(message, payable)]
        pub fn take_order_and_payment(&mut self, list_of_items: Vec<FoodItem>) -> Result<Order> {
            // Gets the caller account id
            let caller = Self::env().caller();

            // this is assertion is opinionated, if you don't want to limit the shop owner from creating an order, you can remove this line
            assert!(
                caller != self.env().account_id(),
                "You are not the customer!"
            );

            // assert the order contains at least 1 item
            for item in &list_of_items {
                assert!(item.amount > 0, "Can't take an empty order")
            }

            // our own local id, you can change this to a hash if you want, but remember to make the neccessary type changes too!
            let id = self.orders.len() as u32;

            // Calculate and set order price
            let total_price = Order::total_price(&list_of_items);
            let mut order = Order::new(list_of_items, caller, id);
            order.total_price = total_price;

            assert!(
                order.paid == false,
                "Can't pay for an order that is paid for already"
            );

            let multiply: Balance = 1_000_000_000_000; // this equals to 1 Azero, so we doing some conversion
            let transfered_val = self.env().transferred_value();

            // assert the value sent == total price
            assert!(
                transfered_val
                    == order
                        .total_price
                        .checked_mul(multiply)
                        .expect("Overflow!!!"),
                "{}", format!("Please pay complete amount which is {}", order.total_price)
            );

            ink::env::debug_println!(
                "Expected value: {}",
                order.total_price
            );
            ink::env::debug_println!(
                "Expected received payment without conversion: {}",
                transfered_val
            );  // we are printing the expected value as is

            // make payment
            match self
                .env()
                .transfer(self.env().account_id(), order.total_price)
            {
                Ok(_) => {
                    // get current length of the list orders in storage, this will act as our unique id
                    let id = self.orders.len() as u32;
                    // mark order as paid
                    order.paid = true;

                    // Emit event
                    self.env().emit_event(Transfer {
                        from: Some(order.customer),
                        to: Some(self.env().account_id()),
                        value: order.total_price,
                    });

                    // Push to storage
                    self.orders_mapping.insert(id, &order);
                    self.orders.push((id, order.clone()));
                    Ok(order)
                }
                Err(_) => Err(BurgerShopError::PaymentError),
            }
        }

We see different attributes message and payable. The message attribute indicates that the function can be called publicly, notice pub keyword too. Any function(contract call) that implements a message attribute, implements a special functionality that allows them to be called by users.

While payable means the contract call will receive some value as part of the call, you can also verify the value you're expecting, we did this here in this code block.




let multiply: Balance = 1_000_000_000_000;
let transfered_val = self.env().transferred_value();
  assert!(
                transfered_val
                    == order
                        .total_price
                        .checked_mul(multiply)
                        .expect("Overflow!!!"),
                "{}", format!("Please pay complete amount which is {}", order.total_price)
            );

The value that will be sent will come from the frontend or the contracts UI. In this article, we will interact with the UI to test our smart contract.

We used self a lot here. This refers to the smart contract itself, it contains a lot of rich methods and types including the ones we created in our storage struct.

The env method is one of the most used methods, it's basically the smart contract environment, you have access to things like account_id of the smart contract, balance which means you can transfer native token to your smart contract. Also, the caller returns the address of who is actually calling the contract, in our case, whenever a customer makes an order, we have access to the customer's address.

Whoo! that was a lot! If you've come this far, Congratulations🎉 you're half way, already!

Next up, we are adding the remaining functions for our burger shop.




  #[ink(message)]
        /// gets a single order from storage
        pub fn get_single_order(&self, id: u32) -> Order {
            // get single order
            let single_order = self.orders_mapping.get(id).expect("Oh no, Order not found");

            single_order
        }

        #[ink(message)]
        /// gets the orders in storage
        pub fn get_orders(&self) -> Option<Vec<(u32, Order)>> {
            // Get all orders
            let get_all_orders = &self.orders;

            if get_all_orders.len() > 0 {
                Some(get_all_orders.to_vec()) // converts ref to an owned/new vector
            } else {
                None
            }
        }

Now, we are done with code. Go ahead, format with this command cargo fmt, compile with this command cargo contract build.

Check your target folder, you should see this. You can check the source code here

Deploying our smart contract and interaction

Ink! compiles down to WASM, which means it can be deployed on any platform that supports WASM, it also means you can do some embedded software development😉 that could call smart contract at the end of the program. So many possibilities here!😃

To test our smart contract, we will be using the contracts ui. We will be using the .contract file, the contract ui supports this file type, it contains all our compiled code.

For you to deploy you contract, you need to use faucet tokens. In this tutorial, we'll be using Aleph zero tokens, they also have a really reliable testnet🤗. You can head to their website to get some faucet tokens. Since you're using polkadot address, you can use aleph zero and yes, you can see your tokens here.

Now, let's deploy our smart contract like this. Notice the drop down at the top left corner of your screen, it contains different test nets available in polkadot, in this case we are using aleph zero testnet, so choose that like this screenshot here.

Then upload your .contract file into the uploader.

Click on Next

Notice the page contains all the functions we talked about, especially the public ones.

Upload and instantiate your contract

It should ask for your password, it interacts with your polkadot wallet (assuming you have the extension installed on your browser)

Interacting with our smart contract

Let's create a new order. I love chicken, so I'm gonna order 1 chicken burger, without adding any amount.

Notice the error on the right, polkadot blockchains also have the power to check if the outcome of a transaction is going to successful without signing the transaction, It's called "DryRun". You can see our assertion fails and it tells you what line this is located. Let's fix this by adding an amount.

Now we have a different error.

Our assertion fails here. Remember I talked about how to assert the price of the burger is actually inputed in the UI. This is where you input the price you're supposed to pay for a transaction. You can see that if the value isn't up to the total_price, it returns an error.

Let's fix this by inputing the amount that is expected, the error also tells us the expected value.

We get a successful outcome, you can go ahead and click thecall contract button below. You'll also be asked to input your password for the wallet address that's calling the contract. You'll also get flash messages on the UI indicating the events that took place.

Notice the new output under the dry run outcome.

You guessed it, these are events emitted. It contains the function that emitted the event, the actual event parameters which is Transfer in this case and also the order in which the tokens where transferred. Tbh, I personally love the events output, so satisfying.

Now, you can call the other functions to get all the orders or a single order.

Congratulations!🎉 You've just written your smart contract and deployed it, You're now on your way to becoming a world class smart contract developer in polkadot!

Ink! smart contracts offer a lot more features, this tutorial introduced you to the fundamentals you need to know when writing smart contracts. You can add more features to your smart contract. We will cover writing unit tests in another article. I hope you found this tutorial helpful.

Polkadot, a decentralized network emerging as a super computer

Bekka — Mon, 10 Jul 2023 11:45:32 +0000

Polkadot is a decentralized, open-source blockchain platform designed to enable interoperability and scalability among different blockchains, it enables assets or data transfer between blockchains which also includes tokens.

Why polkadot?

Polkadot aims to facilitate seamless communication and data transfer between different blockchains known as parachains(in polkadot's ecosystem), unlike other blockchains, this allows them to interact and share data or information. It also offers a shared security model which is provided by its validators, this is also part of how it achieves decentralisation. Each blockchain manages its own consensus mechanism, (which is a set of rules) that enable parallel processing of transactions and improving overall network scalability.

On-chain governance in Polkadot is an important feature that sets it apart from other blockchain platforms. This gives the community a voice and encourages proactive community engagement.

The first Idea on polkadot in a short summary.

Multi-Chain Framework: Polkadot is a heterogeneous multi-chain framework, which means it allows different blockchains to connect and communicate with each other. This interoperability is facilitated by the Polkadot Relay Chain.
Parachains: Parachains are independent blockchains that run in parallel to the Polkadot Relay Chain. They have their own governance, consensus mechanism, and other set of rules, while benefiting from the shared security and interoperability provided by the Relay Chain(which is polkadot in this case). They operate on a single core, parachains are connected in parallel, this is also where the word "parachains" came from because they are "parallel blockchains" executing transactions independently.
Relay Chain: The Relay Chain serves as the central hub, coordinating the network's consensus, governance, and cross-chain communication. It provides shared security to all connected parachains and ensures the overall security and integrity of the network.
Validators, Nominators and Consensus Mechanism: Polkadot utilizes a proof-of-stake (PoS) consensus mechanism. Validators are responsible for block production and maintaining the network's security, while nominators support validators by staking their tokens and participating in the nomination process. These Validators also follow a consensus mechanism implemented in the network that ensures block production is verifiable with proofs.
Governance: As this article mentions earlier, polkadot offers the community a voice, enabling token holders to participate in decision-making processes. On-chain governance mechanisms allow stakeholders to propose, vote and make decisions.
Substrate Framework: The Substrate framework is a development framework for building custom blockchains and decentralized applications (dApps) on top of Polkadot. Substrate provides a modular and flexible environment for developers to create their own blockchain projects. It is written in Rust.
Upgradability and Evolution: Polkadot is designed with upgradability and evolution in mind. It supports runtime upgrades without requiring a hard fork, enabling the network to adapt to technological advancements and address potential security vulnerabilities.

Polkadot, emerging as a super computer.

Before now, Polkadot was primarily built to connect with parachains and enable them communicate with each other. Imagine a spider web, this might not be pleasant if you don't like spiders lol. The web threads are the links for connecting different parachains and transporting assets and data between parachains throughout the network. Each parachain runs on a single core.

Polkadot's future (Polkadot 2.0)

Polkadot currently has about 50 cores and each parachain runs on a core.

What is a core?

A core refers to a processing unit within a central processing unit (CPU). Modern CPUs often have multiple cores, each capable of executing instructions independently and in parallel. Multiple cores allow for increased performance and the ability to perform multiple tasks simultaneously.

Emerging super computer

Polkadot's proposed change is to allow devs deploy blobs on these cores, since cores execute transactions or instructions independently. Developers can rent some core-time(a stipulated amount of time for executing different tasks) for executing their transactions within the blocks in the relay chain.

What are blobs?

Blockchains run a huge database system fundamentally. Blobs, which mean "Binary Large Objects", is a data type used to store large amounts of binary data in computer systems which could be a database for example.

The purpose of the ongoing proposed change in polkadot is to lower the entry requirements for anyone who wants to build or prototype an idea and don't necessarily need to build a parachain. It aims to allow devs deploy blobs that could run on a core, processing transactions just similar to the way parachains execute transactions. These blobs can imagined that they sort of live in polkadot network.

This is a rough visualisation on the proposed change in polkadot.

Those small dots or circles could be blobs or parachains dwelling in the network operating on different cores.

Developers would be able to rent blockspace and core-time so that they could easily prototype their ideas and build applications even faster. Devs would also have access to the assets and information whenever they want to process cross-chain transactions.

This is because these cores are now also accessible to you, remember it was originally accessible to parachains. Note that all transactions in your blob deployed will still follow polkadot's consensus.

What does this mean and how does this drive adoption?

Devs will be able to ship faster, which will in turn allow startups prototype applications quickly and also allow small businesses integrate web3 into their businesses while using less time and resources. Devs don't need to worry about setting up nodes or writing consensus rules, all you need to worry about is prototyping, building and shipping. You could also be able to pause usage of core-time and come back to rent it at anytime.

Future possibilities in Polkadot

If blobs could actually run on a core, there's a possibility of also accommodating smart contracts, however this will come with some overhead complexities.

Since Polkadot has cores which can process transactions, runtime state transitions, XCMPs and participate in block production. All these are tasks fundamentally. Which is similar to computer systems, these cores process tasks and can randomly finish any task it has in its pool. It is safe to say Polkadot is a decentralized super computer.

Writing unit tests for rust applications

Bekka — Wed, 10 May 2023 14:09:47 +0000

Just like in any other programming language, we test our code to give the confidence to push code to production. Rust takes testing and documentation very seriously. This is also very crucial to open source development.

In this post, you will learn how to test your applications, the syntax and also scaling for bigger applications.

This article assumes you already have some rust experience with rust, if you don't, you can start your journey here.

Unit tests

You can write tests to test a function, a module or code snippet. This is usually written in the same module or the file that contains the code.

Rust has attributes for denoting tests, so that cargo will run this parts of the code conditionally. It is denoted #[cfg(test)]. The #[tests] attribute is always placed above the function that contains the test logic for each program you're testing. Let's see how this looks and works in rust.

We are building a word counter project. Create a new project, we will be using a binary project. (i.e the root will be main.rs). Let's call it "word_counter". Run this command in your terminal cargo new word_counter, replace the code with following code in your main.rs.


use std::collections::HashMap;
use std::env;
use std::fs::File;
use std::io::prelude::BufRead;
use std::io::BufReader;

#[derive(Debug)]
struct WordCounter(HashMap<String, u64>);

impl WordCounter {
    fn new() -> WordCounter {
        WordCounter(HashMap::new())
    }
    fn increment(&mut self, word: &str) {
        let key = word.to_string();
        let count = self.0.entry(key).or_insert(0);
        *count += 1;
    }
    fn display(&self, filter: u64) {
        // keep data in a vector for sorting by storing it the same structure as the hashmap
        let mut vec_count: Vec<(&String, &u64)> = self.0.iter().collect();
        // sort by value
        vec_count.sort_by(|a, b| a.1.cmp(b.1));
        // print the sorted vector
        for (key, value) in vec_count {
            // print only the words that have a count greater than the filter
            if value > &filter {
                println!("{}: {}", key, value);
            }
        }
    }
}

fn main() {
    let arguments: Vec<String> = env::args().collect();
    if arguments.len() < 2 {
        panic!("Please provide a filename!");
    }
    let filename = &arguments[1];

    let file = File::open(filename).expect("Could not open file");

    let reader = BufReader::new(file);

    let mut word_counter = WordCounter::new();

    for line in reader.lines() {
        let line = line.expect("Could not read line");
        let words = line.split(" ");

        for word in words {
            if word == "" {
                continue;
            } else {
                word_counter.increment(&word);
            }
        }
    }
    word_counter.display(1);
}

Create a .txt file(with any name) and put this in your outside your src directory, put in some random words and run this command cargo run your_file_name.txt. It should look like this.

Now let's test our program. Add the following code into your main.rs.

#[cfg(test)]
// Our first test
#[test]
fn first_test() {
    assert!(true);
    assert_ne!(false, true);
    assert_eq!(1 + 1, 2);
}

Rust has macros, what are macros? These are pieces of code that generate another piece of code. They allow us write code that writes code. It is also known as meta programming.

In the above code block, there are three macros in our unit test. assert! macro tests that the expression is true, it only contains one expression. assert_ne! tests that the expressions are not equal to each other, it takes in two expressions. assert_eq tests that the expressions are equal to each other. Run cargo tests first_test, this will run the test. There other macros, read more here.

Let's write another test. This tests if our program is correct.


// This is a test for the word counter
#[test]
fn test_word_count() {
    let mut word_counter = WordCounter::new();

    let random_words = [
        "this", "is", "just", "a", "list", "of", "random", "words.", "a", "word", "please",
    ];

    // this adds the words to the hashmap and increments the number of times the word appears
    for word in random_words.iter() {
        word_counter.increment(word);
    }

    assert!(random_words.len() > 0);

    // we should expect 10 because the word "a" is repeated twice, that means "a" will map to 2
    assert!(word_counter.0.len() == 10_usize);
}

Run cargo test test_word_count to run this test. Notice that this command only runs this test. To run all tests in your module, run cargo test. You should see something like this

Integration tests

Integration tests are written in a separate directory. They consume the code/program and always placed in a different directory but at the root of the crate that contains the code.
Let's see how this works in code. Run cargo new integration_test_word_counter --lib in your crate root directory. We will be writing our word counter as a library instead. Note that you can't run cargo run in a library crate. It requires a bin directory(its root is main.rs).

We know the program works, we just want to practice integration tests. Create a new called tests directory outside the src directory. Create a file test_word_count.rs and paste the tests you wrote earlier. Run cargo test. You should see the following.

We have a warning here because our crate is a lib project, we two options here, change the name of the main function or set another attribute to allow dead code. This means we can tell the compiler to ignore the code block that follows the attribute. Note that isn't a good practice in a production code, we are just doing this for learning purposes.

Add #[allow(dead_code)] right before the main function. Run cargo test. You shouldn't see any warning.

You just wrote your first unit tests and also an integration test!

Rust allows developers write tests and which are simple to construct and get running, if you noticed the compilation output, it also tests for documentations too!. This is will be covered in another article. Now you can test your rust programs and push safer programs to production.

An alternative guide to installing clang, g++, gcc and llvm for mac users(M1) for cross-compilations

Bekka — Sun, 18 Sep 2022 13:32:18 +0000

Hey, guys. Welcome to another blog post!
I came across an error
when I was compiling mediasoup in a rust project and I spent two days figuring out what caused the error.
This error is caused by compatibility issues with computer's architecture and the dependency's support.

Before we go into solving the error what are g++, clang, llvm, llc and gcc? What are these terms?

What is g++?

g++ is another name for GNU C++, a freely redistributable C++ compiler produced by the Free Software Foundation plus dozens of skilled volunteers.

What is gcc?

gcc is another name for GNU C Compiler ( gcc ). It is a compiler in Linux which is used to compile C programs. It compiles files with extension. It compiles both files with extension .c and .cpp as C++ files.

What is llvm?

According to LLVM.org

The LLVM Project is a collection of modular and reusable compiler and toolchain technologies. Despite its name, LLVM has little to do with traditional virtual machines. The name "LLVM" itself is not an acronym; it is the full name of the project.

It is a library that is used to construct, optimise and produce intermediate and/or binary machine code.

What is clang?

Clang is a front end for the C, C++, Objective-C, and Objective-C++ programming languages, as well as the OpenMP, OpenCL, RenderScript, CUDA, and HIP frameworks. It can parse C, C++, Objective-C to LLVM.

Clang is considered to be a production quality C, Objective-C, C++ and Objective-C++ compiler when targeting X86-32, X86-64, and ARM and other targets which might have some bugs but are easy to fix.

What is llc?

The llc command compiles LLVM source inputs into assembly language for a specified architecture. The assembly language output can then be passed through a native assembler and linker to generate a native executable.

Now that we are a bit familiar with all these terms I hope they pique your interest into going further.

Install Homebrew

Apple has a set of tools called "command-line tools". It contains most of these software out of the box, but the problem is the version most likely not compatible.

Homebrew is an alternative solution to this problem, we can download other version's of software without it tampering with command-line tools. Let's install Homebrew into a directory.



cd /opt

Then



mkdir homebrew

Do this if you don't have this directory.

Then



sudo chmod go+w homebrew

This is give the right access to write into the directory.



curl -L https://github.com/Homebrew/brew/tarball/master | tar xz --strip 1 -C homebrew

This downloads homebrew into this directory

Export homebrew directory:

After installing homebrew, we need to make it a default directory. Run the following command if you're using zsh.



echo 'eval "$(/opt/homebrew/bin/brew shellenv)"' >> ~/.zshrc

or do this if you're using bash



echo 'eval "$(/opt/homebrew/bin/brew shellenv)"' >> ~/.bash_profile

Next install clang, llvm, llc and gcc with the following commands.

In this case I installed version 14 because at this time of writing llvm hasn't released version 15 yet but the latest rust compiler already has this, so I had to downgrade my rustc and reinstall the GNU tools so that they are in the same version, therefore making the compilation compatible.

When you're installing these software, be sure to note their versions



brew install clang
brew install llc
brew install llvm
brew install gcc

To install a specific version, for example, llvm.



brew install llvm@14

To downgrade rustc to the version compatible with llvm@14 and llc@14, run the following:



rustup install 1.60
rustup default 1.60

Note, The llc command compiles LLVM bytecode into assembly language for a specified architecture.

After that, you will have all the lovely GNU Compiler Collection (GCC) of tools in /usr/local/bin so you need to export it, open up your config file(.zsh or .bash_profile) and put it at the beginning or at least near it.



export PATH=/usr/local/bin:$PATH

Now link them up.



 cd /usr/local/bin
rm gcc
ln -s  gcc-VERSION_INSTALLED  gcc

Open a new terminal to confirm if you've set the correct gcc to the default compiler



 gcc --version

You should see something like this:

For compilers to find llvm you may need to set:



  export LDFLAGS="-L/opt/homebrew/opt/llvm/lib"
  export CPPFLAGS="-I/opt/homebrew/opt/llvm/include"

Now let's move on into the rusty part!
Type the following command into your terminal



rustc --version --verbose

This will show the rust version installed in your Mac, its host, the llvm compiler verison and other info.

This is how it looks like:

To check the llc version:



llc --version

You should see the following:



Homebrew LLVM version 14.0.6
  Optimized build.
  Default target: arm64-apple-darwin21.5.0
  Host CPU: cyclone
....

To check llvm version:



llvm-config --version

You should see this or whatever version you installed



14.0.6

In conclusion, versions checks are very important especially the versions with breaking changes, they can cause bugs especially dealing with rust which has a strict compiler, you need to be careful when dealing with this. If you're cross-compiling, be sure to cross-check the versions too!

I hope this post helps, These are the steps I followed to solve my errors, I'm not saying it's the ultimate solution, It's just a solution to try out👋

Build your first game using rust

Bekka — Wed, 06 Jul 2022 15:06:55 +0000

When you get familiar with rust's syntax and concepts, It's great to strengthen your mental model by building games because not only will you have fun building a game, It'll also give you another perspective when you're writing code.

In this post, we are going to build a simple hangman game using rust! But first, I'm going to list the concepts you are going to use in this program.

Prerequisites

Basic knowledge of command-line and how to traverse between directories
Basic knowledge of Rust

Concepts used in this project

Variables
Input/Output operations from the command-line
Structs and also implementing methods
Vectors
Match statements and control flow
Functions
Loops

Install Rust

If you don't have rust already installed in your machine, let's install rust. If you're using MacOs or a linux machine you can download it via install rust using rustup or if you're using windows.

It's best to run this project in your local machine and not on an online editor because some of the packages we will be using might not work as expected on an online editor.

The idea behind Hangman game

If you don't know about the famous hangman game, It's a famous game that used to be in the old Desktops (mostly windows). I used to play this game with my siblings when I was a kid.

You are given a word without letters 😄. You have to guess each alphabet that makes up that word, while you're guessing, there's a man waiting, his life is dependent on your guesses, so for each wrong guess you make, you pave the path for the poor guy to be hung, for each correct guess you make nothing happens, if you guess all the alphabets in that word correctly, he is released from his shackles!

If you wanna see a better representation of what I'm writing about, check it out here

Hangman game

Once you're done installing rust and checking out the online game, let's move into the purpose of this post.

Pseudocode/logic in human terms

Player starts the game.
Player is given a word with empty letters.
Player types in a letter in attempt to guess the word.
Player is given ten attempts to guess the word.
For every guess either wrong or right, the remaining guesses are reduced by one.
To make things harder, If the player guesses an already guessed letter, the remaining guesses are reduced by one.
If players guesses all the letters correctly before the guesses are exhausted, the player wins else the player loses.
Program ends, start again from the beginning.

In our case, the amount of guesses we have can be likened to the hangman dependent on our guesses instead of drawing the hangman in our terminal, this is too much work for that, trust me you don't want to start messing with the GUI for that(Especially for beginners), but if wanna do it, be my guest!

Creating the hangman project

Open your terminal and create a new project using cargo

cargo new hangman

This will create a new rust project and install cargo, we will be able to run this project using cargo. So cd into the newly created project and type cargo run this should print "Hello, world!" in the terminal.

Next, we add the bare bone logic for this project which is to be able to compare letters with words.

So clear all the code in the fn main () function which is in the src folder inside main.rs. Note, this is where you will be writing all the logic.

Implementing the base logic (user can guess letter and compare letters)

Firstly, we are going to initialise a struct, this will be used to keep all our "assets" something likened to the state of the program, it will also be used for observation, comparisons and more. Copy the code below.

In Rust, memory management is quite different from Javascript, in the sense that all variables are kept in memory and are freed in certain circumstances. This is great, rust has a mechanism for checking all these types using the borrow checker. This is why when you create a struct and initialise it's values won't change until you do!

Please note, this is my first project in rust, so the code style might not suit you, it's just for learning purposes, so excuse me :).


struct PlayerRoot {
        word: String,
        no_of_guesses: i8,
        available_alphabets: Vec<char>,
        list_of_words_to_guess_from: Vec<String>,
        output_string: Vec<char>,
        max_tries: i8,
        guess: String,
    }

The PlayerRoot struct already gives you an idea of how the project is going to be structured like.

Next is to implement the following;

Import rand to choose random indexes in the list of available words, std::io for input/output operations.
Create the struct handling the player's asset, which are the guesses and tries.
Implement methods into the struct to populate the struct key/values when initialised.
The generate_random_word() method is created to generate new words using rand, this is an easier way to do this because vectors are always stored on the heap, rand package is a great package for handling situations like that. If you don't really know much about the heap and stack in rust, you can read about here
The new() method to initialise the struct with the necessary values, it is also considered an idiomatic way of writing rust.
The application takes in an input from the user and compares the user's input against the random word chosen for the game round, it checks if the letter is in the random word and prints out to the console, this is done in a short loop.
Make sure the user input is a character which is of char type.
Create a list of words to choose randomly from.

Copy the following code to replace everything in main.rs.


use rand::seq::SliceRandom;
use std::io;
#[allow(dead_code)]

fn main() {
    struct PlayerRoot {
        word: String,
        no_of_guesses: i8,
        available_alphabets: Vec<char>,
        list_of_words_to_guess_from: Vec<String>,
        output_string: Vec<char>,
        max_tries: i8,
        guess: String,
    }

    struct PlayerGuesser {
        guess: char,
        tries: i8,
    }

    impl PlayerRoot {
        fn new(
            word: &str,
            no_of_guesses: i8,
            available_alphabets: Vec<char>,
            list_of_words_to_guess_from: Vec<String>,
            output_string: Vec<char>,
            max: i8,
            guess: String,
        ) -> PlayerRoot {
            PlayerRoot {
                word: String::from(word),
                no_of_guesses,
                available_alphabets,
                list_of_words_to_guess_from,
                output_string,
                max_tries: max,
                guess,
            }
        }

        fn generate_random_word(list: &Vec<String>) -> String {
            let word = list.choose(&mut rand::thread_rng()).unwrap();
            println!("word {:?}", word);
            word.to_string()
        }
    }


    //list of words for the game
    let list_of_words = vec![
        "hunting".to_string(),
        "dizzy".to_string(),
        "while".to_string(),
        "string".to_string(),
        "something".to_string(),
        "notified".to_string(),
    ];

    let random_word = PlayerRoot::generate_random_word(&list_of_words);

    let letters = vec![
        'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R',
        'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
    ];


    let guess_chars = vec![];

    // for our simple UI 
    let guess_vec: Vec<char> = random_word.clone().chars().collect();
    let output_string_vec = vec!['_'; guess_vec.len()];

    let mut player_one = PlayerRoot::new(
        &random_word,
        0,
        letters,
        list_of_words,
        output_string_vec,
        10,
        "".to_string(),
        guess_chars,
    );


    loop {
        //Takes in an input
        let mut guess = String::from("");
        io::stdin()
            .read_line(&mut guess)
            .expect("Failed to read line");
        println!("You guessed: {}", guess);
        let altered_guess = guess.chars().next().unwrap();
        for n in random_word.char_indices() {
            println!("{:?}", n.1);
            if n.1 == altered_guess {
                println!("your guess{:?}, the rest {:?}", altered_guess, random_word)
            }
        }
        break;
    }
}

Add rand into your cargo.toml like this:

rand = "0.8.5"

At this time of writing, this is the current version, you can change to any version at whatever time you are :)

You can run this code and see what it does so far.

Implementing the logic to keep the character the user has guessed and reduce the number of guesses left

For you to keep up with the guesses left and the letters guessed, you need to do a check for every guess made by the user. You're going to do the following in code.

Add a new field in the struct to keep correct guesses named correct_guesses and initialise it along with the default fields.
Add an if block to check. If a guess is made increase the guess tries by 1, if the guess is correct, push the letter into correct_guesses:vec!.

Let's write some code. Add the following to PlayerRoot struct.

     correct_guesses: Vec<char>,

Also add it to the new() method in the implement block, It should look like so;


     fn new(
            word: &str,
            no_of_guesses: i8,
            available_alphabets: Vec<char>,
            list_of_words_to_guess_from: Vec<String>,
            output_string: Vec<char>,
            max: i8,
            guess: String,
            correct_guesses: Vec<char>,
        ) -> PlayerRoot {
            PlayerRoot {
                word: String::from(word),
                no_of_guesses,
                available_alphabets,
                list_of_words_to_guess_from,
                output_string,
                max_tries: max,
                guess,
                correct_guesses
            }
        }

Look for where we initialise player_one make it mutable, create a new variable;

let guess_chars = vec![];

Add it in the player_one fields. It should look like this.

 let guess_chars = vec![];
   let guess_vec: Vec<char> = random_word.clone().chars().collect();
let output_string_vec = vec!['_'; guess_vec.len()];
    let mut player_one = PlayerRoot::new(
        &random_word,
        0,
        letters,
        list_of_words,
        output_string_vec,
        10,
        "".to_string(),
        guess_chars,
    );

You're going to comment out the current loop block we have and add a new one. Copy the following code block;

println!("Welcome to the hangman game built with rust!, please enter a letter");
loop {

        //Takes in an input
        let mut guess = String::from("");
        io::stdin()
            .read_line(&mut guess)
            .expect("Failed to read line");
        println!("You guessed: {}", guess);

        // makes sure the guess is a char
        let altered_guess = guess.trim().chars().next().unwrap();
player_one.no_of_guesses += 1;
        // creates an outer loop
        'outer: for n in random_word.char_indices() {
            // Make the check for correct guesses and does something after
            if !player_one.correct_guesses.contains(&n.1) {
                if n.1 == altered_guess {
                    player_one.correct_guesses.push(n.1);
                }
            } else {
                continue 'outer;
            }
            println!(
                "correct guess list{:?}, no of guesses {:?}",
                player_one.correct_guesses, player_one.no_of_guesses
            )
        }

    }

You can run this code and see what it does so far. Right now it prints the random word, creates a vector for correct guesses, increases the total number of guesses by one for each guess, If the guess is correct, It adds it into the vector of correct guesses, If the total guess tries is equal to the max guesses, then it's "GAME OVER!!!". All these are printed in the console for you to see.

Already, We've done a major part of the work, although there are some bugs, don't worry we'll fix them. So far, the player can guess the letters in the word and if they don't get it right within the amount of guesses given, then the game ends, the program ends.

Add a Simple UI to the Hangman game and complete the game.

Just like the most hangman games, there are blank spaces, these blank spaces are what make up the word.

In this section, you are going to build a simple UI, which is the blank spaces to depict the blank letters to fill in a word and complete the remaining part of this project.

Add the code block below, replace or comment out the loop block.


loop {

        //Takes in an input
        //Todo Check if input is more than one char
        let mut guess = String::from("");
        io::stdin()
            .read_line(&mut guess)
            .expect("Failed to read line");
        let altered_guess: char = match guess.trim().chars().next() {
            Some(val) => val,
            _ => {
                println!("No letter inputted,type a letter!");
                //It complains it needs a char :D
                '0'
            }
        };


// Checks if guess is valid
        if !player_one.output_string.contains(&altered_guess) {
            player_one.no_of_guesses += 1;

            if !player_one.word.contains(altered_guess) {
                let guess_score = player_one.max_tries - player_one.no_of_guesses;
                println!(
                    "Wrong guess\nFill in the blank spaces{:?} no of guesses remaining {:?}",
                    player_one.output_string, guess_score
                );
            }

            // loops through the word, check if guess is correct, reduces number of guess by one
            for n in player_one.word.char_indices() {
                if n.1 == altered_guess {
                    let guess_score = player_one.max_tries - player_one.no_of_guesses;

                    player_one.correct_guesses.push(n.1);
                    player_one.output_string[n.0] = n.1;

                    println!(
                        "Fill in the blank spaces{:?} no of guesses remaining {:?}",
                        player_one.output_string, guess_score
                    );
                }
            }
        } else {
            println!("That letter is taken!!! guess again")
        }
        // If the player wins
        if player_one.correct_guesses.len() == guess_vec.len() {
            println!("YOU WIN!!");
            break;
        }

        // If the player loses
        if player_one.max_tries == player_one.no_of_guesses {
            println!("GAME OVER!!! \n THE WORD IS {:?}", player_one.word);
            break;
        }
    }

Here, you did the following;

The game takes in the player's guess and makes sure it is a char, so if the user types in two letters, it takes in the first. This isn't a bug, it's a feature :)
Checks if the guess is valid
Loop through the random word given, check if guess is correct, reduces number of guess by one.
Write the condition for the player to win.
Make another condition for the player lose.

The main.rs file should look like this;


use rand::seq::SliceRandom;
use std::io;
#[allow(dead_code)]

fn main() {
    struct PlayerRoot {
        word: String,
        no_of_guesses: i8,
        available_alphabets: Vec<char>,
        list_of_words_to_guess_from: Vec<String>,
        output_string: Vec<char>,
        max_tries: i8,
        guess: String,
        correct_guesses: Vec<char>,
    }

    struct PlayerGuesser {
        guess: char,
        tries: i8,
    }

    impl PlayerRoot {
        fn new(
            word: &str,
            no_of_guesses: i8,
            available_alphabets: Vec<char>,
            list_of_words_to_guess_from: Vec<String>,
            output_string: Vec<char>,
            max: i8,
            guess: String,
            correct_guesses: Vec<char>,
        ) -> PlayerRoot {
            PlayerRoot {
                word: String::from(word),
                no_of_guesses,
                available_alphabets,
                list_of_words_to_guess_from,
                output_string,
                max_tries: max,
                guess,
                correct_guesses,
            }
        }

        fn generate_random_word(list: &Vec<String>) -> String {
            let word = list.choose(&mut rand::thread_rng()).unwrap();
            // println!("word {:?}", word);
            word.to_string()
        }
    }

    //list of words for the game
    let list_of_words = vec![
        "hunting".to_string(),
        "dizzy".to_string(),
        "while".to_string(),
        "string".to_string(),
        "something".to_string(),
        "notified".to_string(),
    ];

    let random_word = PlayerRoot::generate_random_word(&list_of_words);

    let letters = vec![
        'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R',
        'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
    ];

    let guess_chars = vec![];

    // for our simple UI
    let guess_vec: Vec<char> = random_word.clone().chars().collect();
    let output_string_vec = vec!['_'; guess_vec.len()];

    let mut player_one = PlayerRoot::new(
        &random_word,
        0,
        letters,
        list_of_words,
        output_string_vec,
        10,
        "".to_string(),
        guess_chars,
    );

    println!("Welcome to the hangman game built with rust!, please enter a letter");
    println!(
        "Fill in the blank spaces{:?}, no of guesses made {:?}, no of max tries {:?}",
        player_one.output_string, player_one.no_of_guesses, player_one.max_tries
    );

    loop {

        //Takes in an input
        //Todo Check if input is more than one char
        let mut guess = String::from("");
        io::stdin()
            .read_line(&mut guess)
            .expect("Failed to read line");
        let altered_guess: char = match guess.trim().chars().next() {
            Some(val) => val,
            _ => {
                println!("No letter inputted,type a letter!");
                //It complains it needs a char :D
                '0'
            }
        };


// Checks if guess is valid
        if !player_one.output_string.contains(&altered_guess) {
            player_one.no_of_guesses += 1;

            if !player_one.word.contains(altered_guess) {
                let guess_score = player_one.max_tries - player_one.no_of_guesses;
                println!(
                    "Wrong guess\nFill in the blank spaces{:?} no of guesses remaining {:?}",
                    player_one.output_string, guess_score
                );
            }

            // loops through the word, check if guess is correct, reduces number of guess by one
            for n in player_one.word.char_indices() {
                if n.1 == altered_guess {
                    let guess_score = player_one.max_tries - player_one.no_of_guesses;

                    player_one.correct_guesses.push(n.1);
                    player_one.output_string[n.0] = n.1;

                    println!(
                        "Fill in the blank spaces{:?} no of guesses remaining {:?}",
                        player_one.output_string, guess_score
                    );
                }
            }
        } else {
            println!("That letter is taken!!! guess again")
        }
        // If the player wins
        if player_one.correct_guesses.len() == guess_vec.len() {
            println!("YOU WIN!!");
            break;
        }

        // If the player loses
        if player_one.max_tries == player_one.no_of_guesses {
            println!("GAME OVER!!! \n THE WORD IS {:?}", player_one.word);
            break;
        }
    }
}

When you run the program the output should look like this below, of course it might be another word that is longer. This is the link to the source code

Welcome to the hangman game built with rust!, please enter a letter
Fill in the blank spaces['_', '_', '_', '_', '_'], no of guesses made 0, no of max tries 10

Conclusion

You just built your first game in rust! Woot! Congratulations on making it this far!. You can play around this project, add modifications, add GUI, add a score keeper, e.t.c.

This is a great step in learning how to code, remember it is cool to have fun at what you do. This is not really a project is to push to production, but It's great for learning. If you're learning rust check out the book, It's a great resource. What are you going to build for fun this week?😃

Lifetimes in Rust

Bekka — Tue, 17 May 2022 15:25:18 +0000

When you learn about the borrow checker, there's a new concept that you need to get familiar with and that's Lifetimes. I mentioned it briefly in my post on the borrow checker. Now, what are lifetimes?

Lifetimes are how long a reference can live in a program. What does this mean?
Let's look at the example code below.


{
let ray; // we can do this for now, but if we run it in our code, it gives a compilation error, since rust doesn't allow null values
{
let rays= "rays";  //This is how long "rays" live
ray = &rays; //this is the end of the scope
}
println!("The sun {}", &ray) //outside the scope, into the outer scope.
}

This will compile to an error that says "ray" doesn't live long enough. If you come from JavaScript you'll think, okay, this is similar to closures. I'm here to tell you that it's not. The concept of lifetimes is broader than you think.

Whenever we are using references, underneath the hood, they have smart pointers that point to the address of the value. This is how you can use references. If they point to an address that has no value the program will give a compilation error. This is why lifetimes are important.

Lifetimes can be used in functions⎯ they are annotated by 'a or 'b or any letter with the apostrophe. It is important to know where Rust data types are stored when dealing with lifetimes. Some data types are stored on the stack while some are stored on the heap. Whenever a value is initialised, it is allocated a pointer that will be used to get the address of the value, which can be used as a reference. Now the issue is when you are referencing values, they have to live long enough.

Let's see how they can be used and why it's useful to rust developers.

In functions

fn main() {
    let string1 = String::from("abcd");
    let string2 = "xyz";

    let result = longest(string1.as_str(), string2);
    println!("The longest string is {}", result);
}

// 'a lifetime syntax

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str { //parameters are string references with lifetimes. This is also used in the return type of the function.
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

When you are using lifetimes in functions, it's better to annotate the same lifetime to the parameters and also in the result type.

It might sound a bit confusing. But I want you to picture this: think about when you login into an application, under the hood. You are given a token⎯all that good stuff⎯ and you can keep logging in for as long as the token is still valid. This is similar to the way lifetimes are in rust. Whenever you are using references for some logic, you have to tell the compiler that it lives long enough by annotating the syntax, so when your code is compiling, it will check if the variable you are referring to is still valid(exists).

Why do we need this?
When a program(e.g a function) ends, memory is freed too. This is part of the role of the borrow checker. Lifetimes are needed to explicitly tell the compiler that your reference will be valid. The borrow checker does all the validations in compile-time so if you annotate a lifetime on a reference that doesn't live long enough, you'll get a compilation error.

Another way to use it is in structs.

In Structs

#[derive(Debug, Deserialize)] //this is an attribute, this type enables us to print values to the console when they don't have the display trait
struct Car<'a>{
color: &'a str //expecting a reference to a string slice
}


let car: (&str, &str)= ("toyota", "blue"); // a tuple of string slices
let new_car = Car {
color: &car.1, //this is how you reference values in a tuple
};

println!("{:#?}", new_car.color);

Whenever you use references in structures that are going to be used in logic, you have to specify lifetimes. That is how the compiler is able to keep track of the values in memory.

You can also use lifetimes in methods.

In methods

Methods are kinda similar to functions in the sense that the structure looks like a function but the actions are not.


impl <'a> Car <'a>{
fn driver_liscense (&self) -> &str {
"hello world"
}
}

Lifetimes Elision

Before you run the code block above, you might think to yourself that this code will compile to an error and then you get a bit disappointed🥲

Lifetime Elision came about when the Rust team found out that Rust programmers kept writing the same patterns of code in lifetime annotations over and over again. So they thought to themselves, "Why not help make it easier; let's cut them some slack." So they made some exceptions where Rust devs don't need to use the lifetime annotation syntax. There are three exceptions (rules).

(Note that according to the rust book, Lifetimes on function or method parameters are called input lifetimes, and lifetimes on return values are called output lifetimes.)

Now let's get into those rules:

The first rule is that each parameter that is a reference gets its own lifetime parameter, i.e., a function with a parameter gets one lifetime parameter, and a function with two parameters gets two separate lifetime parameters.

The second rule is if there is exactly one input lifetime parameter, that lifetime is assigned to all output lifetime parameters, this is demonstrated in the example above on lifetimes in functions.

The third rule is if there are multiple input lifetime parameters, but one of them is &self or &mut self because this is a method, the lifetime of self is assigned to all output lifetime parameters. This is demonstrated in the example of lifetimes in methods.

All these Elision rules apply to only functions and methods.

Finally, there are static lifetimes, they live as long as the entire program. The text of this string is stored directly in the program’s binary, which is always available. String literals are always stored in the binary.

let eyes: &'static str = "I have two eyes.";

That's the basics of lifetimes in rust, it is one of the major mechanisms in the borrow checker, once you get along with it, you'll rarely have to fight with it but you can never avoid it🤪.

This article was previously published by me at Lifetimes in rust

Primitive types and data types in Rust

Bekka — Mon, 11 Apr 2022 15:49:29 +0000

Every programming language has Its basic units and types, the way human languages are made up of vowels and consonants. They make up every line of your code in your program.
In this post, we are going to learn about Rust's data types.

What are types in Rust?
Rust is a statically typed language, which means that it must know the types of all variables at compile time. The compiler can actually infer what type we want to use based on the value we provided and also how we use it. Rust has two data types subsets. They are also referred to as Rust's primitive types. They are:

Scalar types
Compound types

Scalar types

Scalar types represent a single value. Rust has four primary types: Integers, floating-point numbers, booleans, characters.

Integers:- This is a number without a fractional component. They are used to represent whole numbers e.g 2, 3, 5 e.t.c They are also referred to as "int". In Rust, There are different values to declare the type of an int value. Examples are 8-bit -> u8, 16-bit -> u16. They could be signed like this

let negative_two: i8 = -2;

or unsigned like this

let two: u8 = 2;

The "i" means it is signed, (i.e it could be negative or positive) while the "u" means it is unsigned (i.e it is always positive). Numbers are represented in bits size, I recommend learning more about "bits" if you are unfamiliar with them.

Floating point numbers:- Rust's floating-point types are f32 and f64, which are 32 bits and 64 bits respectively. These are also known as "decimal numbers" in the math world 😄. Of course, you can perform basic numeric operations on numbers (int) and floating-point number but note that you can't do numeric operations between an i32 number and an f32. You have to convert i32 to f32 for such operations. Let's give a try

let decimal_num: f32 = 8.4;
    let whole_num: i32 = 8;

    println!("The answer is {}", decimal_num + whole_num);

This will compile to an error, telling you "cannot add i32 to f32". i32 is treated as a different type from f32 although to us humans they are still numbers. In machine code they are different. Let's fix the error in our code.

let decimal_num: f32 = 8.4; //a floating-point number
    let whole_num: i32 = 8;

    println!("The answer is {}", decimal_num + whole_num as f32);

This compiles and the answer is 16.4.

The boolean type:- Just like in most programming languages, a boolean has two possible values: true or false. This is one byte in size. It is specified using the keyword "bool"
The character type:- Rust's char type is the most primitive type in the language, according to the Rust book. They are specified in single quotes not double quotes. They are four bytes in size and the indexing patterns are not usually what you think it is.

let single_char: char = 'c'; //a char type
let single_string: &str = "c"; //a string slice

Compound types

They can group multiple values into one type, They are two in this category.

Tuple: It is a general way of grouping together a number of of values with a variety of types into one compound type. They have a fixed length, they cannot grow or shrink in size. This is an example of a tuple below.

  let two_values = (1, true);
    println!("pair is {:?}", two_values);

Arrays: Unlike tuples, an array can only have one type, i.e all values of an array must have just one type. They have a fixed length, you can access them using indexes. If you want a growable list you can use a Vector instead. Vectors are stored on the heap while arrays are stored on the stack.

let array_one = [2, 3, 5, 7]; //without a type, rust can infer the type of this array

let array_two: [i32; 4] = [2, 3, 5, 7]; //this is the standard way for initialising an array
println!("array {:?}", array_one);

Generic types

This is not a type but can be likened to a tool that allows to write code for multiple contexts with different types. This might seem complex at first, but it is a great tool for grouping code together.

I hope this cleared out some confusions on types on Rust, as they are the bare foundations to the Rust programming language. Remember to checkout the "Rust book", It's a great book to start learning how to code in Rust.

The borrow checker in Rust

Bekka — Mon, 21 Mar 2022 10:05:50 +0000

Hey guys, Welcome to another blog post on Rust!

In the last post I mentioned the borrow checker briefly. In this post, I'm going to share what I've learned so far about the borrow checker. Now before we go into that, we need to go back to the foundational knowledge we had the last time.

Rust's uniqueness is memory safety, the way it achieves this is by implementing a mechanism of ownership.

What is ownership?

Ownership is a set of rules created to manage how rust manages memory. Languages like JavaScript uses garbage collection, this basically means it frees the memory when they are not used anymore. In Rust, this is managed by a set of rules that the compiler checks, if they are violated, the program won't compile.

These rules are as follows:

Each value that is contained in a variable is tagged it's owner, or simply put any variable initialised with a value is the owner of that value. It is tagged it's owner. For example:

let basket = String::from("Basket string");

The variable basket here is tagged the owner here.

There can be only one owner at a time. This means that whatever value that is been allocated into the memory can only point to one owner at a time. For example: Using the example above but adding more modifications

let basket = String::from("Basket string");
let house = basket;
println!("This is a {}", basket);

If you're coming from JavaScript like me, doing this won't bring any error when we call the first variable basket. In Rust, this will throw an error at compile time that;

we've moved the ownership to the new variable

Of course, this won't be the exact error, but that is what it means.
Therefore basket is no longer available.

When the owner goes out of scope the value will be dropped. This means that when we initialise a variable in a function(which is also a scope) or any scope, the value is dropped when the scope is over. For example,

{
let apple = "apple";
}

println!("This fruit is an {}", apple);

This won't compile because the scope of apple has been dropped before we could access it.

What is the borrow checker?

This can be referred to as the mechanism in the compiler that checks and validates the ownership rules in your program. Whether it's a reference or if the variable owns the value.

We can't talk about the borrow checker without talking about references, the stack and the heap. For you to understand the borrow checker well, you need to learn how rust data types are stored. Because of the uniqueness of the language, you need to know whether a value is stored on the stack or the heap. It's crucial in Rust development.

The Stack and the Heap

Both the the stack and the heap are available to your code at runtime, but they are structured in different ways.

The stack stores the value in the order It gets them and removes the values in the opposite order. This can be referred to as the "the last in, first out" order. To explain this convention, think about a stack plates or a stack of books, you have to remove from the top to avoid destruction, 😆. Removing from the stack is called "popping" while adding to it is called "pushing". All data stored on the stack must be a known fixed size.

The heap is less organised, when you put data on the heap, you request a certain amount of space. The memory allocator finds an empty slot in the heap,if the memory is big enough, it allocates it to your value and returns a pointer, which is the address of the location. To explain this better, think of a park. Let's say John and his friends/family decide to go out on a picnic, they need to take a few things or a lot of things for the picnic. John goes to look for a space at the park or rent a space. The space depends on the people, their things and so on, this space can be compared to allocating memory on the heap.
The exact location of the picnic can be compared to the pointer. Let's say the picnic is under a mango tree, to locate the picnic, John tells his friends, the picnic is under the mango tree, that's how his friends are able to locate him easily.
At the end of the picnic, they go to their various homes. The space for the picnic is no longer in use. This can be compared to when the value on the heap is now deallocated or cleaned up at the end of the program. The park can be compared to as the heap.

References:- A reference is like a pointer in that, It's an address we can follow to access data stored in that address that is owned by some other variable. A reference is guaranteed to point to a valid variable of a particular type, unlike a pointer. Let's go back to the picnic example, remember John's picnic was under the mango tree, which is a location. A pointer will still point to a location even when it doesn't have any value. References don't, that's why there's another concept of lifetimes. This will be another topic, I don't want to overload this post, 😄.

So that's the basic concept of "the borrow checker", the rules that guides it, the mechanism and my thought process.
I recommend reading through the Rust book. It's where I'm learning how to write Rust. See you soon!