DEV Community: ಮಿಥುನ್

git stash usage for beginners

ಮಿಥುನ್ — Sat, 25 Feb 2023 04:31:51 +0000

In the below branch tree, let's say you are working on Feature-branch-helper.

master
- develop
  - Feature-branch
    - Feature-branch-helper

Now you completed working on Feature-branch-helper, before you merge with Feature-branch, you would want to take latest from Feature-branch. Without taking latest from Feature-branch you cannot merge. In this case we can use git stash.

Steps I follow to update current branch. Assuming you are in Feature-branch-helper.

First take backup of your changes

 git stash

Second take latest of Feature-branch

 git pull origin Feature-branch

Resume your changes to your branch ,Feature-branch-helper

 git stash pop

Simple Dictionary Program in GO

ಮಿಥುನ್ — Sun, 20 Mar 2022 07:02:13 +0000

Hello Friends, As a beginner in GO I have written a simple Dictionary program. This program uses Map to store word and meaning. This program also allows user to update, delete, search and list all words. Feel free to comment and let me know how can i improve this program. Thanks.

Please follow this link to see program.

Dictionary Program

using axios in nodejs

ಮಿಥುನ್ — Thu, 23 Sep 2021 15:06:59 +0000

axios is Promise based Http Client for the browser and node.js

install axios into your nodejs project using below command.


    npm install axios

import axios using below statement.


     const axios = require('axios');

Below sample code to shows how to use axios. since axios returns promise object handle success and error data with then() and catch() callback functions.


app.get("/yourapi", function(req, res, next) => {
    axios.get("https://replace/your/url/here")
    .then(function (response) {
        // handle success
        return res.send(response.data);
    })
    .catch(function (error) {
        // handle error
        console.log(error);
        // return res.send(error["message"]); // send response or 
        next(error); // pass error to global error handler
  })
})

global error handler example. make sure you use error handler middleware at the end of entry script file(index/server.js file).


    app.use(function (err, req, res, next) {
      res.status(500).send(err["message");
    })

References

RxJs interval with condition

ಮಿಥುನ್ — Wed, 06 Jan 2021 14:17:24 +0000

We have used setInterval() to run a task multiple times after every specific interval. We need to clear interval after the task is done. Using RxJs interval function we can simulate setInterval function.

import { interval } from "rxjs";

// creating observable
let numbers = interval(1000);

// subscribe function returns reference to observable
let numbesubs = numbers.subscribe(x => {
  console.log("Next: ", x);
  // clearing interval when x reaches 10 value
  if (x == 10) {
    unSubscribingfunction();
  }
});

function unSubscribingfunction() {
    // clearing interval
    numbesubs.unsubscribe();
}

// Logs:
// Next: 0
// Next: 1
// Next: 2
// ..
// Next: 10

why to use sync.WaitGroup in golang?

ಮಿಥುನ್ — Fri, 14 Aug 2020 15:47:14 +0000

WaitGroup instance is available in sync package in golang. WaitGroup is required to force Main GoRoutine to wait all other GoRoutine complete their tasks.

Before we see how to use waitgroup lets discuss about Goroutines first.

what is Goroutine?

Goroutine is separate path of execution if you familiar with Java, it is same as thread.

By default there is will atleast one Goroutine in golang program, which i call as Main Goroutine as i come from java background.

On top of that you can create your own Goroutine which can be called as user defined Goroutines.

How to create Goroutine?

it is simple, just use prefix "go" to your function call.

eg :   go myTask() // creates a Goroutine.

why we need WaitGroup? lets look at this example

package main
import "fmt"
func task(msg string) {
for i := 0 ; i < 10 ; i++ {
    fmt.Println(msg)
}
}

func main() {
    // we are creating two goroutine
    go task("first")
    go task("second")
}

output : program exited

In the above example , we are creating two Goroutine but we are not making Main Goroutine to wait till "first" and "second" Goroutine completes. Now sync.WaitGroup comes into picture.

steps to use sync.WaitGroup

import "sync" package and declare variable sync.WaitGroup
increment counter by using function Add(numberOfGroutineAdding)
use Wait() at the end of program
use Done() when each Goroutine is completed. It decrements counter by 1.

Now working example with sync.WaitGroup

package main

import (
"fmt"
"sync"
)

func task(msg string, wg *sync.WaitGroup) {
for i := 0 ; i < 10 ; i++ {
    fmt.Println(msg)
}
wg.Done() // decrement counter
}

func main() {
    var wg sync.WaitGroup
    wg.Add(1) // incrment counter for "first"
    go task("first", &wg)
    wg.Add(1) // increment counter for "second"
    go task("second", &wg)
    // Main Goroutine will wait till "first" and "second" completes
    wg.Wait() 

}

output: ten times "first" and "second" will be printed.

In the above program , we have added one more parameter sync.WaitGroup to call Done() when each Goroutine is completed.

Typescript Mixin example

ಮಿಥುನ್ — Sun, 05 Jul 2020 20:07:23 +0000

Typescript doesn't allow multiple inheritance through classes, although an interface extends multiple classes but it doesn't inherit methods implementation, it inherits only method declaration.

class One {
    one() {
    }
}

class Two {
    two() {
    }
}

interface Three extends One, Two {
   // inherits One's, Two's method declarations
   one();
   two();
}

There is another way to inherit methods from multiple special class(In typescript mixin used as function) called Mixin. According to Wikipedia, In object-oriented programming languages, a mixin (or mix-in) is a class that contains methods for use by other classes without having to be the parent class of those other classes. How those other classes gain access to the mixin's methods depends on the language.

Mixins are sometimes described as being "included" rather than "inherited". Basically in typescript Mixin is used to create a class. To this newly created class it adds new property and adds property from existing class.

it can be said as

 Base/our class properties -> [ Mixin adds properties] -> NewClass

and then you can add few more properties

NewClass  properties -> [ AnotherMixin adds properties] -> AnotherNewClass

Steps to use Mixin

Create your class with properties, lets say User.
Create constructor function
Create Mixin function which return new class with new properties added by mixin and properties from User class.

Implementation

let's create a User class with property name
```
 class User {
   name: string;
}
```
let's create constructor function, used to create mixin class. refer this link for more details : instantiating generic type
```
 // declaring generic type

 type Constructor<T = {}> = new (...args: any[]) => T;
```

A mixin function that adds new property and returns new class

function Timestamped<TBase extends Constructor>(Base: TBase) {
  // User is considered as Base and Base is extended by new class
  // return a class, combining "name" and "timestamp"  
  return class extends Base {
    timestamp = Date.now(); // goes inside new class constructor 
  };
}

New class is named as TimestampedUser
it consists of new property timestamp and "name" from User

  const TimestampedUser = Timestamped(User);
  const timestampedUserExample = new TimestampedUser();
  timestampedUserExample.name = "vishruth";
  console.log(timestampedUserExample.name); //"vishruth"
  console.log(timestampedUserExample.timestamp);//1593976747100

You can create another Mixin and keep add properties to new class TimestampedNewMixinUser. like

      // define NewMixin function here and call like below    
      const TimestampedNewMixinUser = Timestamped(NewMixin(User));