DEV Community: Tanisk Annpurna

Scaling Databases (Sharding)

Tanisk Annpurna — Mon, 24 Jun 2024 12:11:01 +0000

💜 DAY4 -> Scaling Databases (Sharding) 💜

As in my previous blogs, We talked about replication of databases. In this We will talk about Sharding.

👉 What is Sharding?

Sharding is simply dividing DB mutually exclusive, so data is divided.
In simple word, you divide data in smaller chunks called as shards because as data becomes huge the performance also decreases, but having smaller data does not impact performance that much.

*Real life example : *

Let's say we have a huge list of names stored on db.
Now we can divide db into 3 shards like shard1 will store names starting 'A' to 'J', shard2 -> 'K' to 'T' and shard3 -> 'U' to 'Z'.
When request comes to store new names in db, we can simply check first character and point it to proper shard for storing data.
When GET request comes, then also we will be able to decide which shard would hold data.

-> Remember Image shown above as different shards is not different database but its a single database which has 3 nodes.

SQL vs NO-SQL

Both dbs has inbuilt sharding features.
SQL follows ACID properties but NO-SQL doesn't. So if there is any update that have to be run on multiple shards, SQL will either perform operations on all shards or none shards at all. but NO-SQL can give intermediate results.

BENEFITS

Improved Scalability: It allows Dbs to handle more capacity in much better way.
Increased Performance: Any operation that works on only one shard, will achieve result much faster as data is less, so performance is more.
Fault Tolerance: If one fails, the others can continue to serve the requests. So, not complete outbreak.
Reduced Costs: Vertical Scaling is costly thus sharding allows horizontal scaling.

Why is sharding not used by default

The reason for this is very simple, Its very costly as well as time consuming for 2 shards to communicate with each other even though they belong to same DB. So it becomes absolute important to select such data on which sharding is done, so that there is none to minimum communication requirement between shards.

DAY3 -> Scaling Databases (Replication)

Tanisk Annpurna — Fri, 21 Jun 2024 18:39:43 +0000

As in my previous blogs, We talked about vertical scaling. In this We will talk about Horizontal Scaling.

HORIZONTAL SCALING

We know that for any db read & write ratio is 90:10;
The very basic scaling that we can do is have separate db just for reading and separate db for writing.
Through API we can send request to replica DB(Read operation) and Master DB(Write operation).

It would look something like shown below. (Replica DB can be multiple)

Data consistency becomes a big part as we don't want data to be different in replica db and in master db. So, its very important to replicate the data.

There are mainly 2 ways to replicate :

SYNCHRONOUS
This means that when there is any write/update operation then through code or DB, we also update replica DB at the same time thus resulting in
More response time
Slower writes
Zero replication logs
Very strong consistency.

ASYNCHRONOUS
This means that we keep logs of all the write operations on master db and at certain time we just run those logs on replica dbs. This results in
Small response time
Faster writes as it doesn't write on multiple db at a time, some replication logs
Eventual consistency.

Day1-100 series - Learning System Design for Interviews.

Tanisk Annpurna — Thu, 20 Jun 2024 14:57:41 +0000

Day2 -> Learning Databases

Remember 90% of battle is won, when you select correct database for your system.

There are 2 types of Databases Relational(SQL) and Non-Relational(NoSql). In todays post we will learn about Relational Databases, ACID properties & Scaling them.

RELATIONAL DBs

Relational DBs were originally created for financial purposes. In 90's there were financial companies had ledgers that were filled by people to mantain financial records and it was tiresome as well as error prone.
So Relational DB's were inspired from those ledgers like rows and columns. They had to follow all the properties those ledgers had.
All the properties provided by Relational DB's can be generalised to ACID properties :

A -> Atomicity
C -> Consistency
I -> Isolation
D -> Durability

ATOMICITY

This simply means that if you have multiple queries under a transaction, either all of then will be executed or none of them will be executed.

Eg. Let's say Person A is transferring 50₹ to Person B. Now we have 2 statements to execute, one would deduct 50₹ from Person A and add 50₹ to Person B. So, either both of them will have to be executed or none of them should be executed to mantain consistency between data.

CONSISTENCY

This simply means that Relation DB's provides lots of tools and features to make sure that data is consistent. Some of the features are like Foreign Keys, Constraints, Cascades, triggers and many more.

ISOLATION

This simply means that Relational DB's provide multiple levels of transparency between two transactions.

Eg. Let's say Person A and Person B are running transactions at the same time on the same data, Now we can decide on our requirements when, where or how much transparency is there about changes.

Isolations have 4 levels

READ UNCOMMITTED
This isolation level allows dirty reads, i.e., where a transaction may see uncommitted changes made by some other transaction. This means values in the data can be changed and rows can appear or disappear in the data set before the transaction completes.
In general, don’t use READ UNCOMMITTED. The one and only time it ever makes sense is when you are reading data that will never be modified in any way. For example, if you need to scan a large volume of data to generate high-level analytics or summaries, and absolute moment-of-query accuracy is not critical.
READ COMMITTED
It is the default isolation level in most Postgres databases, and older SQL databases in general.
It restricts the reader from seeing any intermediate, uncommitted, ‘dirty’ read during a transaction and guarantees that any data read was committed at the moment it was read.
REPEATABLE READ
REPEATABLE READ is the ideal isolation level for read-only transactions.
REPEATABLE READ would be a good choice for a financial app that calculates the total balance of a user’s accounts. This isolation level ensures that if a row is read twice in the same transaction, it will return the same value each time, preventing the nonrepeatable read anomaly mentioned above. In this case, when calculating a user’s total balance, REPEATABLE READ guarantees that the balance does not change during the calculation process due to concurrent updates.
SERIALIZABLE
SERIALIZABLE is the highest level of isolation (and the default isolation level in CockroachDB).
Transactions are completely isolated from each other, effectively serializing access to the database to prevent dirty reads, non-repeatable reads, and phantom reads.

SCALING DBs

There are 2 types of scaling - VERTICAL & HORIZONTAL.

VERTICAL SCALING

Vertical scaling is simpler and should always be the first option in terms of scaling.
Vertical scaling is adding more power like increasing RAMs, CPU or PROCESSOR power, MEMORIES etc.
Vertical scaling is limited by hardware, like whatever source used will have certain hardware limit.

HORIZONTAL SCALING

We know that 90% of the time we perform read operations. So, for these read operations we can have seperate db which handles only read operations.
We can do sharding, partitioning and many more things for scaling.

We will read SHARDING, REPLICATION and PARTITIONING in the next blog.

If you love posts like this, and think its beneficial, do follow and if any confusion do post any questions in comments.

Day1-100 series - Learning System Design for Interviews.

Tanisk Annpurna — Thu, 20 Jun 2024 06:12:25 +0000

Hello everyone, I am starting Day1-100 series on Learning System Design for Interviews.

We will go from 0-100 in system design. If you want to learn system design follow and share, I will be posting everyday about system designs.

Day1 -> 💜 LATENCY and THROUGHPUT 💜

Let's start,
In today's date, every system is online and is accessible to everyone across the globe. So Latency and Throughput becomes one of the most important factors to measure performance of any system.

💁‍♂️ What is Latency ?
👉 Latency is the measurement of time between request sent and response received by the system. In simple terms, when you open a website i.e. you send a request and then the delay taken for the response to arrive.
👉 Latency measured in ms(milliseconds).
👉 Low latency is always preferred over high latency. There are systems where low latency is compulsory like Online Video games and high latency always gives bad user experience.
👉 Latency can be measured using ping test or there are many tools which can measure and record latency over a period of time.

💁‍♂️ *What is throughput ? *
👉 Over the networks, we send data using data packets. Now these data packets are like small chunks of bigger data. System takes those data packets and combine them back to create the bigger data. Hence that's why we see images on websites taking much more time to load instead of text because text data is smaller in size and image data.
👉 Now, Throughput refers to the amount of data that can be transferred over a network in a period of time.
👉 So, When data is transferred through networks, due to multiple factors, data packets are lost and system will request for them again and again till it gets complete data or it hits connection timeout.(Connection is broken when it hits timeout).
👉 Throughput is measured in Mbps(megabit per second) or bps(bit per second).
👉 There are lots of tools to measure throughput of a system like when you do speedtest on your browser that also simulates network traffic generators.

🔺 Remember throughput is affected by latency and bandwidth(the internet speed that you buy from your ISP). So we use tools as it gives throughput and latency separately.

💁‍♀️ Impacting factors for latency
👉 Location : if your data has to travel long distance, latency will always be high.
👉 Protocol efficiency : Depending on the network protocol, latency may differs such as TCP does 3 handshakes for making and breaking connections. So it creates a delay.
👉 Infrastructure : if network infrastructures are overloaded, then data packets will be dropped, delayed adding it to latency.
👉 Congestion : Network data packets is bound to take longer distance routes, when there is high volume of data transferred.

💁‍♀️ Impacting factors for Throughput
👉 Bandwidth : If your network bandwidth is 1Gbps, you can send much more data packets in short amount of time resulting in less loss of data packets.
👉 Network topology : Depending on number of devices connected, distance between devices plays a major role in throughput.
👉 Packet loss : Misconfiguration, network overloaded and many more affects through put.
👉 Processing Power : Certain network devices are specialized in handling complex data packets, or more optimized interms of data packets lost.

These are few factors that affect latency and throughput of system.

Hopefully, you may have enjoyed these. Do Follow and show some love.

GoLang (Part 1)

Tanisk Annpurna — Sat, 03 Sep 2022 21:02:34 +0000

💜Little about goLang..

goLang was designed by google in 2007.
They wanted to create a language that would fix problems with traditional languages like concurrency.
Languages like Java, C++ can be used to implement concurrency but its quite hard as well as complicated.
They also wanted the new language to have better memory safety, better garbage collection, better structural typing with being much faster and readable.
goLang is very efficient and mainly used in distributed systems.
This language quite resembles with python for simplicity and C++ for efficiency.

👉Remember, The best part of goLang is it removes complication for implementing concurrency. We will look into that in the upcoming articles.

👉 Follow this article for setting up your system to run goLang Here

💜VARIABLES

Variables are like small storage values with predefined data types.
We define these to store values, that can be used ahead in the code.
We define variables :

There are 3 ways to define a variable ->
1. var <variable_name> = <value>
2. <variable_name> := <value>
3. var <variable_name> <data_type> OR var <variable_name> <data_type> = <value>

**Explanation**
1 -> When we use first way, goLang compiler automatically assigns a data type depending on the value given to it. So, First one requires value when we declare the variable else we will get compiler error as shown.

❌ var <variable_name>
✅ var <variable_name> = <value>

2 -> When we use second way, that also assigns data type automatically to the variable name and it also requires a value.

❌ <variable_name>
✅ <variable_name> := <value>

3 -> We use third way when we don't already know the value of variable. We can use it both with the value or without the value.

✅ var <variable_name> <data_type>
✅ var <variable_name> <data_type> = <value>

💜When, Where to use what??

We select between first and second way, when we need to define a const variable in the code. As by default goLang will take variables to be var.
When using first and second way to declare the variable, goLang automatically assigns data type which would not be the required behaviour always.
My personnel preference would be the third one as it works with the value or without as well as we can define a var or const and with proper data type.

💜Examples

1. var numberOfTickets = 69 // We can define here const/var but not specific data type.
2. numberOfTickets := 69 // We can't define here const/var.
3. var numberOfTickets int = 69 // We can define here const/var with proper data type.

💜Data types

**int8**      8-bit signed(+/-) integer
**int16**  16-bit signed(+/-) integer
**int32**     32-bit signed(+/-) integer
**int64**     64-bit signed(+/-) integer
**uint8**     8-bit unsigned(+) integer
**uint16**    16-bit unsigned(+) integer
**uint32**    32-bit unsigned(+) integer
**uint64**    64-bit unsigned(+) integer
**float32**  32-bit IEEE 754 floating-point number
**float64**  64-bit IEEE 754 floating-point number
**int**       Both int and uint contain same size, either 32 or 64 bit.
**uint**          Both int and uint contain same size, either 32 or 64 bit.
**complex64**   Complex numbers which contain float32 as a real and imaginary component.
**complex128**  Complex numbers which contain float64 as a real and imaginary component.
**string** word/sentences

👉 Remember, by default goLang takes either int,float64,complex64 or string i.e. highest order data type depending on the value assigned. If we need to have specific data type, we need to define it specifically.

💜Run your program

Paste this code in and run your program using "go run ."
We will look into packages, fmt and many more in the next articles.

package main

import "fmt"

func main() {

    //string
    var1 := "hello world"

    // integer
    var2 := 10
    var var6 uint = 10

    // float
    var3 := 1.55
    var var5 float32 = 1.55

    // boolean
    var4 := true

    fmt.Printf("var1 = %T\n", var1) //string
    fmt.Printf("var2 = %T\n", var2) //int
    fmt.Printf("var3 = %T\n", var3) //float64
    fmt.Printf("var4 = %T\n", var4) //boolean
    fmt.Printf("var5 = %T\n", var5) //float32
    fmt.Printf("var6 = %T\n", var6) //uint

}

💜 That's it folks. 💜

Do follow to get notified about future articles about few advanced concepts of goLang like concurrency, context and many more. Next Article would be about structure, functions and packages in goLang. 💁‍♂️ till then HAPPY READING!!

  Hello, I am Tanisk Annpurna
  I post about
  🚀web3, Blockchain, Ethereum
  🐦Smart Contract, Solidity
  🎉JavaScript, ReactJS, NodeJS and many more...
  Follow and like for more such posts. !!✌️!!

DATA STRUCTURES IN SOLIDITY

Tanisk Annpurna — Fri, 29 Jul 2022 13:23:19 +0000

You can read about basics of solidity like variables and different keywords, here 👇

Basic of Solidity (PART 2)

Let's go,

💜 Data Structures are simply a structure in which we store the data, so that it allows certain method to be implemented. This saves time as well as in some cases memory.

💜 Every Data Structures has their trade offs and proper use. So depending on the scenario, one data structure may work better than other.

💜 ARRAYS

An array is a collection of items of same data type stored at contiguous memory locations.
This makes it easier to calculate the position of each element by simply adding an offset to a base value, i.e., the memory location of the first element of the array (generally denoted by the name of the array). The base value is index 0 and the difference between the two indexes is the offset.

FIXED ARRAYS

<DATA TYPE> <ACCESS MODIFIER> <NAME>

uint[10] public balance; // This would create size of 10 indexes, If we try to store more it would fail.

address[200] private address_arr; // This would create size of 200 indexes, If we try to store more it would fail.

STORING VALUES IN ARRAYS

balance[0] = 200; // Stores value at index 0. 
balance[1] = 203; // Stores value at index 1.

👉 Remember, Arrays index starts from 0. So a 10 size array will have index from 0 to 9.

DYNAMIC ARRAYS

<DATA TYPE> <ACCESS MODIFIER> <NAME>

uint[] public balance; // This would create a dynamic size array, will increase the size as per need.

address[] private address_arr;

👉 Remember, Its good practice to use dynamic array only when required.
👉EVM implements some constraints to force developers to keep their code as much optimized as much possible.

ACCESSING VALUES IN ARRAYS

<DATA TYPE> <ACCESS MODIFIER> <NAME>

uint[10] public balance; // This would create a dynamic size array, will increase the size as per need.

🍏 public_balance[8]; //This would give the value stored at 8th position in the array.
⛔ public_balance[10]; // This would give error as index are from 0 to 9;

address[] private address_arr;

💜 MAPPING

A mapping is like a dictionary, which has key and value pair.
You simply provides the system the key, it returns the value paired with.

MAPPING

mapping(<DATA TYPE> => <DATA TYPE>) <ACCESS MODIFIER> <NAME>

mapping(string=>uint256) public balance; // This would require a key of string and values of uint256

mapping(address=>uint256) public balance2; // This would require an address as key and values of uint256

👉 Remember, Keys will have to be unique else it will overwrite the value earlier stored corresponding to the key.

STORING VALUES IN MAPPING

balance["abc"] = 26;
balance2[0x.....] = 92;

ACCESSING

balance["abc"]; //This would give result as 26.
balance2[0x....]; // This would give result as 92.

💜 STRUCT

A Struct is used when we need to combine the use of different data variables. Like one variable stores uint, string, int etc.
Its like a custom variable which one can create and use as per need. These can also store functions within themselves.

STRUCT

Struct <NAME>{ <DATA TYPE> <NAME> }

Struct People {
  uint256 number;
  String name;
}

DEFINING IT

<STRUCT NAME> <ACCESS MODIFIER> <NAME> = <STRUCT NAME> ({..provide details of variable as shown...acts as a constructor})
People public people1 = People ({number:5, name:"Tanisk"});
People public people2 = People ({number:92, name:"Sharma"});

USING IT

<NAME>.<VARIABLE IN STRUCT>
people1.name;

👉 There are more Data Structure, but these are enough for writing smart contracts as they are used extensively.
👉 There are few more but we can learn in future articles.

That's all.

In the next article, we will look into few nuances of EVM and how memory is handled in EVM.

Hello, I am Tanisk Annpurna

I post about

🚀web3, Blockchain, Ethereum

🐦Smart Contract, Solidity

🎉JavaScript, ReactJS, NodeJS

Follow and like for more such posts. !!✌️!!

SOLIDITY-101 (PART 2)

Tanisk Annpurna — Fri, 22 Jul 2022 07:26:00 +0000

You can read about basics of solidity in my last article here 👇

Solidity-101 (part1)

Let's Start

💜 VARIABLES

We have different type of values to store in program like it can be an Integer, String, Characters, boolean etc.
There are variables for integer or unsigned Integer, we can add power of 2 after variables data type and it will restrict it to certain value.
Variables in solidity are :

Integers

Numbers can be negative as well as positive but not decimals

int -> This is to tell solidity that we will store integer in this variable.
int8 -> This will store values from -2^8-1 to  2^8-1 i.e. -255 to 255.
int16 -> This will store values from -2^16-1 to  2^16-1 i.e. -65536 to 65536.
.
.
.
int256 -> This is the maximum integer value solidity store i.e. -2^256-1 to 2^256-1.

👉 Remember, writing just int or int256 is same. By default int is taken as int256.

Unsigned Integers

For Numbers that will be only positive but not negative or decimals

uint -> This is to tell solidity that we will store unsigned integer in this variable.
uint8 -> This will store values from 0 to  2^8-1 i.e. 0 to 255.
uint16 -> This will store values from 0 to  2^16-1 i.e. 0 to 65536.
.
.
.
uint256 -> This is the maximum integer value solidity store i.e. 0 to 2^256-1.

👉 Remember, writing just uint or uint256 is same. By default int is taken as uint256.

👉 This is only limited to integer and unsigned Integer.

💜 DEFINING A VARIABLE

We define variable in solidity as this pattern.

<DATA_TYPE> <ACCESS IDENTIFIER> <VARIABLE NAME>

int8 private fav_num = -8;
uint16 public fav_num = 8;
bool internal is_fav_num = true;
string external word = "Hello";
address private contractAddress = 0x70997970C.......;

💜 SPECIAL ACCESS IDENTIFIER FOR FUNCTIONS

These access identifier is just to tell EVM how the function will interact with the storage.

PURE -> This means that it will not even access the storage.

VIEW-> This means that it will only access the storage but wont change anything.

💜 EXAMPLE

address private i_owner;
uint256 public minimumUsd;

function getOwner() public view returns (address) {
        return i_owner;
}

function getAddressToAmountFunded(address funder) public view returns (uint256) {
        return s_addressToAmountFunded[funder];
}

💜 Summary

This is done because we want to eliminate unwanted storage usage.
So, if we know that values will be small then we can use uint8, uint16...etc.
This is done to keep our gas prices in control.
Depending on different task, EVM requires amount of gas to be paid. So to keep it in control we use these.

👉 Remember using PURE or VIEW -> SPECIAL ACCESS IDENTIFIER, its because these denotes that they tells EVM that they have very limited functionality and gas charge will be taken as per.

That's all.

In the next article, we will look into different Storage, Data Structures that we basically use in writing SMART CONTRACT.

Hello, I am Tanisk Annpurna

I post about

🚀web3, Blockchain, Ethereum

🐦Smart Contract, Solidity

🎉JavaScript, ReactJS, NodeJS

Follow and like for more such posts. !!✌️!!

SOLIDITY - 101 (PART 1)

Tanisk Annpurna — Sun, 17 Jul 2022 22:13:27 +0000

You can read my last article about COMPILING SMART CONTRACT, here 👇
Colmpiling Smart Contract

Let's Start

💜 VARIABLES

Variables are data items that is defined to store different values for the runtime of the program.
We have different type of values to store in program like it can be an Integer, String, Characters, boolean etc.
Variables in solidity are :

Integers

Numbers can be negative as well as positive but not decimals

int -> This is to tell solidity that we will store integer in this variable.

Unsigned Integers

Numbers can only positive but not negative or decimals

uint -> This is to tell solidity that we will store only positive integer in this variable.

Boolean

True or False

bool -> This is to tell solidity that we will store true or false in this variable.

String

A combination characters. It can be a word, sentence etc.

string-> This is to tell solidity that we will store combination of characters in this variable.

Address

Its a special type of data that is used in smart contract. As EVM has an hexadecimal unique value for every accounts or smart contract. We call them address as EVM will interact with the account/contract using the address.

address-> This is to tell solidity that we will store Address in this variable.

💜 ACCESS IDENTIFIER

Access Identifier means that we can decide who can access the variables/function or anything in the smart contract.
For Security purposes, We need to restrict the access. We do this using access Identifier.

PUBLIC -> This means that it can be accessed from anywhere, anyone can access it. No Restrictions.

PRIVATE -> This means that it can only be accessed from the contract in which its present. No contract/account from outside the contract can access it. Although they can see it but can not be accessed.

INTERNAL -> This means that no outside contract/accounts can access it. It can be accessed from within and contract's children i.e. Contracts inherited from this contract can access it. This is the default identifier i.e. If no access identifier is provided, EVM assumes this access identifier.

EXTERNAL -> This means that only external contracts/accounts can access it. if we need to use it internally then we have to use "this" keyword.

💜 DEFINING A VARIABLE

We define variable in solidity as this pattern.

<DATA_TYPE> <ACCESS IDENTIFIER> <VARIABLE NAME>

int private fav_num = -8;
uint public fav_num = 8;
bool internal is_fav_num = true;
string external word = "Hello";
address private contractAddress = 0x70997970C.......;

👉 Remember, We can also omit the access identifier and EVM by default will take internal as access identifier.
👉 Remember, Always try to use Variable Name as self-explanatory.
👉 Remember, We use " " for defining strings and ; to end any syntax.

💜 SPECIAL ACCESS IDENTIFIER FOR FUNCTIONS

These access identifier is just to tell EVM how the function will interact with the storage.

PURE -> This means that it will not even access the storage.

VIEW-> This means that it will only access the storage but wont change anything.

💜 DEFINING FUNCTIONS

We define function in solidity as this pattern.

function <FUNCTION_NAME> <ACCESS IDENTIFIER> <SPECIAL ACCESS IDENTIFIER(OPTIONAL)> returns(<DATA_TYPE>){}

function func_name public pure returns(uint){}
function func_name2 private view returns(string){}

👉 Remember, We can also omit the special access identifier.
👉 Remember, Always try to use Function Name as self-explanatory.

💜 EXAMPLE

address private i_owner;
uint256 public minimumUsd;

function getOwner() public view returns (address) {
        return i_owner;
}

function getAddressToAmountFunded(address funder) public view returns (uint256) {
        return s_addressToAmountFunded[funder];
}

That's all.

In the next article, we will look why we need special access identifiers, how we can add on these variables and use it more space effeciently.

Hello, I am Tanisk Annpurna

I post about

🚀web3, Blockchain, Ethereum

🐦Smart Contract, Solidity

🎉JavaScript, ReactJS, NodeJS

Follow and like for more such posts. !!✌️!!

COMPILING THE SMART CONTRACTS

Tanisk Annpurna — Tue, 12 Jul 2022 16:46:40 +0000

You can read more about ABI and BYTECODE here 👇

'understanding-smart-contract-bytecode-and-abi'

LETS START.....

💜 Recap

In the previous article we learnt that EVM requires ABI and BYTECODE to understand any smart contract.
ABI gives the power to interact with Smart Contract using JavaScript
BYTECODE gives commands for EVM on how to execute the Smart Contract.

if you want to understand in more depth, Please read my last article.

💜 Converting to ABI and BYTECODE

There are many framework through which we can convert Smart Contract into ABI and BYTECODE. Among them we will look into few of them.
Before that we will need smart contract to convert. So, Copy the below code into VS code or any IDE as per your preference and follow along.

SMART CONTRACT

Create a file named "SimpleSmartContract.sol".
.sol is an extension used for solidity files.
This Smart Contract is very simple, It updates a number, gets the number and multiply it with a number.

//SPDX-License-Identifier: MIT

pragma solidity ^0.8.7;

contract SimpleSmartContract {
    uint256 public number;

    function getNumber() public view returns (uint256) {
        return number;
    }

    function updateNumber(uint128 _newNumber) public {
        number = _newNumber;
    }

    function multiplyNumber(uint8 _multiple) public {
        number = number * _multiple;
    }
}

👉 Remember, There are many extensions for Solidity in VS code. You can use anyone for proper intellisense and linting. Just search solidity in extension marketplace.

💜 SOLCJS

Its a framework written in typescript and can provide ABI and BYTECODE with single command.
we have to install it using npm or yarn and for npm we need 'Node.js'. So first install Node.js if not installed.
Open any terminal and change the directory to the location where smart contract is stored.
Using NPM

npm install solc

or We can also use YARN

yarn add solc

To check if solc is installed , write

solcjs --help

if no error, then solc is installed else we need to install it again. Check location of terminal pointing to.

To compile , we use this command :

solcjs --bin --abi --include-path node_modules/ --base-path . SimpleSmartContract.sol

👉 SimpleSmartContract.sol is the name of the smart contract. Replace it with the name of your own smart contract.

👉 --bin and --abi tells the solcjs to create .bin as well as .abi file. If you need anyone then simply remove the other one from the command.

💜 BYTECODE

608060405234801561001057600080fd5b506102dd806100206000396000f3fe608060405234801561001057600080fd5b506004361061004c5760003560e01c8063297c8d7a1461005157806347a9ee3f1461006d5780638381f58a14610089578063f2c9ecd8146100a7575b600080fd5b61006b60048036038101906100669190610161565b6100c5565b005b61008760048036038101906100829190610134565b6100df565b005b6100916100fb565b60405161009e919061019d565b60405180910390f35b6100af610101565b6040516100bc919061019d565b60405180910390f35b8060ff166000546100d691906101b8565b60008190555050565b806fffffffffffffffffffffffffffffffff1660008190555050565b60005481565b60008054905090565b60008135905061011981610279565b92915050565b60008135905061012e81610290565b92915050565b60006020828403121561014a57610149610274565b5b60006101588482850161010a565b91505092915050565b60006020828403121561017757610176610274565b5b60006101858482850161011f565b91505092915050565b6101978161022e565b82525050565b60006020820190506101b2600083018461018e565b92915050565b60006101c38261022e565b91506101ce8361022e565b9250817fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff048311821515161561020757610206610245565b5b828202905092915050565b60006fffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b600060ff82169050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b600080fd5b61028281610212565b811461028d57600080fd5b50565b61029981610238565b81146102a457600080fd5b5056fea26469706673582212206ce7a9ae1c7536d9fe3d885a363d9f98f3dc8defb9d937459835ecac88104ca664736f6c63430008070033

💜 ABI

[{"inputs":[],"name":"getNumber","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint8","name":"_multiple","type":"uint8"}],"name":"multiplyNumber","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"number","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint128","name":"_newNumber","type":"uint128"}],"name":"updateNumber","outputs":[],"stateMutability":"nonpayable","type":"function"}]

👉 Remember if you want to read ABI, just change the extension from .abi to .json, The file will update and then change it back to .abi again.

You can read more about solcjs here 👉 'solcJs'

💜 REMIX IDE

Remix IDE allows developing, deploying and administering smart contracts for Ethereum like blockchains.
You can visit it here 👉REMIX IDE
Create a new file and name it "SimpleSmartContract.sol" and paste the smart contract as shown.

👉 Make sure that compiler version is set to ^0.8.7. You can set it by clicking on Solidity Compiler button at most left panel. Select Compiler from dropdown as 0.8.7+commit.. In the Smart Contract we have defined compiler version, Its best to pick the same compiler version as in Smart Contract.

After pasting the code, we can hit compile button and check if any errors. If any error Please check that compiler version is correct.
Below that Solidity Compiler, We have Deploy & Run Transaction. Select it. Keep the option as it is.

We hit Deploy button.
We can see our smart contract deploy as shown below.

Now In the Compiler tab, we can see ABI & BYTECODE button. From there one can copy the ABI/BYTECODE and have a look at it.

These are the ways one can convert the Smart Contract to ABI and BYTECODE.

👉 Remember the BYTECODE and ABI will be same for same Smart Contract. It will never be different irrespective of the method of conversion. It will only change if Smart Contract changes.

In the next article, we will see basics of solidity and how to write smart contract and deploy it.

Hello, I am Tanisk Annpurna

I post about

🚀web3, Blockchain, Ethereum

🐦Smart Contract, Solidity

🎉JavaScript, ReactJS, NodeJS

Follow and like for more such posts. !!✌️!!

Understanding SMART CONTRACT - BYTECODE & ABI

Tanisk Annpurna — Sat, 09 Jul 2022 09:24:05 +0000

In the last article, we saw how smart contracts are better than paper contracts. Read it here 👉
Intro to Smart Contracts

Lets Start....

We have seen how smart contracts are better than the old paper contracts, and how EVM makes sure that smart contracts keeps their promises.

Now, EVM doesn't understand any high level language. It understands low level language. So, we need to convert our smart contract into low level language i.e. BYTECODE.

💜 BYTECODE

Bytecode is a low level language consisting combination of numbers and alphabets.
Bytecodes are very hard to write as well as read. Basically its not human readable.
Using different frameworks like solcjs,ethers, hardhat and many more, we can convert our smart contracts into bytecodes.
This is how a bytecode looks for a very small and simple smart contract.

608060405234801561001057600080fd5b50610771806100206000396000f3fe608060405234801561001057600080fd5b50600436106100575760003560e01c80632e64cec11461005c5780636057361d1461007a5780636f760f41146100965780639e7a13ad146100b2578063b2ac62ef146100e3575b600080fd5b610064610113565b

We can see them as a combinations of numbers and alphabets.
EVM is a stack machine, meaning it uses stack to run any script. It stores functions, would PUSH function, would POP them and many more.
Bytecode may look gibberish but they are commands for EVM on how to interact with stack.
If we convert these bytecodes into OPCODE i.e. operation code, we will see how or what commands these combinations are giving to EVM.
There are many websites that can convert bytecode -> opcode. I am using etherscan. 👉https://etherscan.io/opcode-tool

This is what we get....


    [0] DUP1
    [2] PUSH1 0x40
    [3] MSTORE
    [4] CALLVALUE
    [5] DUP1
    [6] ISZERO
    [9] PUSH2 0x0010
    [10] JUMPI
    [12] PUSH1 0x00
    [13] DUP1
    [14] REVERT
    [15] JUMPDEST
    [16] POP
    [19] PUSH2 0x0771
    [20] DUP1
    [23] PUSH2 0x0020
    [25] PUSH1 0x00
    [26] CODECOPY
    [28] PUSH1 0x00
    [29] RETURN

👉 Remember EVM treats every number as a hexadecimal number. "0x" means that the number is a hexadecimal number. Now in-case of EVM, it doesn't need any "0x" as it treats every number as hexadecimal. So "0x40" in EVM we can put it as just "40".

Now these are different commands that helps EVM. Here is what they mean

PUSH1 0x40 -> This means to put 1 byte value of "0x40" in the stack. Now the hexadecimal value of PUSH1 is "60". So the commands become "6040".
MSTORE -> This will allocate memory of 0x60 and will move 0x40 in there. The hexadecimal code for MSTORE is "0x52".

So the final bytecode for these becomes...

In this way every bytecode has their meaning and tells EVM what to do. We don't require to know about what every bytecode means for writing a smart contract. Just knowing what it does is good. But if you want to learn more, Here is a link that will help a lot Ethervm.io.

Now, In the last article we saw ABI. Well, Smart contracts are only good when someone can use it. So here helps ABI.

💜 ABI

ABI stands for Application Binary Interface.
ABI's are not as complicated as BYTECODE and are human readable.
ABI looks like these :

[
  {
    "inputs": [
      {
        "internalType": "string",
        "name": "_name",
        "type": "string"
      },
      {
        "internalType": "uint256",
        "name": "_favouriteNumber",
        "type": "uint256"
      }
    ],
    "name": "addPerson",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  }
]

As we can look these are just JSON format files with extension of .abi
If we look closely these abi contains like type:'function' or "uint256" or "string".
These files contains all the details about the smart contracts like variables , their type , their name as well as name of functions, access modifiers, they are payable or non-payable and many more.

Ex-> when type is "uint256" or "string" that means its a variable but when its "function" that means its a function.

Its used when JavaScript wants to interact with smart contract, that is where abi comes in. without abi there will not be any interactions and you can't call any functions or do anything with it.

💜** Let's summarise....**

Smart contract requires bytecode and abi to run.
Bytecode is non human readable and it tells EVM on how to execute the smart contract.
Bytecode can be converted OpCode which is human readable.
Every number in bytecode means a command in EVM. EVM assumes every number as hexadecimal.
ABI is a JSON file with extension of .abi. It contains details about variables, access modifiers, function, their return types and many more.
ABI makes it possible for JavaScript to call the functions in smart contract.

👉Remember if you can write correct BYTECODE and ABI, you can simply deploy that on the chain.

In the next article, we will see in how we can convert our smart contract to bytecode and ABI. We will also get basics of solidity and how to write smart contract and deploy.

Hello, I am Tanisk Annpurna

I post about

🚀web3, Blockchain, Ethereum

🐦Smart Contract, Solidity

🎉JavaScript, ReactJS, NodeJS

Follow and like for more such posts. !!✌️!!

Introduction to SMART CONTRACTS

Tanisk Annpurna — Thu, 07 Jul 2022 21:05:44 +0000

You can read my last article on "WHY ETHEREUM" here 👇

https://dev.to/taniskannpurna/limitations-of-blockchain-solved-by-ethereum-3hei

Let's start….

💜 REAL WORLD CONTRACTS
Paper Contracts are already present in the world. So why we need the SMART CONTRACTS, well there is a issue with our current contract

Paper contracts are basically backed by Government. One relies that if the contracts agreement are not fulfilled then they can complain to government.
But What happens if the government doesn't support. What one can do if suddenly government changes something and your contract gets null.
No one can do anything now.

So what is the solution then ?....

💜 SMART CONTRACTS

Smart Contract is an electronic contract written in solidity and then deployed to EVM(Ethereum Virtual Machine).
Smart Contract is like a promise that can not be broken.

💜 HOW IT WORKS
We have already seen how blockchain and Ethereum works.

Just like bank accounts we have accounts on Ethereum.
Now We have account number in banks which is unique. Similarly, we have account address that is unique.
We have balances in bank accounts. Similarly, we have balances in accounts.

Now, Ethereum handles smart contract similarly...

When we deploy a smart contract to Ethereum, It is also treated as an account on the chain.
Ethereum provides the smart contract its unique address, its own balance and ability for other accounts to use deployed smart contracts.
These smart contracts lives on the chain and as soon as certain condition is met, it executes proper function for that.

So we can see, How any external authority or anyone can change or make the contract null.

👉 Remember, Smart Contracts once deployed on the chain can not be altered/Changed because Chain makes it too hard for the change. We can block it / give the access but we cannot alter it.

💜 APPLICATIONS OF SMART CONTRACTS
It can be used to create these ...

DeFi -> Decentralized Finance
DAOs -> Decentralized Autonomous Organization
NFTs -> Non-fungible tokens
Dapps -> Decentralized Apps

💜 HOW EVM HANDLES SMART CONTRACT

Smart contracts are written in solidity, a programming language heavily inspired by JavaScript.
But EVM does not understand solidity or any high level languages. It understand BYTECODE i.e. a low level language.
Now writing BYTECODE is not human readable, So we convert our SOLIDITY -> BYTECODE and then send to EVM.
But we also require ABI(Application Binary Interface). This helps our JavaScript code to interact with EVM BYTECODE.
Now we can use many packages to convert our smart contract into ABI and BYTECODE. Few of them are "solcjs","ethers","hardhat" and many more.

This is the way EVM handles smart contract. In the next article we will see in more details about ABI, BYTECODE and how we can convert our smart contract to these.
We will also get basics of solidity and how to write smart contract and many more..

Hello, I am Tanisk Annpurna

I post about

🚀web3, Blockchain, Ethereum

🐦Smart Contract, Solidity

🎉JavaScript, ReactJS, NodeJS

Follow and like for more such posts.
!!✌️!!

Limitations of Blockchain solved by Ethereum...

Tanisk Annpurna — Mon, 04 Jul 2022 21:31:58 +0000

You can read my last article on How transactions are made in blockchain.. here👇

https://taniskannpurna.hashnode.dev/how-transactions-goes-on-blockchain

New technology always tries to solve the limitations of previous technology.

So to understand the need of Ethereum, we need to study the limitations of blockchain and how Ethereum solves it.

💜 Just to recap, Lets first see the features of blockchain...

Blockchain was created as an alternative of paper currency as an online currency i.e. bitcoin(BTC).
The best feature that it provides is the DECENTRALIZED system i.e. not run or owned by single authority of any kind.
It provides the most secure system that is almost impenetrable.
It hashes all the data using sha256, that means if anyone changes any data then hash will change and once hash changes the NONCE(Read it in my last post) will change making the block wrong and other nodes will simply reject it.

In summary, Blockchain is a very secure decentralized system that acts as a public ledger using online currency i.e. Bitcoin.

💜 There is no as such proper limitation of blockchain. It is best on what it is meant to do, but it also does not provides a growth opportunity in its system. What I mean here is it was created as a public ledger in 2009 and today in 2022, its still working as a public ledger and nothing more.

💜 So, Using the blockchain's idea of decentralized system, its security. Can we make a system that can do more rather than just being a public ledger.

💜 The Rise of Ethereum

Ethereum also works as a public ledger just like Blockchain.
Instead of bitcoin(BTC) as online currency, It uses ether(ETH).
It is also a decentralized system which is very secured just like bitcoin.
It also hashes the data but instead of sha256, It uses keccak256 algorithm for hashing.

With these features, The biggest feature that it provides which differentiates it from blockchain is to write SMART CONTRACTS.

💜 SMART CONTRACTS
In real world, we have contracts meaning a sheet of paper authorized by government which sets some rules and requirements between two parties to achieve any kind of result.

Similarly Smart Contract is an electronic piece of code that sets some rules between any two parties. It can be another user, the system, time anyone.

💜 Facts(no 🧢) about smart contracts

Smart contracts are written in solidity. Its a programming language inspired from JavaScript.
These smart contracts are deployed on EVM i.e. Ethereum Virtual Machine.
Once deployed, Its very very hard to change the smart contract. Its easier to write a new one.

💜 Why we need the SMART CONTRACT ?

The real world contract works only in real world. The real world is a centralized system i.e. There is single unit of power or authority that controls it.
Now, These single unit of power or authority may flip a switch and the real world contract will be nullified.
Smart Contract solves this, Once the smart contract is in the network i.e. deployed then no-one can alter it. We can block the access but none can alter it.
Its a decentralized and transparent contract that will always work. It keeps the trust.

Smart contract is just like a pinky promise i.e. UNBREAKABLE PROMISE that will always follow the rule of its contract and no-one can change it.

We will look into Ethereum and Smart Contract in more details in upcoming articles. So 👇👇👇

Hello, I am Tanisk Annpurna

I post about
🚀web3, Blockchain, Ethereum
🐦Smart Contract, Solidity
🎉JavaScript, ReactJS, NodeJS

Follow and like for more such posts.
!!✌️!!