DEV Community: Rishabhraghwendra18

Fund Me Smart Contract using Typescript on Near (Non-EVM)

Rishabhraghwendra18 — Sun, 29 Oct 2023 11:17:10 +0000

Near is a Non-EVM blockchain with 100,000 TPS which is 3x faster, and cheaper than the Non-EVM blockchain Solana!!

On top of that, You can deploy Typescript code as a smart contract on Near!!

Let's build and deploy a fully functional FundMe DApp with Typescript smart contract on Near and learn some new concepts that make Near better than other EVM and non-EVM chains.

Here's a little preview of what we gonna build:

This DApp allows users to donate Near tokens, and allows admins to withdraw the donations from the contract from the blockchain explorer.

So let's go 🚀

Setup the development environment

Setup the development environment using the below template. It's made using Vite React and Near CLI which is much faster than the official Near's npx create-near-app CLI.

https://github.com/Rishabhraghwendra18/react-near-template

Just click on the top green button to Use this template which will setup a new repository in your account using the template.

Clone the repository created in your account on your local machine and follow the below instructions:

cd frontend 
npm i

In another terminal:

cd contract
npm i

After installing dependencies in both folders, run npm run deploy in the contract folder to deploy the dummy HelloNear contract.

On the successful deployment of the contract run, npm run dev in the frontend folder.

You will see a basic UI running at http://localhost:5173/ in the browser.

Create a testnet wallet on Near

Create a testnet wallet on Near on MyNearWallet. Near will automatically deposit $200 worth of test Near in your wallet so no need for faucets.

Fun Fact: Near doesn't provide a random hash as your wallet account address. It has named account addresses like mine is rishabh.testnet which is very easy to remember.

Let's now see step by step to build the Typescript smart contract. I will explain to you the meaning of each and every line.

Building the FundMe Contract

Navigate to contract/src/contract.ts file and remove all the code.

Import dependencies on first line:

import { NearBindgen, near, call, view,UnorderedMap } from 'near-sdk-js';

NearBindgen: This decorator helps to convert typescript classes to Near smart contracts.
near: It has lots of built-in near API like getting contract balances, caller account IDs, etc.
call: Decorator for setter functions in contract.
view: Decorator for getter functions in the contract.
UnorderedMap: An iterable hashmap data structure to store the donation amount with the donor account.

Now create a class with NearBindgen decorator:

@NearBindgen({})
class FundMe {
  beneficiary: string ="<beneficary-account-id>";
  donations= new UnorderedMap<bigint>('d');
}

You may wonder what is 'd' in the UnorderedMap. It's used as a prefix to store key-value pairs in the memory on the near blockchain. So whenever you have two unorderedmap make sure their prefixes are different.

Let's add donate function:

@call({payableFunction:true})
  donate(){
    let donor=near.predecessorAccountId();
    let donationAmount: bigint = near.attachedDeposit() as bigint;

    let donatedSoFar = this.donations.get(donor, {defaultValue: BigInt(0)})
    donatedSoFar+=donationAmount;
    this.donations.set(donor,donatedSoFar);
    near.log(`Thank you ${donor} for donating ${donationAmount}! You donated a total of ${donatedSoFar}`);
  }

Here, we have passed payableFunction:true to decorator because the caller will attach some near amount with function call. It's similar to payable in solidity.

near.predecessorAccountId(): To get the caller account ID.
near.attachedDeposit(): Near attached to the function call like msg.value in solidity.
this.donations.get(): to get the donor account ID and previously donated amount (if any, otherwise default value is 0) from the hashmap.
this.donations.set: updating new donation amount for the caller in hashmap.
near.log: To log any message on blockchain explorer when transactions complete. Same as console.log in javascript.

Wow! Donation function is complete. Let's move to withdraw_funds function which will allow the admin (the contract deployer) to withdraw the donations from the contract.

@call({privateFunction:true})
  withdraw_funds(){
    let balance=near.accountBalance() - BigInt('10000000000000000000000000');
    const promise = near.promiseBatchCreate(this.beneficiary)
    near.promiseBatchActionTransfer(promise, balance);
  }

Notice the privateFunction:true we have passed to the decorator because we want this function to only be called by the admin.

Private functions work differently in Near than EVM chains.

There's a concept of access keys in Near which is similar to Private keys but are shareable. By default, the user who deploys the contract at first has full access to smart contract functions including private functions. It enables the user to transfer tokens, cross-contract calls, and even update the contract after deployment (we will talk about this in the end).

To know more about new concepts, and cool stuff on Near visit my recent blog for an easy explanation: https://dev.to/rishabhraghwendra/near-blockchain-development-guide-for-ethereum-developers-1f1n

We are also leaving 10 Near in the contract for future use to pay for gas fees in the future:

near.accountBalance() - BigInt('10000000000000000000000000');

Since smart contract is built using Typescript it also has a Promises concept. Every token transfer and cross-contract call returns a promise. In this case, we have like this:

const promise = near.promiseBatchCreate(this.beneficiary)

Remember we can't use async/await in the contract. It's not supported.

To resolve this promise we can do something like this:

near.promiseBatchActionTransfer(promise, balance);

Now let's create the function to get all the donations list

@view({})
  get_all_donations(){
    return this.donations.toArray();
  }

It's a simple view function call that converts the donations hashmap into an array and returns it to the caller.

To get the balance of the contract:

@view({})
  view_balance(){
    return near.accountBalance();
  }

Deploy the smart contract by running npm run deploy in the contract folder. It will also output the transaction ID link on the near test net where the contract has been deployed.

Copy the transaction hash and search it on https://testnet.nearblocks.io/ for better UI.

Note: Whenever you deploy a contract using the above template it will automatically store the contract address in the contract/neardev/dev-account.env environment variable which will be automatically taken up by the frontend.

Now smart contract is done. Since it's not a frontend tutorial I will build a simple frontend and connect it with smart contract.

Building the simple frontend

The frontend is made using Vite React. If your frontend is not running, run it by running npm run dev in the frontend folder.

I am using Material UI to get some UI components. Install it in frontend folder using:

npm install @mui/material @emotion/react @emotion/styled

Go to App.jsx file and paste below code:

import * as nearAPI from "near-api-js";
import React, { useState } from "react";
import Card from "@mui/material/Card";
import CardContent from "@mui/material/CardContent";
import Button from "@mui/material/Button";
import Table from "@mui/material/Table";
import TableBody from "@mui/material/TableBody";
import TableCell from "@mui/material/TableCell";
import TableContainer from "@mui/material/TableContainer";
import TableHead from "@mui/material/TableHead";
import TableRow from "@mui/material/TableRow";
import Paper from "@mui/material/Paper";
import "./App.css";

import {  SignInButton,SignOutButton } from "./components/SignInButton.jsx";

const contractId=process.env.CONTACT_NAME;

export default function App({contractId, wallet }) {
  const [donorsList, setDonorsList] = useState([]);
  const [depositValue, setDepositValue] = useState();
  const [totalFunds, setTotalFunds] = useState('');

  // Get blockchian state once on component load
  useEffect(() => {
    getDontations()
      .then((response) => {
        const { utils } = nearAPI;

        let donors = response.map((donor) => ({
          donor: donor[0],
          amount: utils.format.formatNearAmount(donor[1]),
        }));
        setDonorsList(donors);
        console.log("response: ", response);
      })
      .catch(alert)
      getTotalFunds().then((response)=>{
        let funds =nearAPI.utils.format.formatNearAmount(response);
        funds=funds.split(".");
        let wholeNumber = funds[0];
        let decimalPart='0';
        if(funds.length>=2){
          decimalPart=funds[1].padEnd(2,'0').slice(0,2);
        }
        setTotalFunds(wholeNumber+'.'+decimalPart);
      })
  }, []);

  const getTotalFunds = async()=>{
    return wallet.viewMethod({ method: "view_balance", contractId })
  }

  function donate(e) {
    e.preventDefault();
    const deposit = nearAPI.utils.format.parseNearAmount(depositValue);

    // use the wallet to send the funds to the contract
    wallet
      .callMethod({
        method: "donate",
        deposit,
        contractId,
      })
      .then(async () => {
        console.log("Deposited!!");
        return getDontations();
      })
      .then(setValueFromBlockchain)
  }

  function getDontations() {
    // use the wallet to query the all contract's donations
    return wallet.viewMethod({ method: "get_all_donations", contractId });
  }

  return (
    <>
      {wallet.accountId ?<SignOutButton accountId={wallet.accountId} onClick={()=>{wallet.signOut()}}/>:<SignInButton onClick={()=>{wallet.signIn()}}/>}
      <main>
        <div className="flex">
          <h1>Welcome To Fund Me Contract on Near</h1>
          <h2>(Total Funds Raised: {totalFunds} Near)</h2>
          <div className="container-div">
            <div className="txn-list">
              <h3>All Donors</h3>
              <TableContainer component={Paper}>
                <Table
                  sx={{ minWidth: 400 }}
                  size="small"
                  aria-label="a dense table"
                >
                  <TableHead>
                    <TableRow>
                      <TableCell>Donor</TableCell>
                      <TableCell align="right">Amount</TableCell>
                    </TableRow>
                  </TableHead>
                  <TableBody>
                    {donorsList.map((row) => (
                      <TableRow
                        key={row.name}
                        sx={{
                          "&:last-child td, &:last-child th": { border: 0 },
                        }}
                      >
                        <TableCell component="th" scope="row">
                          {row.donor}
                        </TableCell>
                        <TableCell align="right">{row.amount} Near</TableCell>
                      </TableRow>
                    ))}
                  </TableBody>
                </Table>
              </TableContainer>
            </div>
            <div className="fund-me">
              <h3>Fund Me</h3>
              <Card>
                <CardContent sx={{display:'flex',flexDirection:'column',gap:'1.3rem'}}>
                  <label>Enter Amount</label>
                  <input
                    autoComplete="off"
                    defaultValue={0}
                    className="amount"
                    type="number"
                    onChange={(e)=>setDepositValue(e.target.value)}
                  />
                  <Button variant="contained" size="small" sx={{width:'100%'}} onClick={donate}>Submit</Button>
                </CardContent>
              </Card>
            </div>
          </div>
        </div>
      </main>
    </>
  );
}

The template has the helper class called Wallet in frontend/src/utils/near-wallet.js which has the all methods to call the call function on the contract as well as the view functions.

Checkout main.jsx to know how the template setups the Class object at the app startup.

In App.css paste this:

.flex{
    display: flex;
    gap: 1rem;
    flex-direction: column;
    align-items: center;
    justify-content: center;
}
.container-div{
    display: flex;
    flex-direction: column-reverse;
    gap: 1rem;
    width: 100%;
    align-items: center;
    justify-content: center;
}
.txn-list{
    width: 100%;
    max-width: 600px;
}
.fund-me{
    width: 100%;
    max-width: 600px;
}
.amount{
    border: 2px solid grey;
    border-radius: 0.3rem;
}

And your first DApp on Near Blockchain is ready!! 🚀

I hope you liked the blog. If you have any doubts let me know in the comments.

To support me, you can donate me some Near on rishabhrag.near 🥳

Near Blockchain Development Guide For Ethereum Developers

Rishabhraghwendra18 — Sun, 22 Oct 2023 12:37:22 +0000

Near is a non-EVM-based blockchain, similar to Solana. The best part of it is that smart contracts can be written in JavaScript/TypeScript.

However, if you haven't built on non-EVM chains before, then this blog is for you. It includes a few new concepts and some interesting facts that a developer should know before building on Near.

Smart contracts are not immutable

On Near, smart contracts are not immutable. A smart contract can be updated or changed after it's deployed unless it changes the state of the previously deployed version of the contract. This feature has both pros and cons.

Pros

This enables developers to add new features and fix bugs & security issues.

Cons

This makes the network slightly centralized, as one entity or person has full rights to change the smart contract code as needed. Therefore, before trusting the smart contract, check who has full authority to change the code. It should be linked to a multi-sig wallet.

Access Keys and Private Keys

Access Keys and Private Keys may sound similar but they have different functionalities. Access keys are derived from Private keys but are shareable.

Access keys are those keys that authorize someone to perform specific tasks based on their access permissions. This concept is similar to role-based access in Web2. For example, a company can share its wallet access keys with its employees, allowing them to spend Near tokens on behalf of the company without needing to share the private keys.

These access keys are primarily used for smart contract updates. The access key with full access to a smart contract has the authority to make any changes and publish them to the network. Therefore, it's advisable to ensure complete decentralization of the smart contract by either removing all access keys after smart contract deployment or by giving access keys to a multi-sig wallet.

There are two types of access keys:

FullAccess: This type of access grants full authority over the account, enabling actions like deleting the account, deploying a smart contract, calling any method on any contract, and transferring Near Ⓝ tokens.
FunctionCall: These keys only allow permission to call specific methods on a contract, potentially all methods, but do not permit attaching NEAR Ⓝ to the call."

Some Fun facts about Near Ⓝ

Fact 1: Contract codes are not visible on Block Explorer

This is a harsh reality, but the Near Block Explorer (https://nearblocks.io/) does not display the smart contract code, unlike what we can see on Etherscan.

Fact 2: Near has named wallet addresses.

You read it correctly. Unlike other blockchains where you receive an unmemorable hash as your wallet address, Near provides named wallet addresses by default, such as mine: rishabhrag.near.

This wallet address is referred to as a TLD (Top Level Domain), and it can be used to create sub-domains as well, such as rishabhrag.school.near.

These are some of the new concepts and facts I discovered when transitioning from an EVM-based blockchain to a non-EVM-based blockchain. I hope they will assist new developers who are venturing into Near, as it took me two days to grasp these new concepts.

If you found this information helpful and would like to show your appreciation, you can donate to me at rishabhrag.near.

Your contribution would be greatly appreciated.

Thanks for reading, and have a fantastic day! Keep building on Near!

What is Rust Progamming Language | Why Big Tech Companies are using it in Production | Why you should learn it in 2022

Rishabhraghwendra18 — Sat, 29 Jan 2022 14:26:17 +0000

“If you want your application in production for 10+ years with very less need of maintenance prefer Rust else Go”

As per StackOverflow survey 2020 , Rust is the most beloved language in the developer community .

So what makes Rust so amazing even than Python or TypeScript ? Why are people suggesting to write the whole Linux kernel in Rust ? We will answer all these questions and explore the uniqueness of Rust. We will discuss about:

Features of Rust that are different from other languages
Companies who use Rust and why they use it
Cons of Rust
Conclusion whether you should learn Rust or not in 2022

So let’s begin

Introduction

Rust is a statically typed programming language without a garbage collector (yes , it doesn’t have a garbage collector) and with more focus on safety, speed and more low level control without sacrificing the high level syntax. It's developed by keeping in mind the core issues of the today's high level languages, for example data races conditions in multithreading programs.

Rust was originally made as a side project at Mozilla Research by Graydon Hoare. It was first launched on 7th July 2010.

Today many tech giants like AWS , Microsoft use Rust in production . It’s new way of managing memory has made developers write bug free code (not completely free) without sacrificing speed and performance . It can be used in different domains like Web, Blockchain , Game , Networking and even for Embedded devices because it’s minimal (or no) runtime. Let’s see what Rust has to offer

Unique features of Rust that no other language provide

The ownership model

If you are a C/C++ developer then you have experienced the problem of dangling pointers aka when a pointer points to an already freed memory location . In such a situation your programs crash. This is a major issue which is present in many languages , even if they don’t have pointers . The used garbage collector to automatically deallocate memory instead of the programmer has to do. But this is also not a full proof solution . Garbage collector instead has its own bugs. Due to such bugs and inappropriate memory management lead to memory leaks and memory related security issues.

Rust tries to solve this issue using it’s ownership model concept. In rust there is a concept of ownership. If we pass an object to a function , instead of passing it as by reference the parameters of the function takes the ownership of the object. Let’s take an example to get a clear picture:

#[derive(Debug)]
struct Person{
   name: String,
   age: u64,
}

fn show_struct(person_obj: Person){
   println!("Name is: {} and age is {}",person_obj.name,person_obj.age);
}
fn main() {
  let person1 = Person{
      name: String::from("Rishabh Raghwendra"),
      age:19
  };
  show_struct(person1);
  println!("{:#?}",person1); // here we get the error
}

If you run this code in , Rust compiler will give you an error borrow of moved value:person1value borrowed here after move .

We have created a struct called Person and an object of it in main() as person1. We then passed the object to function show_struct() to print the object contents. After that we tried to print the person1. The reason we get the error at the print statement because of person1 is no longer the owner of the object.

When we passed the person1 to the show_struct() function , it’s parameters took the ownership of the person1 object. Hence person1 is no longer the owner of the object.

There is a way to not let the function parameters take the ownership , by passing it as pass by reference as we do in C/C++ . It is out of the scope of the blog so we will discuss about in my future blog.

This model prevents the misuse of memory without the need of a garbage collector.

Fearless Concurrency

Ever run in a data race condition or deadlock situation while doing multi-threading programming ? If yes , then you definitely run in any one of these situations and you even know how hard it is to write a correct multi-thread program and also how hard to debug it if something bad happens in production . Ahhhhh!!! Never push your code on Fridays.

Rust has special attention to concurrency and memory safety . It gives you errors at compile time rather than at runtime. Rust again uses an ownership model to prevent access to invalid memory . For eg take a look at this Rust code:

use std::thread;

fn main() {
   let v = vec![1, 2, 3];

   let handle = thread::spawn(|| {
       println!("Here's a vector: {:?}", v);
   });

   drop(v); // oh no!

   handle.join().unwrap();
}

We spawn a thread with a closure who is accessing vector ‘v’ and store the thread instance in variable ‘handle’. After that we tried to drop the (free up) vector ‘v’.

If you implement the same logic in other programming languages like C/C++ or Python . You will get a Segmentation Fault error which will lead your program to crash and hackers to gain access to your system , nice.

If you run this code in Rust . It will give you an error saying that you don’t have the right to drop the variable ‘v’ because its value is moved to the thread . The ownership model kicked in!!. It does so because rust compilers have trust issues with us (thread: what’s the guarantee that ‘v’ will be valid till I am doing my work). That's why Rust compiler asks you to give the ownership of the variable to the thread so that it can fearlessly use the variable ‘v’. To see the solution of the above error see this link.

See how rust stopped you from making a nasty concurrency bug at compile time and saved your weekend . Such type of development Rustaceans called Compiler Driven Development.

Friendly Compiler

If you have run the above examples (you can run it in Rust Playground) , you have seen that the compiler gives you solutions/hints to the errors too. Rust compiler is very intelligent and tries to give you the appropriate solution to the error in a friendly readable way. This is one of the features that made developers love Rust.

Companies who uses Rust in Production

Microsoft

Microsoft has now started to migrate their C/C++ codebase to Rust . The reason is that they have found that most security issues are related to memory. They tried to solve the issue on their own using C/C++ but failed to do so . The only option they are left with is to migrate their C/C++ codebase to Rust which prevents 90% of the memory related issues at compile time only.

For more info watch this video.

Facebook

Facebook used Rust to rewrite their source control backend which was originally written in Python . Rust attracted their attention because they want speed & memory safety which is only Rust's able guarantee .

For more info watch this video.

Discord

Discord has written both their client-side and server-side in Rust. They rewritten the Read state service in Rust which was originally written in Go. Due to the Go garbage collector they see unexpected high latency spikes randomly. The only solution they are left with is to rewrite everything in Rust because it doesn’t have a garbage collector and ensures memory safety. Till now their experience with Rust is very positive and the codebase is easily able to serve 11 million users at a time.

For more info read this official discord blog.

NPM

Engineers at NPM realized that their service performance would soon become a bottleneck if the user increased. They refused to use C/C++ and Java because they don’t provide memory safety and they don’t want to deploy JVM on their servers. The only best fit as per their requirements is Rust. They believe it’s the right choice they have made, as Rust has the most friendly compiler and community. They also have positive experience with Rust till now.
For more info read this official Rust whitepaper

Cons of Rust

Rust has steep learning Curve

Rust involves lot’s of new programming concepts which you haven’t heard of or used in any of the programming languages like Python , Java , C++ . For eg as we have seen there are concepts of ownership , it also has a concept known as lifetimes and these are the major concepts of Rust and most of the time Rust developers find themselves fighting with the compiler. Hence , Rust is not preferred to be your first language.

Slow compilations time

It has slow compilation time. For bigger projects it can be more than 5 mins . Even it uses some methods to reduce the compilation time but it doesn’t have much effect. Rust compilation time has decreased from the legacy releases but still it’s slow and most importantly if your machine doesn’t have enough RAM then it may slow down your machine performance. Therefore , for now , it’s recommended to use some host servers to compile the Rust code , as it can drastically reduce the compilation time.

Small developer community

Rust is a new language , hence it’s community is not so big . You can get stuck in some errors but there is no solution for it on google or stackoverflow even. But this is not a big issue . You can join their discord server , there are already more than 2k+ developers on the server , where you can get 24x7 support . It’s a very welcoming community and you should be a part of it if you are learning Rust.

Conclusion: Whether you should learn Rust or not in 2022

In my opinion , Rust has a bright future . Despite not being a beginner friendly or smaller developer community , it has lots of features and memory safety guarantees which other languages don’t . If you are a beginner , just starting out your career in programming then Rust is not a best fit for you . It may demotivate you from programming . So it’s best to learn other languages like Python , Java and when you become comfortable with them then learn Rust. Otherwise if you want to learn system programming then Rust can be a best choice for you.

If you have any doubts , feel free to comment down below . I will be happy to help you.

To see my projects or to get in personal touch , follow me on:
Linkedin:https://www.linkedin.com/in/rishabh-sde/
GitHub: https://github.com/Rishabhraghwendra18
Thanks for reading
Written with ❤️ & passion 🔥 by Rishabh Raghwendra

SDLC: Agile Model

Rishabhraghwendra18 — Tue, 17 Aug 2021 14:15:01 +0000

Agile model is commonly used by SDLC these days because of its adaptability to changing requirements . It is a combination of Iterative & Incremental models . It focuses on process adaptability & rapid delivery of working software products .

In Agile , requirements are divided in small incremental builds (iteration). Each build lasts for about 1-2 months . Each build is planned in advance . At the end of each build customers feedback is taken on the current build. The final build has all requirements.

Here’s the diagram of Agile Model:

Each Build has to go through Design , Development and Testing.

Check out my blog SDLC to get the gist of the process.

Use Cases

Frequent changes are required
Highly skilled team is available
Customer is ready to have interaction frequently
Project size is small

Pros of Agile Model

Easy to manage
Little or no planning required
Reduces total development time
Customer interaction is the backbone of the model
Minimum documentation required
Adaptive to changing requirements

Cons of Agile Model

Not good fit for complex projects
Risk of sustainability , maintainability & extensibility
Heavily dependent on customer interaction . If customer is not clear then team can be guided in wrong direction
Very high dependency on an individual since less documentation is made
Due to less documentation passing of the project to new team members is difficult
An overall plan and an agile expert/leader is needed without him/her the model is difficult to follow .

So far, we have discussed the Model, it’s use cases, pros & cons.

More information on waterfall model & iterative model is in my other blog’s, here’s the link :
WaterFall Model: https://dev.to/rishabhraghwendra/sdlc-waterfall-model-307n
Iterative Mode: https://dev.to/rishabhraghwendra/sdlc-iterative-model-1lb6

Feel free to comment if you have any questions. All comments are greatly appreciated. If you like the blog , don’t forget to like it & share with your friends/colleagues.

To see my projects or to get in personal touch , follow me on:
Linkedin:https://www.linkedin.com/in/rishabh-sde/
GitHub: https://github.com/Rishabhraghwendra18

Thanks for reading
Written with ❤️ & passion 🔥 by Rishabh Raghwendra

SDLC: Iterative Model

Rishabhraghwendra18 — Wed, 21 Jul 2021 14:38:12 +0000

In the Iterative Model , the development starts with a small set of requirements. Once this set of requirements is completed , then a new set of requirements is implemented again . This process of implementation goes on iteratively until unless the complete set of requirements is not implemented.

In each iteration , we design , test & deploy . Every iteration has a fixed time in which it should be completed .

Here’s the diagram , representing iterations as ‘Build 1’ , ‘Build 2’ and ‘Build 3’:

Each Build (iteration) has to go through Design , Development , Testing & Deployment (Implementation as per the diagram)

Check out my blog SDLC to get the gist of the process.

When to use the model

This model is best fit for project which are:
Requirements are clearly defined
Client wants working model at each iteration
New technologies are implemented & learnt on the way
Not availability of highly skilled team
Highly risky project

Pros of Iterative Model

A working model is ready in end of every iteration
Feedback of client can be taken at each iteration
Supports changing requirements
Risk management is easy . Highly risky part is done first
Suitable for large & critical projects
Parallel development is possible

Cons of Iterative Model

Not suitable for smaller projects
More resources are required
More attention of management is required
Management complexity is more
End of project is not defined , which can be risky
System design or architecture issues may arise because all requirements is not gathered at the beginning

So far, we have discussed the Iterative model, it’s use cases, pros & cons.

More information on Waterfall Model is in my other blog’s, here’s the link
WaterFall Model: https://dev.to/rishabhraghwendra/sdlc-waterfall-model-307n

Feel free to comment if you have any questions. All comments are greatly appreciated. If you like the blog , don’t forget to like it & share with your friends/colleagues.

To see my projects or to get in personal touch , follow me on:
Linkedin: https://www.linkedin.com/in/rishabh-sde/
GitHub: https://github.com/Rishabhraghwendra18

Thanks for reading
Written with ❤️ & passion 🔥 by Rishabh Raghwendra

SDLC: WaterFall Model

Rishabhraghwendra18 — Tue, 13 Jul 2021 14:46:29 +0000

The Waterfall Model was the first Process Model to be introduced. It was widely used as it was easy to understand & implement .

WaterFall Model is also known as Linear-Sequential Life Cycle Model because work is done linearly - the next stage begins after completion of the previous stage . Output of the previous stage is the input of the next stage .

The name “WaterFall Model” is because the process looks like flowing steadily downwards - as shown below just like a waterfall .

The Phases are:-

Requirement Analysis: In this phase all the requirements about the project are gathered . For eg features in projects , etc . All these requirements are well documented in the SRS ( Software Requirement Specifications ) document.
System Design: The SRS document is then used to design the system . Defining system requirements like hardware, modules (any),etc.
Implementation: After the System design phase is completely over . Implementation phase starts . Here each unit is individually developed . This stage goes on until all the requirements in the SRS document are not developed .
Testing & Integration: Each individual unit is tested for potential bugs or errors . After testing is successful , individual units are integrated together.
Deployment: Once the integration is done, the software is deployed to production servers.

Note: Before deploying to production , the project is tested again (we are not going into much details).

Maintenance: Project is continuously being monitored for any user inconvenience or bugs . Time to time new patches are released as a result of any bug fixes.

Projects best fit for WaterFall Model:

Requirements are clear
Technology used is not dynamic
Project is short

Advantages of WaterFall Model:

Model is simple & easy to understand
Clear defined milestones & deadlines
Properly documented , hence team is focused towards one common goal
Clearly defined stages
Easy to arrange tasks

Disadvantages of WaterFall Model:

No working software is made till end of life cycle
Client feedback is not taken at any stage.
Not good fit for changing project requirements
Not suitable for OOPs & long-on going projects
Difficult to track progress within a stage
Includes high amount of risk & uncertainty

So far, we have discussed the WaterFall model, it’s use cases, advantages & disadvantages.

Feel free to comment if you have any questions. All comments are greatly appreciated. If you like the blog , don’t forget to like it & share with your friends/colleagues.

To see my projects or to get in personal touch , follow me on:
Linkedin: https://www.linkedin.com/in/rishabh-sde/
GitHub: https://github.com/Rishabhraghwendra18

Thanks for reading,
Written with ❤️ & passion 🔥 by Rishabh Raghwendra

Software Development Life Cycle: Beginners Guide

Rishabhraghwendra18 — Fri, 25 Jun 2021 14:04:11 +0000

You may have heard the term Software Development Life Cycle (SDLC) and are curious to know what it means and it’s benefits?
My Blog will provide all that information in a simplified way for the beginners.

What is SDLC?
SDLC stands for software development life cycle.It’s a systematic process for building software that ensures the quality & correctness of the software build .In simple terms , it’s a planning process before developing the software .

You may have heard of the quote “Think twice, code once.”

It’s true , we should follow this approach and such an approach can be achieved with the help of SDLC.

We plan each and every step like requirements, coding conventions, design patterns, etc in SDLC . We do so to achieve goals in less time , save money and prevent chaos .

SDLC Phases

Phase 1: Planning
This is the most important or crucial stage of the process . It defines the success or failure of the project . If a project is not thoroughly planned , we are likely to fail to build it.

Here the senior members take input about the project from the customer , then domain experts analyse it and estimate the cost of the project as well as the risk factors .

With the help of experts , marketing team and surveys they are able to minimize the risk factors and the cost to the team .

Phase 2: Defining
After the planning phase is complete , now it’s time to document it . This document is called SRS( Software Requirement Specification ) .It includes all the product requirements needed during the life cycle process . Later on the SRS is sent to the customer or the market analyst for approval .

Phase 3: Designing
After the approval of the SRS document, a DDS( Design Document Specification ) is proposed at this stage. It contains all the architecture (follow & managing of data) and design patterns (paradigms to follow while coding) proposed considering all the requirements and risk factors involved .

Later on, all the stakeholders review the DDS and select a good fit architecture & pattern for the project .

DDS contains the data flow structure from different modules (if any) . The more DDS is detailed about every step, the easier the development phase.

Phase 4:Building
This is the stage where real fun begins - coding. DDS is sent to developers . Developers follow the layed out patterns in the document.

It includes tools a developer needs while developing like compiler , interpreter , debugger , etc . It also includes in which high level languages like C, JavaScript , Python,etc he/she should code .

Phase 5:Testing
We can say it’s a subset of coding . In the real world we follow TDD - Test Driven Development , it means we test every piece of code that we have written . Same process here is also followed.

Here each piece of function is tested rigorously . We perform tests on each and every function and part of the application . This helps us to identify bugs , unexpected errors at an early stage .

If you have testing skills as a developer then you have an edge over other developers so it’s recommended to learn this skill too to get high chances of your resume getting shortlisted.

Phase 6: Deployment & Maintenance
After testing (removing each and every bug), your application is ready to be deployed for the public.

Note: Before deploying there is a staging environment where Testers test applications under heavy load but we are not going into much details right now .

Regular feedback is taken from the public - who are using their application to spot any bug or error that is not spotted in the testing phase . Afterwards the team analyzes the problem and solves the bug and redeploy it .This process of feedback & resolving bugs continues .

Our newly deployed application is also monitored . It helps us to get insight out how much load we are getting on our application and what should be our next task to manage this load much more efficiently .

This whole process of SDLC repeatedly goes-on-and-on - forever till the application gets outdated - adding new features , resolving new bugs , etc.

Here we have only discussed what SDLC is , it’s benefits and phases . But it’s not the end . There are different models/methodologies we follow in SDLC for eg Agile, Iterative, Waterfall Model, etc . Each of these models have their pros and cons. We will discuss this in the next blog.

Thanks for reading,
Written with ❤️ & passion 🔥 by Rishabh Raghwendra

Step By Step Visual Roadmap To Any learn programming Language (Practice Questions included)

Rishabhraghwendra18 — Tue, 08 Jun 2021 14:13:00 +0000

It’s always a good idea to plan rather than directly jumping in, to achieve our goals in a shorter period of time.

To learn a programming language, follow a visual roadmap to understand the basics and succeed in that. Practice questions sheets are provided for some important topics. This roadmap & questions are applicable to any language you are learning because concepts are same in every language , only syntax is different.

Note: Assuming that you have chosen which programming language to learn.

So let’s get started ,yippee..

Learn a new topic and practice that topic on alternate days, as shown below :

Blue bar shows the day to learn a new topic . White bar shows the day to practice questions from below the Practice Questions sheet , topics that we have learnt a day before.
Sunday is our day off!!

Visual roadmap of topics that we should know in any programming language .

Link :- https://cutt.ly/cnEJca4

As promised , here’s the practice questions sheet :

Link :- https://cutt.ly/5nTeQ4G

Questions are not complex, but enough to make your concepts clear. Solutions of these questions can be very easily found on the internet , but try to spend at least 30mins figuring out the solution.

With these estimates you can complete the roadmap in about 3 month! It’s just a rough estimate and can vary from person to person.

Bonus Tip: If you are still searching for best resources to learn C++,JavaScript,Python , here’s the list:
- C++(Paid): https://cutt.ly/HnEJIjF
- JavaScript(Free): https://cutt.ly/JnEJDu8
- Python(Free): https://cutt.ly/LnEJJKd

At last all I would say is, keep on practicing as practice is the only key to success!

Thanks for reading,
Written with ❤️ & passion 🔥 by Rishabh Raghwendra

How to learn Programming in 2021

Rishabhraghwendra18 — Thu, 27 May 2021 14:09:11 +0000

Computer Programming is one of the hot industries in the world. It not only pays good salary but also gives job security during pandemic too .This industry has grown 66% in the US in 10 years and expected to grow 20% annually.

You want to be a part of Programming industry, but don’t know how to program or code?
In this blog, I will share some tips provided by my mentors when I started, this will be useful for the beginners.

Throughout the blog, I will use the programming and coding words interchangeably, for sake of simplicity.

1. Focus on one programming language or technology to start with.

Beginners think that they have to learn every programming language to become a good programmer, but it's not true, follow below steps which will prevent you from burnout.

Even Professionals, don’t learn each and every language/technology.

How to Start Programming

Step 1: Hang out with people with the same interest (learn program/code)

This is the most important step than directly jumping into learning any new programming language.

What’s the benefit of this?

Most of the beginners when they start learning any programming language, initially they are very enthusiastic but as they continue learning they get bored. They don’t have much enthusiasm and as a result, they start procrastinating. That is when your coding buddies will help and support! Learning in a group brings more enthusiasm and motivation. Discussing the programming issues and coming up with a solution together will make you work harder with more energy and motivation. Most important thing is the people you hang out with , more likely you will become like them.

How to find coding buddies 🤔?

You can start following professional programmers on social media like YouTube, Twitter, Instagram, etc. Most of them have discord servers, you can join their servers (for free) and make them your coding buddies. Another way to find coding buddies is to go to programming events or online events and meet people or you can make a WhatsApp group of your college classmates, who are passionate about coding, in there you may find a mentor as well!

Step 2: Decide what you want to learn

There are a lot of technologies in the market for different domains - Web development, Cloud Computing, Blockchain, etc.. and it’s not possible to learn all these technologies at one time, so first decide what you want to become and your end goal.

You can search about different domains of computer science or I will also write a blog on this topic with salary expectations, on your demand.

Below are some ideas -

Want a job within a year?

To get a job within a year or two, the focus should be on one programming language preferably C++ because it’s faster than other languages. Know some basics about the language and then learn Data Structures & Algorithms (DSA).

Most of the companies don’t usually see how many projects you worked on, but they see your problem solving capabilities . DSA is the key point that can prove that you are a problem solver.

Learn DSA through free or paid DSA courses on the internet. Practice DSA skills using sites like LeetCode, InterviewBit, etc. These are interview-based sites which will help with the coding interview round for different product or service-based companies. The more you practice the more confidence you get, in cracking an interview.

Want to develop Apps just for fun?

For a Mobile app or a Web app or Social networking sites like Instagram/Facebook, then learn Python or JavaScript, HTML, CSS also learn SQL or MongoDB databases, these are the common requirements for a Web or an Android app.

Python and JavaScript are used as the backend for any application to run continuously on a server.

HTML, CSS are used to create frontend interface for an application, whereas JavaScript is used to make frontend interactive. We can learn Frontend in a month or so. Later on we can learn Reactjs, Angular.js, Vue.js - these are frontend libraries and frameworks, to enhance our front-end skills.

Want to be a software developer?

To be a software developer first learn a programming language and make a stronghold on it. Learn C++ first as it fastest programming language and as well many other programming languages like Java has evolved from C++. Many other programming language or run-time environment also uses C++ under the hood like CPython, Node.js.

Fun Fact: C++ developer has a higher salary than any other programming language developer!

2.Learn one Language at a time

Don’t try to learn more than one programming language simultaneously, spend time on learning one language, the more time you spend, the more benefit in the long run. Choose a small project to get hands on experience.

Choose a project

This is the most crucial step. If you don’t do this, then no one can believe you that you know to program.

3.Learn technologies as per your project requirements.

It’s impossible to learn every Technology, learn technologies as per project requirements. To learn every technology will take ages and we won’t be able to learn or implement anything.

Start with a simple project

Start with a small project like a Calculator, a Coffee ordering app or a Game..
After making some simple projects, make 2-3 medium-level projects from which you can learn something new while developing it.

4. Practice makes everyone perfect…. Practice, Practice & Practice!
Follow your dreams to become a great Programmer by practicing hard.

I will also post a roadmap for learning your first programming language, so stay in tune 😉

Thanks for reading ,
Written with ❤️ & passion 🔥by Rishabh Raghwendra