Forem: Nawodya Ishan

Simple Storage Smart Contract on Avalanche Blockchain with Solidity, TypeScript, EVM, HardHat and EthersJS

Nawodya Ishan — Sun, 23 Apr 2023 14:40:08 +0000

Introduction

Avalanche is a relatively new blockchain platform that aims to solve some of the scalability and efficiency issues faced by other blockchain networks like Bitcoin and Ethereum. It was created by a team of computer scientists led by Emin Gün Sirer, a well-known figure in the blockchain community.

Avalanche uses a novel consensus mechanism called Avalanche consensus, which allows for high throughput, low latency, and high transaction finality. Unlike traditional Proof-of-Work or Proof-of-Stake consensus algorithms, Avalanche relies on a random sampling of network participants to quickly reach consensus on the state of the network.

One of the key features of Avalanche is its ability to support multiple subnets or "blockchains within a blockchain." This means that different groups of users can create their own subnets with their own rules and governance structures while still being able to interact with the wider Avalanche network.

Another notable feature of Avalanche is its support for the creation of smart contracts using the Solidity programming language, which is also used by Ethereum. This allows developers to build decentralised applications (dApps) on the Avalanche platform with familiar tools and languages.

Overall, Avalanche is a promising blockchain platform that offers significant improvements in scalability, speed, and flexibility over other existing blockchain networks. Its unique consensus mechanism and support for multiple subnets make it an interesting option for developers and users looking to build decentralised applications or participate in a fast and efficient blockchain ecosystem.

Steps

Prerequisites

Before we begin, make sure you have the following tools installed:

Node.js (v14+)
npm (v7+)
HardHat (v2+)
Solidity (v0.8+)

Step 1: Setting up the project

Create a new directory for the project and navigate into it:

mkdir simple-storage
cd simple-storage

Initialize a new Node.js project and install the required dependencies:

npm init -y
npm install --save-dev hardhat @nomiclabs/hardhat-waffle ethereum-waffle chai @nomiclabs/hardhat-ethers ethers typescript ts-node dotenv @types/dotenv @types/mocha @types/chai avalanche

Initialize HardHat:

npx hardhat

Choose "Create an empty hardhat.config.js" when prompted.

Step 2: Configure TypeScript and HardHat

Create a new tsconfig.json file in the root of the project with the following content:

{
  "compilerOptions": {
    "target": "es2017",
    "module": "commonjs",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true,
    "resolveJsonModule": true,
    "outDir": "dist"
  },
  "include": ["./scripts", "./test"],
  "files": ["./hardhat.config.ts"]
}

Rename hardhat.config.js to hardhat.config.ts and update its content:

import { HardhatUserConfig } from 'hardhat/config';
import '@nomiclabs/hardhat-waffle';
import '@nomiclabs/hardhat-ethers';
import 'dotenv/config';

const config: HardhatUserConfig = {
  solidity: '0.8.0',
  networks: {
    hardhat: {
      chainId: 31337,
    },
  },
  mocha: {
    timeout: 20000,
  },
};

export default config;

Step 3: Creating the Simple Storage Contract

Create a new directory contracts and a new Solidity file SimpleStorage.sol inside it:

mkdir contracts
touch contracts/SimpleStorage.sol

Add the following code to SimpleStorage.sol:

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

contract SimpleStorage {
  uint256 private _storedData;

  function set(uint256 value) public {
    _storedData = value;
  }

  function get() public view returns (uint256) {
    return _storedData;
  }
}

Overview

The Simple Storage contract is designed to demonstrate the basic functionality of a smart contract by allowing users to store and retrieve data on the Ethereum blockchain. The contract consists of a single state variable that holds an unsigned integer and two functions for setting and getting the stored value.

State Variables

The contract has one state variable:

storedData: This unsigned integer (uint256) holds the stored data. It is the main data storage for the contract, and its value can be modified using the set() function and retrieved using the get() function.

Functions

The contract has two main functions:

`set()`

This function allows users to update the value of the storedData state variable. It takes a single input parameter, a uint256 value, which represents the new data to be stored.

function set(uint256 x) public {
    storedData = x;
}

When called, this function updates the storedData state variable with the provided input value.

`get()`

This function allows users to retrieve the current value of the storedData state variable. It takes no input parameters and returns the uint256 value stored in storedData.

function get() public view returns (uint256) {
    return storedData;
}

When called, this function returns the current value of the storedData state variable without modifying it.

Interaction Flow

The following steps outline the typical interaction flow for users interacting with the Simple Storage contract:

Deploy the contract: The user deploys the Simple Storage contract to the Ethereum blockchain. Upon deployment, the storedData state variable is initialized with the value of 0.
Set the stored data: The user calls the set() function, providing a uint256 value as input. The function updates the storedData state variable with the provided value.
Get the stored data: The user calls the get() function to retrieve the current value of the storedData state variable. The function returns the uint256 value without modifying it.

Conclusion

The Simple Storage smart contract demonstrates the basic functionality of a smart contract on the Ethereum blockchain. It allows users to store and retrieve an unsigned integer value through two simple functions, set() and get(). This contract serves as a starting point for understanding the fundamentals of smart contract development and can be expanded upon to implement more complex features and use cases.

Step 4: Writing tests for the contract

Create a new directory test and a new TypeScript file SimpleStorage.test.ts inside it:

mkdir test
touch test/SimpleStorage.test.ts

Add the following code to SimpleStorage.test.ts:

// @ts-ignore
import { ethers, waffle } from "hardhat";
import { Contract } from "ethers";
import { expect } from "chai";

describe("SimpleStorage", () => {
    let simpleStorage: Contract;

    beforeEach(async () => {
        const SimpleStorage = await ethers.getContractFactory("SimpleStorage");
        simpleStorage = await SimpleStorage.deploy();
        await simpleStorage.deployed();
    });

    it("Initial stored data should be 0", async () => {
        const storedData = await simpleStorage.get();
        expect(storedData.toString()).to.equal("0");
    });

    it("Should set stored data to a new value", async () => {
        await simpleStorage.set(42);
        const storedData = await simpleStorage.get();
        expect(storedData.toString()).to.equal("42");
    });
});

Step 5: Compile the contract and run tests

Compile the contract using HardHat:

npx hardhat compile

Run the tests:

npx hardhat test

If everything is set up correctly, you should see the tests passing.

Step 6: Deploy the contract on a local network

Create a new directory scripts and a new TypeScript file deploy.ts inside it:

mkdir scripts
touch scripts/deploy.ts

Add the following code to deploy.ts:

// @ts-ignore
import { ethers } from "hardhat";

async function main() {
    const SimpleStorageFactory = await ethers.getContractFactory("SimpleStorage");
    const simpleStorage = await SimpleStorageFactory.deploy();
    await simpleStorage.deployed();

    console.log("SimpleStorage deployed to:", simpleStorage.address);
}

main()
    .then(() => process.exit(0))
    .catch((error) => {
        console.error(error);
        process.exit(1);
    });

Run the deployment script:

npx hardhat run scripts/deploy.ts

You should see the contract deployed to a local address.

Step 7: Deploy the contract on Avalanche Testnet using Ethers.js

To deploy the contract on Avalanche Testnet, you need an account with test AVAX. You can get some from the Avalanche Faucet.

Add the following configuration to your hardhat.config.ts:

import { HardhatUserConfig } from 'hardhat/config';
import '@nomiclabs/hardhat-waffle';
import '@nomiclabs/hardhat-ethers'; // Add this line
import 'dotenv/config';

const config: HardhatUserConfig = {
  solidity: '0.8.0',
  networks: {
    hardhat: {
      chainId: 31337,
    },
    fuji: {
      url: "https://api.avax-test.network/ext/bc/C/rpc",
      chainId: 43113,
      gasPrice: 225000000000,
      accounts: [process.env.PRIVATE_KEY || ""],
    },
  },
  mocha: {
    timeout: 20000,
  },
};

export default config;

Make sure to replace PRIVATE_KEY in the accounts array with your private key.

Run the deployment script on Avalanche Testnet:

npx hardhat run scripts/deploy.ts --network fuji

You should see the contract deployed to an Avalanche Testnet address.

Now you have successfully created a simple storage contract in Solidity with TypeScript, EVM, and AvalancheJS, along with HardHat local testing and deployments.

Step 8: Interacting with the contract using AvalancheJS

To interact with the deployed contract, create a new TypeScript file interact.ts inside the scripts directory:

touch scripts/interact.ts

Add the following code to interact.ts:

import {ethers} from 'ethers';
import * as dotenv from 'dotenv';

dotenv.config();

const CONTRACT_ADDRESS = process.env.CONTRACT_ADDRESS as string|| '';
if (!CONTRACT_ADDRESS) {
    throw new Error('Please set your contract address in the interact.ts script');
}
// Your ABI Here
const ABI = [
    {
        "inputs": [],
        "name": "get",
        "outputs": [
            {
                "internalType": "uint256",
                "name": "",
                "type": "uint256"
            }
        ],
        "stateMutability": "view",
        "type": "function"
    },
    {
        "inputs": [
            {
                "internalType": "uint256",
                "name": "value",
                "type": "uint256"
            }
        ],
        "name": "set",
        "outputs": [],
        "stateMutability": "nonpayable",
        "type": "function"
    }
];

const FUJI_RPC_URL = "https://api.avax-test.network/ext/bc/C/rpc";
const PRIVATE_KEY = process.env.PRIVATE_KEY as string || '';

async function interact() {
    dotenv.config();
    if (!CONTRACT_ADDRESS) {
        throw new Error("Please set your contract address in the interact.ts script");
    }

    const provider = new ethers.providers.JsonRpcProvider(FUJI_RPC_URL);
    const wallet = new ethers.Wallet(PRIVATE_KEY, provider);
    console.log("Wallet address:", wallet.address);

    const simpleStorage = new ethers.Contract(CONTRACT_ADDRESS, ABI, wallet);
    console.log("Contract address:", CONTRACT_ADDRESS);
    console.log("Contract instance:", simpleStorage);

    // Read stored data
    const storedData = await simpleStorage.get();
    console.log("Stored data:", storedData.toString());

    // Set new data
    const tx = await simpleStorage.set(100);
    await tx.wait();

    // Read updated stored data
    const updatedStoredData = await simpleStorage.get();
    console.log("Updated stored data:", updatedStoredData.toString());
}

interact().then(r => console.log("Complete"));

Replace YOUR_CONTRACT_ADDRESS with the address of your deployed contract and add your contract's ABI.

Run the interaction script:

npx ts-node scripts/interact.ts

You should see the stored data, transaction receipt, and updated stored data in the console output.

╰─ npx ts-node scripts/interact.ts

Wallet address: 0x2E3bE6ddaC75f8dA97d14009A540E917d881ea92
Contract address: 0x0697aBc8Dc960d53911f4A8BB8989826b78CaF61
Contract instance: Contract {
  interface: Interface {
    fragments: [ [FunctionFragment], [FunctionFragment] ],
    _abiCoder: AbiCoder { coerceFunc: null },
    functions: { 'get()': [FunctionFragment], 'set(uint256)': [FunctionFragment] },
    errors: {},
    events: {},
    structs: {},
    deploy: ConstructorFragment {
      name: null,
      type: 'constructor',
      inputs: [],
      payable: false,
      stateMutability: 'nonpayable',
      gas: null,
      _isFragment: true
    },
    _isInterface: true
  },
  provider: JsonRpcProvider {
    _isProvider: true,
    _events: [],
    _emitted: { block: -2 },
    disableCcipRead: false,
    formatter: Formatter { formats: [Object] },
    anyNetwork: false,
    _networkPromise: Promise { <pending> },
    _maxInternalBlockNumber: -1024,
    _lastBlockNumber: -2,
    _maxFilterBlockRange: 10,
    _pollingInterval: 4000,
    _fastQueryDate: 0,
    connection: { url: 'https://api.avax-test.network/ext/bc/C/rpc' },
    _nextId: 42
  },
  signer: Wallet {
    _isSigner: true,
    _signingKey: [Function (anonymous)],
    _mnemonic: [Function (anonymous)],
    address: '0x2E3bE6ddaC75f8dA97d14009A540E917d881ea92',
    provider: JsonRpcProvider {
      _isProvider: true,
      _events: [],
      _emitted: [Object],
      disableCcipRead: false,
      formatter: [Formatter],
      anyNetwork: false,
      _networkPromise: [Promise],
      _maxInternalBlockNumber: -1024,
      _lastBlockNumber: -2,
      _maxFilterBlockRange: 10,
      _pollingInterval: 4000,
      _fastQueryDate: 0,
      connection: [Object],
      _nextId: 42
    }
  },
  callStatic: {
    'get()': [Function (anonymous)],
    'set(uint256)': [Function (anonymous)],
    get: [Function (anonymous)],
    set: [Function (anonymous)]
  },
  estimateGas: {
    'get()': [Function (anonymous)],
    'set(uint256)': [Function (anonymous)],
    get: [Function (anonymous)],
    set: [Function (anonymous)]
  },
  functions: {
    'get()': [Function (anonymous)],
    'set(uint256)': [Function (anonymous)],
    get: [Function (anonymous)],
    set: [Function (anonymous)]
  },
  populateTransaction: {
    'get()': [Function (anonymous)],
    'set(uint256)': [Function (anonymous)],
    get: [Function (anonymous)],
    set: [Function (anonymous)]
  },
  filters: {},
  _runningEvents: {},
  _wrappedEmits: {},
  address: '0x0697aBc8Dc960d53911f4A8BB8989826b78CaF61',
  resolvedAddress: Promise { <pending> },
  'get()': [Function (anonymous)],
  'set(uint256)': [Function (anonymous)],
  get: [Function (anonymous)],
  set: [Function (anonymous)]
}
Stored data: 0
Updated stored data: 100
Complete

That's it! You have now successfully developed a simple storage contract in Solidity with TypeScript, EVM, HardHat, and EthersJS, including local testing, deployments on Avalanche Testnet, and interactions with the deployed contract.

Source Code

https://github.com/nawodyaishan/avalanche-simple-storage

Ethereum Blockchain App Developer Learning Path

Nawodya Ishan — Sun, 23 Apr 2023 11:49:29 +0000

Step 1: Fundamentals of Computer Science and Programming

Learn a programming language: Start with a language like Python or JavaScript, which are beginner-friendly and commonly used in blockchain development.
- Resources: Python, JavaScript
Study data structures and algorithms: Understand basic data structures (arrays, linked lists, trees) and algorithms (sorting, searching).
- Resources: Coursera - Algorithms
Learn basic web development: Understand HTML, CSS, and JavaScript to build user interfaces for web applications.
- Resources: FreeCodeCamp

Step 2: Blockchain Fundamentals

Understand blockchain basics: Learn about distributed ledgers, consensus mechanisms, cryptography, and smart contracts.
- Resources: Blockchain Basics
Explore popular blockchain platforms: Study platforms like Ethereum, Bitcoin, and Hyperledger to understand their ecosystems and use cases.
- Resources: Ethereum, Bitcoin, Hyperledger

Step 3: Smart Contract Development

Learn Solidity: This is the primary language for writing smart contracts on the Ethereum platform.
- Resources: Solidity Documentation
Understand the Ethereum development environment: Learn about tools like Truffle, Ganache, and Metamask to streamline development.
- Resources: Truffle Suite
Study other smart contract languages: Consider learning languages like Vyper (Ethereum), Rust (Polkadot, Solana), or Go (Hyperledger).
- Resources: Vyper, Rust, Go

Step 4: Decentralized Application (DApp) Development

Learn to build DApps: Understand the architecture and components of decentralized applications.
- Resources: DApp University
Frontend development for DApps: Utilize web development skills to build user interfaces, and integrate with blockchain using libraries like Web3.js or Ethers.js.
- Resources: Web3.js, Ethers.js
Security best practices: Learn to write secure smart contracts and protect DApps from common vulnerabilities.
- Resources: Smart Contract Security

Step 5: Advanced Topics

Layer 2 scaling solutions: Study technologies like Plasma, Optimistic Rollups, and zk-SNARKs to improve blockchain scalability.
- Resources: Ethereum Layer 2 Scaling Solutions
Interoperability: Understand cross-chain communication and bridges for seamless integration between different blockchain networks.
- Resources: Cosmos, Polkadot
Decentralized finance (DeFi): Learn about DeFi protocols, lending platforms, decentralized exchanges, and other financial applications built on blockchain.
Resources: DeFi Pulse, Aave, Uniswap
Non-fungible tokens (NFTs): Understand the concept of NFTs and learn how to create, manage, and trade unique digital assets on blockchain platforms.
- Resources: OpenSea, NFT School
Identity and privacy: Study blockchain-based identity solutions and privacy-preserving techniques like zero-knowledge proofs.
- Resources: uPort, zk-SNARKs

Step 6: Hands-on Experience and Networking

Build personal projects: Create DApps, smart contracts, or other blockchain-related projects to solidify your skills and showcase your capabilities.
Contribute to open-source projects: Engage with the blockchain community by contributing to existing projects, reporting bugs, or suggesting improvements.
Participate in hackathons: Join blockchain hackathons to collaborate with others, develop new ideas, and compete for prizes.
Network: Attend conferences, meetups, and webinars to connect with other professionals, learn about the latest trends, and stay up-to-date with the industry.

Step 7: Job Search and Continuous Learning

Prepare your portfolio: Create a professional portfolio showcasing your projects, contributions, and skills to impress potential employers.
Enhance your online presence: Maintain an active presence on platforms like GitHub, LinkedIn, and Twitter to connect with industry professionals and showcase your expertise.
Apply for jobs: Look for job opportunities at blockchain startups, established companies, or freelance platforms.
Stay informed: Keep learning about new developments, technologies, and trends in the blockchain space to stay ahead in the industry.

By following this learning path, you will gain the essential knowledge and skills to become a successful blockchain app developer software engineer. Remember that the field is constantly evolving, so staying up-to-date and continuing to learn is crucial for your success.

ASP.NET Core MVC - What are HTTP Status Codes?

Nawodya Ishan — Sat, 18 Jun 2022 14:50:27 +0000

Any RESTful Web API relies on request and response. Every status code has a specific significance, and we must ensure that we are sending a proper answer with a valid status code during development.

Why HTTP Status Codes ?

HTTP response status codes represent whether or not a specific HTTP request were successfully completed. These responses are divided into the following 5 categories.

The Status-Code element in a server response is a three-digit integer where the first digit indicates the response type and the final two digits have no classifications role.

1. Informational Responses

These codes are informative, they are telling like the server has received a request and is continuing to process.

Ex:

100 Continue - This interim response indicates that the client should continue the request or ignore the response if the request is already finished.
101 Switching protocols - This code is sent in response to an Upgrade request header from the client and indicates the protocol the server is switching to.

2. Succesful Responses

This means the request has been successful and the browser has received the expected information data.

Ex:

200 OK - The request is OK. The request succeeded. The result meaning of "success" depends on the HTTP method:
- GET: The resource has been fetched and transmitted in the message body.
- HEAD: The representation headers are included in the response without any message body.
- PUT or POST: The resource describing the result of the action is transmitted in the message body.
- TRACE: The message body contains the request message as received by the server.
202 Accepted - The request is accepted for processing, but the processing is not complete.
201 Created - The request is complete, and a new resource is created .
203 Non-authoritative Information - The information in the entity header is from a local or third-party copy, not from the original server.
204 No Content - A status code and a header are given in the response, but there is no entity-body in the reply.
205 Reset Content - The browser should clear the form used for this transaction for additional input.
206 Partial Content - The server is returning partial data of the size requested. Used in response to a request specifying a Range header. The server must specify the range included in the response with the Content-Range header.

3. Redirection Responses

This code says that we have been redirected and completion of the request need further actions.

Ex:

300 Multiple Choices - A link list. The user can select a link and go to that location. Maximum five addresses .
301 Moved Permanently - The requested page has moved to a new url .
302 Found - The requested page has moved temporarily to a new url .
303 See Other - The requested page can be found under a different url .
304 Not Modified - This is the response code to an If-Modified-Since or If-None-Match header, where the URL has not been modified since the specified date.
305 Use Proxy - The requested URL must be accessed through the proxy mentioned in the Location header.
306 Unused - This code was used in a previous version. It is no longer used, but the code is reserved.
307 Temporary Redirect - The requested page has moved temporarily to a new url.

4. Client Error Responses

This indicates the client errors such as some pages cannot be reached, unavailable etc.

Ex:

400 Bad Request - The server did not understand the request.
401 Unauthorised - The requested page needs a username and a password.
402 Payment Required - You can not use this code yet.
403 Forbidden - Access is forbidden to the requested page.
404 Not Found - The server can not find the requested page.
405 Method Not Allowed - The method specified in the request is not allowed.
406 Not Acceptable - The server can only generate a response that is not accepted by the client.
407 Proxy Authentication Required - You must authenticate with a proxy server before this request can be served.

5. Server Error

These are the code that tells request is valid but the server could not complete the request.

Ex:

500 Internal Server Error - The request was not completed. The server met an unexpected condition.
501 Not Implemented - The request was not completed. The server did not support the functionality required.
502 Bad Gateway - The request was not completed. The server received an invalid response from the upstream server.
503 Service Unavailable - The request was not completed. The server is temporarily overloading or down.
504 Gateway Timeout - The gateway has timed out.
505 HTTP Version Not Supported - The server does not support the "http protocol" version.

You can learn more information via Microsoft’s Official Documentation here.

ASP.NET Core MVC - What is IActionResult?

Nawodya Ishan — Sat, 18 Jun 2022 14:45:52 +0000

The IActionResult type is a based abstraction of an ActionResult.

💡 An ActionResult is a return type of a controller method, also called an action method, and serves as the base class for *Result classes. Action methods return models to views, file streams, redirect to other controllers, or whatever is necessary for the task at hand.

It specifies how a response is going to be given for a Specific Request.

The IActionResult return type is appropriate when multiple action result return types are possible in an action.

The IActionResult is an interface, while action results themselves are abstract classes.

ASP.NET Core MVC - Introduction

Nawodya Ishan — Sat, 18 Jun 2022 14:42:52 +0000

Hey fellows, In this article series I’m going to cover the following areas in the Web development with C#, ASP .NET Core MVC, MVVM Tech Stack.

ASP .NET Core
Razor Pages and Blazor
MVC Architecture
MVVM Architecture
Models, ViewModels, Views, Partial views, Controllers, ViewComponents
Dependency injection, Major dependency injection lifetimes, Services
SQL Server configuration, EFCore migrations, Relationship types
Authentication, Authorization, Cookie-based Authentication
Azure Deployment

So, In this section, we will talk about MVC architecture at a high level.

What is MVC mean?

The Model-View-Controller (MVC) is an architectural design pattern that divides a software application/system into three main logical components,

The model
The view
The controller

Each of these components is made to control and manage specific development domains in an application.

MVC is one of the most frequently used industry-standard web development frameworks to create scalable and extensible projects.

Model

In basic C# ASP .NET Core Web applications, it acts as a C# class which holds application data as a Data Blueprint. It also manages the Database operations and relations.

Ex: Buyer, Seller, Admin User, Categories Classes in e-commerce Applications

So Basically, The Model component corresponds to all the data-related logic that the user works with.

View

The view is a component that displays the user interface. In C#, It’s the CSHTML file (Razor Views). This handles the app's data presentation and user interaction

In view, you can trigger/notify the events that get handled by the controllers.

Controller

A controller controls the workflow that a user interacts with MVC application*.* A controller contains the flow control logic for an ASP.NET MVC application. A controller determines what response to send back to a user when a user makes a browser request.

According to some folks,

Controllers are the brain of an ASP.NET Core application. They process incoming requests, perform operations on data provided through Models, and selects Views to render on the browser.

Controllers are stored inside the Controllers folder in the root of the app.

Next Article, we will talk about these 3 main sections with C# examples.

Basic Input and Output in C Language

Nawodya Ishan — Sun, 12 Jun 2022 08:59:40 +0000

Basic meaning behind the Input and output in programming is

In Input, we feed data int to a program
In Output, we feed data out from the program

The C programming language includes standard libraries that enable input and output in programs. The file pointers provide access to the file for reading and writing.

Standard File	File Pointer	Device
Standard input	stdin	Keyboard
Standard output	stdout	Screen
Standard error	stderr	Your screen

The stdio.h or standard input output library in C contains input and output methods. The header file stdio.h stands for Standard Input Output. It has the information related to input/output functions.

Function	Description
printf()	It is used to print the strings, integer, character etc on the output screen.
scanf()	It reads the character, string, integer etc from the keyboard.
getc()	It reads the character from the file.
putc()	It writes the character to the file.
fopen()	It opens the file and all file handling functions are defined in stdio.h header file.
fclose()	It closes the opened file.
remove()	It deletes the file.
fflush()	It flushes the file.

putchar(), getchar() function in C

The putchar() method in the C programming language is used to write a character to standard output/screen. The getchar() method retrieves/reads a character from keyboard input. Please see the explanation and syntax for the aforementioned file handling method below.

putchar(0

Declaration: int putchar(int char)

putchar() function is used to write a character on standard output/screen. In a C program, we can use putchar function as below.

putchar(char);

where, char is a character variable/value.

getchar()

Declaration: int getchar(void)

getchar() function is used to get/read a character from keyboard input. In a C program, we can use getchar function as below.

getchar(char);

where, char is a character variable/value.

#include <stdio.h>
int main( ) {

   int c;

   printf( "Enter a value :");
   c = getchar( );

   printf( "\nYou entered: ");
   putchar( c );

   return 0;
}

According to above example, The int getchar(void) method returns the next available character from the screen as an integer. This function only reads one character at a time. If you wish to read more than one character from the screen, you may use this technique in the loop.

The int putchar(int c) method displays the character provided to it and returns the same character. This function only inserts one character at a time. If you wish to display more than one character on the screen, you may use this approach in the loop.

But when we are using more than 1 character in a program we need to use The gets() and puts() Functions.

#include <stdio.h>
int main( ) {

   char str[100];

   printf( "Enter a value :");
   gets( str );

   printf( "\nYou entered: ");
   puts( str );

   return 0;
}

The scanf() and printf() Functions

The scanf() method, in C, reads the value from the console as per the type specified. The scanf(const char *format,...) function receives input from the standard input stream stdin and scans it using the format specified.

The printf() method, in C, prints the value passed as the parameter to it, on the console screen. The printf(const char *format,...) function outputs to the standard output stream stdout and conforms to the format specified.

Using scanf() and printf() Functions with basic data types in C.

Integer

Input: scanf("%d", &intVariable);
Output: printf("%d", intVariable);

Example:

# include <stdio.h>

int main(void)
{
    int fahrenheit, celsius;

    printf("Please enter fahrenheit as a integer: ");

    scanf("%d", &fahrenheit);

    printf("You have entered: %d as the temperature in fahrenheit", fahrenheit);

    celsius = (fahrenheit - 32) /1.8 ;

    printf("\n %d fahrenheit is %d celsius \n", fahrenheit, celsius);

    return 0;
}

Float

Input: scanf("%f", &floatVariable);
Output: printf("%f", floatVariable);

Example:

#include <stdio.h>

int main()
{
    float speed;
    printf("\n********************************");
    printf("\nEnter Your Speed: ");
    scanf("%f", &speed);
    printf("You have entered: %f as the Speed", speed);

    if (speed <= 60)
    {
        printf("\nYour Speed is Normal");
    }
    else
    {
        printf("\nYour Speed is Too High");
    }

    return 0;
}

Character

Input: scanf("%c", &charVariable);
Output: printf("%c", charVariable);

#include <stdio.h>

int main()
{
    char ch;
    printf("\n\nEnter the Character: ");
    scanf("%c", &ch);
    printf("\nEntered character is: %c", ch);
}

String

Input: scanf("%s", stringVariable);
Output: printf("%s", stringVariable);

Example:

#include <stdio.h>

int main()
{

    char str[50];

    printf("Enter the Word: ");
    scanf("%s\n", str);

    printf("\nEntered Word is: %s", str);

    printf("\n\nEnter the Sentence: ");
    scanf("%[^\n]\ns", str);

    printf("\nEntered Sentence is: %s", str);

    return 0;
}

What is %[^\n]\ns

[^\n] when we include this in scanf we will input the string until it encounter a new line in input.
%[^\n] scans everything until a \n, but doesn't scan in the \n.
^ is caret operator. It helps us to ignore a particular character.
whenever we write ^\n in scanf function, we will be able to write string with spaces and also able to store in a particular variable(here, str variable),until \n (here, \n is Enter key) is encountered.

Begin your C# Game Development Journey Using This Challenge

Nawodya Ishan — Mon, 04 Apr 2022 14:02:44 +0000

Hi Fellows,

Here we will discuss a simple but important programming challenge that will help you enhance your fundamental knowledge of C# .NET Console Applications, Data Types, Declaring Variables, Constants, & mathematical operations that are critical for game development.

C# Pre-requisites

Declaring and using variables
Calculating with integers, floats and doubles.
Prompting for inputs and Getting inputs
Declaring and Using Constants and Variables
Trigonometry with floats
Calculations and Rounding

Challenge Description

Here you want to have an impossible imagination. What if you are about to visit ancient Greek and meet Pythagoras, Hipparchus using a time machine. And you visit them with modern computers and games you developed using their amazing mathematical theories like Trigonometry and Pythagoras Theorem.

So on that occasion, you are about to show a simple program to show them how you implemented the Pythagoras theorem using C# Programming Language.

Wait !! Pythagoras' theorem is a critical theorem used in game development mostly to calculate the distance between two points.

The Pythagoras Theorem

The Pythagorean Theorem tells us how to calculate the length of the hypotenuse of a right triangle.

Then,

Here are some applications of the theorem.

Challenge !!

In the following scenario, Imagine there are two players. Player A wants to throw a projectile at Player B as they are enemies.

The requirement for Projectile Throwing is the Direction and distance of Player B from Player A's position.

First of all, we have to take the current positions of 2 Players as x y coordinates imagining a 2D cartesian plane.

Player A -> (point1X, point1y)
Player B-> (point2X, point2y)

So Let's Implement it in C# Script.

using System;
using System.Runtime.ConstrainedExecution;

namespace GameDevPythagoras
{
    /// <summary>
    /// Pythagoras Implementation for position calculation using C#
    /// </summary>
    class Program
    {
        // declaring x and y coordinates for player positions
        static float point1X;
        static float point1Y;
        static float point2X;
        static float point2Y;

then we can assign values for declared variables using the C# input function. Here we input data as a one-line string.

Player A's XY Coordinates and Player B's XY Coordinates Separated by spaces like below,

5 5 4 4

Also we assign q to end the while loop.

/// <param name="args">command-line args</param>
static void Main(string[] args)
{
    // loop while there's more input
    string input = Console.ReadLine();
    while (input[0] != 'q')

Then we read the input and assign values for points using the following function.

static void GetInputValuesFromString(string input)
{
    // extract point 1 x
    int spaceIndex = input.IndexOf(' ');
    point1X = float.Parse(input.Substring(0, spaceIndex));

    // move along string and extract point 1 y
    input = input.Substring(spaceIndex + 1);
    spaceIndex = input.IndexOf(' ');
    point1Y = float.Parse(input.Substring(0, spaceIndex));

    // move along string and extract point 2 x
    input = input.Substring(spaceIndex + 1);
    spaceIndex = input.IndexOf(' ');
    point2X = float.Parse(input.Substring(0, spaceIndex));

    // point 2 y is the rest of the string
    input = input.Substring(spaceIndex + 1);
    point2Y = float.Parse(input);
}

Then inside the previous while loop, we call the above function to assign values from the input.

// extract point coordinates from string
GetInputValuesFromString(input);

Next, we are going to calculate the distance between 2 points as a float. To do the implementation of the Pythagoras Theorem, we want the delta x and delta y as 2 vertices of the triangle.

To do the next calculations, we are going to use the Math class in C#.

Calculating Distance

Math.Sqrt -> Returns the square root of a specified number as a Double.
Math.Pow -> Returns a specified number raised to the specified power as a Double.
Math.Atan2 -> Returns the angle whose tangent is the quotient of two specified numbers as a Double.

So we calculate the distance between 2 player positions as follows.

float distance = (float) Math.Sqrt((Math.Pow(point1X - point2X, 2) + Math.Pow(point1Y - point2Y, 2)));

Basically what happens here is,

DeltaX = Player B's X Coordinate Magnitude-Player A's X Coordinate Magnitude
DeltaY = Player B's Y Coordinate Magnitude-Player A's Y Coordinate Magnitude

Then,

We use Math.Pow method by giving 2 numbers as the parameters like below,

Math.Pow (double x, double y);
double x = A double-precision floating-point number to be raised to a power.
double y = A double-precision floating-point number that specifies a power.
_

We use Math.Sqrt method by giving the number required to calculate the square root as the parameter.

Then we convert calculated double values to float using (float).

Calculating the angle

To calculate the angle we have to use Math.Atan2 method which returns the angle whose tangent is the quotient of two specified numbers.

double angle = (float)Math.Atan2(point2Y - point1Y, point2X - point1X);

This returns the radiant value of the angle, so we need to convert it to degrees to proceed.

angle *= (float)180/Math.PI;   //angle = angle * (float)180/Math.PI

> The Math.PI property represents the ratio of the circumference of a circle to its diameter, approximately 3.14159: Math.PI = π ≈ 3.14159

Next, we print out the calculation answers using Console.WriteLine method in DOT NET.

Console.WriteLine("The Distance Between Player A and B is " + (float) Math.Round(distance, 6));
Console.WriteLine("The Angle from Player A to Player B is " + (float)Math.Round(angle, 5) + " degrees");
input = Console.ReadLine();

Here is a test case.

Here you can have look at the source code.

using System;
using System.Runtime.ConstrainedExecution;

namespace GameDevPythagoras
{
    /// <summary>
    /// Pythagoras Implementation for position calculation using C#
    /// </summary>
    class Program
    {
        // declaring x and y coordinates for player positions
        static float point1X;
        static float point1Y;
        static float point2X;
        static float point2Y;


        /// <param name="args">command-line args</param>
        static void Main(string[] args)
        {
            // loop while there's more input
            string input = Console.ReadLine();
            while (input[0] != 'q')
            {
                // extract point coordinates from string
                GetInputValuesFromString(input);

                // calculate distance between points 1 and 2
                float distance = (float) Math.Sqrt((Math.Pow(point1X - point2X, 2) + Math.Pow(point1Y - point2Y, 2)));

                double angle = (float)Math.Atan2(point2Y - point1Y, point2X - point1X);

                angle *= (float)180/Math.PI;

                Console.WriteLine("The Distance Between Player A and B is " + (float) Math.Round(distance, 6));
                Console.WriteLine("The Angle from Player A to Player B is " + (float)Math.Round(angle, 5) + " degrees");
                input = Console.ReadLine();


            }
        }

        /// <summary>
        /// Extracts point coordinates from the given input string
        /// </summary>
        /// <param name="input">input string</param>
        static void GetInputValuesFromString(string input)
        {
            // extract point 1 x
            int spaceIndex = input.IndexOf(' ');
            point1X = float.Parse(input.Substring(0, spaceIndex));

            // move along string and extract point 1 y
            input = input.Substring(spaceIndex + 1);
            spaceIndex = input.IndexOf(' ');
            point1Y = float.Parse(input.Substring(0, spaceIndex));

            // move along string and extract point 2 x
            input = input.Substring(spaceIndex + 1);
            spaceIndex = input.IndexOf(' ');
            point2X = float.Parse(input.Substring(0, spaceIndex));

            // point 2 y is the rest of the string
            input = input.Substring(spaceIndex + 1);
            point2Y = float.Parse(input);
        }
    }
}

So, I believe this guide would've provided some basic introduction to C# Programming for Game Development as a beginner.

Thank you.

Introduction to Machine Learning and Hello World in Neural Networks

Nawodya Ishan — Sun, 27 Mar 2022 11:35:44 +0000

Hi fellows,

Here we are going to build basic pattern recognition models using neural networks. Neural Networks are a more advanced topic in machine learning that belongs to deep learning but in this basic introductory example we use the external libraries to make things easy a little bit.

First of you have to have some basics prerequisites of machine learning

What is Machine Learning?

Yes, as the topic says machines are learning. Machine learning is all about how machines are learning and how do we teach the machines to learn. In so near future machines can learn and do the thing that we, humans do.

From the computer programming perspective, traditionally we write computer programs by defining rules and data by ourselves to the computer.

As the following diagram, the user gives rules and data and answers come out.

But in a machine learning scenario, we give answers and data to the machine, the computer and it produces the rules, the connection between answers, and data itself.

Basically, the thing happening here is we give the exiting examples to the computer which we cant figure out how it's happening, and through machine recognizes the how it happening by the rules.

Let's take a quick simple example,
Here I show you, a Human coded BMI Calculator using Python.

# height input as "h" and weight in as "w"
h = float(input("Please Enter Your Height in cm: "))
w = float(input("Please Enter Your Weight in kg: "))
BMI = w / (h/100)**2

As above code, we can calculate each person's BMI index and give feedback on their inputs as follows.

print(f"You BMI Index is {BMI}")
if BMI <= 18.4:
    print("You are slightly underweight.")
elif BMI <= 24.9:
    print("You are pretty healthy.")
elif BMI <= 29.9:
    print("You are slightly overweight.")
elif BMI <= 34.9:
    print("You are severely overweight.")
elif BMI <= 39.9:
    print("You are obese.. -_-")
else:
    print("You are severely obese... Get Some Help")

But what if we want to calculate different health indexes using the same or different input data (like Body Adiposity Index AKA BAI, Waist-to-Hip, etc), this approach has to be failed.

So as previous diagrams explain, we teach computers that this is BMI and how to calculate BMI, this is BAI how to calculate that using given example data and outputs. So those will become Answers and Data according to our previous diagrams. what is happening inside is the computer is learning the pattern of data and answers using machine learning algorithms. So this has opened a new horizon in the computer science and data science world.

Machine Learning Road Map

Introduction to Machine Learning
Supervised Learning and Linear Regression
Classification and Logistic Regression
Decision Tree and Random Forest
Naïve Bayes and Support Vector Machine
Unsupervised Learning
Natural Language Processing and Text Mining
Introduction to Deep Learning
Time Series Analysis

if you want to study machine learning in-depth, I recommend these courses for a successful career through machine learning.

Simple Number Pattern Prediction using Neural Networks

Here I am going to show you how to do a simple pattern recognition like above using Neural Networks which is a part of Deep Learning.

Deep Learning is a more complicated advanced topic of machine learning but it is easier with neural networks to do simple pattern recognitions using external Python Libraries like NumPy, Pandas, and Tensorflow.

As previously said, machine learning is the computer learning pattern to do certain things.

So as an example following number sequence has a pattern. try to recognize this pattern.

x = -1, 0, 1, 2, 3, 4
y = -3, -1, 1, 3, 5, 7

so the relationship is,

y = 2x-1

In our mind, you might figure out that between -1 and 3 there is a difference of 2 and between 0 and -1 there is 1 difference. so there might be multiple of x with 2 and + or - of some value.

So let's implement this in the Python programming language.

Waaaiiiit !!!! Why Python? Python is simple and consistent, already have massive community support worldwide, have tons of libraries and frameworks for machine learning and data science (NumPy, Pandas, Matplotlib, Seaborn for Data Analysis and Visualization, TensorFlow, Keras, Scikit-learn for Machine learning, OpenCV, Pillow for Computer vision, NLTK, spaCy for Natural language processing)

Let's dive into our first code,

First, we import Keras API (application programming interface) from TensorFlow.

Here keras make it easy with its set of functions for neural networks. In this line of code, we implemented the simplest possible neurons. "Dense" defines the connected neurons.

As there is only one layer of dense here, there is only one layer on neurons in here. And input shape of this layer is also the simplest form with one value.

import keras

model = keras.Sequential([keras.layers.Dense(units=1,input_shape[1])])

But when it comes to machine learning we need to calculate using Linear algebra calculus and more advanced theories but in Tensorflow and Keras those complicated ones are already implemented.

but if you need to optimize and go deep you want Machine Learning Concepts with Advcanec Scientific mathematical Background.

Then we implement loss function and optimizer. The loss function guesses the relation between x and y and gives the measured result data (good or bad, how much loss or close) to the optimizer to make the next guess.
Optimizer decides the accuracy of the guess done by the loss function. Optimizers are methods or approaches that adjust the properties of your neural network, such as weights and learning rate, to decrease losses.
The main logic is here to make each guess made by loss function to be better than one before.

model.compile(optimizer="sgd", loss='mean_squared_error')

When gues are making some progress with gues becoming better and better the convergence is being used. To study more about convergence visit this site.

Next, we import the NumPy library to do calculations easily.

import numpy as np

next we implement two flat arrays to x and y values.

xs = np.array([-1.0, 0.0, 1.0, 2.0, 3.0, 4.0], dtype=float)
ys = np.array([-3.0, -1.0, 1.0, 3.0, 5.0, 7.0], dtype=float)

In the next cell we figure out how do these xs value fit in ys values by implementing model.fit method for 500 number of times. epochs = 500 means the training loop will do 500 times its guesses.

# Training the model
model.fit(xs, ys, epochs=500)

And the output looks like this

Epoch 1/500
6/6 [==============================] - 0s 36ms/step - loss: 12.7812
Epoch 2/500
6/6 [==============================] - 0s 524us/step - loss: 10.2833
…….
6/6 [==============================] - 0s 157us/step - loss: 3.9143e-05
Epoch 499/500
6/6 [==============================] - 0s 185us/step - loss: 3.8338e-05
Epoch 500/500
6/6 [==============================] - 0s 255us/step - loss: 3.7551e-05

This is called training the model. After running 500 training loops you can see that loss is getting lower. so next we do prediction of our custon number for X using predict method.

print(model.predict([10.0]))

and the output should be close to 19 but instead it showed
[[18.982122]]

This is happening because of insufficient training data.
if we Train the model with 1000 loops answer will look like this.
[[18.999987]]

So with model training, it becomes close to the real answer.

You can find the source code for this here.

Simple House Price Prediction using Neural Network Basics and Tensorflow

Here we are going to do a real-life scenario to Build a Neural network using TensorFlow.

Here is the simple formula for the prediction

House of Price with one bedroom = 100k
House of Price with one bedroom = 150k

Accordingly, the price of the houses increases by the number of bedrooms.

Here we going to build a neural network to predict the prices of houses according to their bedrooms.

here is the two x and y data for this
x = 1, 2, 3, 4, 5, 6, 7
y = 1, 1.5, 2, 2.5, 3, 3.5, 4

And Let's start by importing essential libraries for this

import tensorflow as tf
import numpy as np
from tensorflow import keras

Then we implement whole methods as loss function, optimization, and defining number arrays, defining training loops ( Here 1000 epochs ) inside a basic python function called house_model and return model with empty arguments.

def house_model():
    xs = np.array([1.0,2.0,3.0,4.0,5.0,6.0], dtype=float)
    ys = np.array([1.0,1.5,2.0,2.5,3.0,3.5],dtype=float)
    model = tf.keras.models.Sequential([tf.keras.layers.Dense(units=1,input_shape=[1])])
    model.compile(optimizer = 'sgd', loss = 'mean_squared_error')
    model.fit(xs,ys,epochs=1000)
    return model

Then we assign the number of beds to value to new_y and use predict method and execute the house_model function.

new_y = 10.0
model = house_model()
prediction = model.predict([new_y])[0]

After training the data 1000 times the prediction will print as follows

print(prediction)

[5.5149393]

You can find the source code from here.

If you want to continue your self-study in Neural networks while parallel to Machine Learning, You can follow the DeepLearning Coursera specialization by applying for financial Aid.
Visit Coursera

So, I believe this guide would've provided some basic introduction on how machine learning and artificial intelligence are applied through the neural network.

Thank you.