Forem: Bikash Mishra

Introducing encache: A Powerful Caching Library for Go

Bikash Mishra — Sun, 12 May 2024 03:39:59 +0000

In the world of software development, performance is king. One effective way to boost your application's performance is by caching expensive function calls. This is where the encache package comes into play. encache is a Go library that provides a caching mechanism for function calls, allowing you to cache the results of computationally intensive or I/O-bound operations, and retrieve them from the cache instead of recomputing them.

Features Galore

The encache package is packed with features that make caching a breeze:

Support for in-memory and Redis caching: Choose between caching in memory or using Redis, depending on your project's requirements.
Automatic cache expiration and periodic expiration of stale entries: Never worry about stale data clogging up your cache.
Locking mechanisms for thread-safety: Ensures your cached data remains consistent, even in concurrent scenarios.
Customizable cache key generation: Fine-tune how your cache keys are generated to suit your needs.
Option to cache function results even when errors occur: Errors won't halt the caching process, ensuring you always have data available.

Getting Started

Installing encache is a breeze, thanks to Go's built-in package management system:

go get github.com/forkbikash/encache

Once installed, using encache is incredibly straightforward. Here's a simple example:

package main

import (
    "fmt"
    "time"
    "github.com/forkbikash/encache"
)

func expensiveOperation(a, b int) (int, error) {
    // Simulate an expensive operation
    time.Sleep(2 * time.Second)
    return a + b, nil
}

func main() {
    // Create a new in-memory cache implementation
    mapCache := encache.NewMapCacheImpl()
    cacheKeyImpl := encache.NewDefaultCacheKeyImpl()
    lockImpl := encache.NewMuLockImpl()

    // Create a new encache instance
    encache := encache.NewEncache(lockImpl, mapCache, cacheKeyImpl, false, time.Minute)

    // Wrap the expensive function with caching
    cachedExpensiveOperation := encache.CachedFunc(expensiveOperation, encache, time.Minute)

    // Call the cached function
    result, err := cachedExpensiveOperation(2, 3)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Println("Result:", result)

    // Subsequent calls will retrieve the result from the cache
    result, err = cachedExpensiveOperation(2, 3)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Println("Result (cached):", result)
}

In this example, we create a new encache instance with an in-memory cache implementation (MapCacheImpl), a default cache key implementation (DefaultCacheKeyImpl), and a mutex-based lock implementation (MuLockImpl). We then wrap the expensiveOperation function with the CachedFunc function, which returns a new function that will cache the results of expensiveOperation.

Contributing

Contributions are what keep the open-source community vibrant and growing. If you have any improvements, bug fixes, or new features to propose, please open an issue or submit a pull request. We welcome all contributions!

Future Developments

The encache package is constantly evolving, and we have exciting plans for future developments:

Cache invalidation strategies: Aside from the simple expiration-based cache invalidation, we plan to add support for other strategies like manual invalidation, LRU (Least Recently Used) eviction, or event-based invalidation (e.g., invalidating the cache when the underlying data changes).
Monitoring and metrics: We aim to provide metrics and monitoring capabilities to help users understand the cache's performance, hit/miss rates, and other relevant statistics.
Adaptive caching: Implement an adaptive caching mechanism that can automatically adjust the cache size, eviction policy, or other parameters based on the workload and usage patterns.
Asynchronous cache updates: Provide an asynchronous cache update mechanism to allow for non-blocking cache population and update operations.
Change package structure: Reorganize the package structure to improve maintainability and extensibility.

Stay tuned for more updates and enhancements to the encache package!

I hope this article helps someone out there.

If you liked the post, you can find more by:

Following me on twitter: @forkbikash
Following me on gitHub: @forkbikash
Following me on dev.to: @forkbikash

Tweet this post
Follow me on Twitter @forkbikash

Unleash the Power of Rate-Limiting with Limitless

Bikash Mishra — Sun, 12 May 2024 03:29:17 +0000

In today's fast-paced world of web applications, rate-limiting has become an indispensable tool for maintaining system stability and protecting against abuse or overload. That's where the limitless package for Golang comes into play, offering a powerful and flexible rate-limiting solution that harnesses the power of the token bucket algorithm.

Understanding Rate-Limiting

Before we dive into the limitless package, let's briefly explore what rate-limiting is and why it's so important. Rate-limiting is a technique used to control the rate at which requests or operations are processed by an application. By limiting the number of requests that can be processed within a given time window, you can prevent system overload, protect against denial-of-service (DoS) attacks, and ensure fair usage of shared resources.

Introducing Limitless

The limitless package is a robust and highly configurable rate-limiting solution that provides both in-memory and Redis-based implementations of the token bucket algorithm. With its wide range of features, limitless empowers you to tailor rate-limiting to your application's specific needs.

Features Galore

In-Memory Token Bucket: For applications that don't require distributed rate-limiting, limitless offers an in-memory implementation of the token bucket algorithm.
Redis Token Bucket: If you're dealing with horizontally scaled applications, the Redis-based implementation of the token bucket algorithm provides a distributed rate-limiting solution.
Configurable Rate and Capacity: Customize the rate (requests/operations per second) and capacity (maximum burst size) of the token bucket to suit your application's demands.
Concurrent Access: With proper locking mechanisms, limitless ensures thread-safety and supports concurrent access to the rate limiter.
Extensibility: The package provides a RateLimiter interface, allowing you to implement custom rate-limiting strategies if needed.

Getting Started

Installing the limitless package is a breeze:

go get github.com/forkbikash/limitless

import "github.com/forkbikash/limitless"

// Create a new in-memory token bucket
tb := limitless.NewInMemoryTokenBucket(10, 2) // capacity: 10, rate: 2 requests/second

// Check if a request is allowed
allowed, err := limitless.Allow(tb)
if err != nil {
    // Handle error
}
if *allowed {
    // Process the request
} else {
    // Request is rate-limited
}

Contributing to Limitless

Contributions to the limitless package are always welcome! If you encounter any issues or have suggestions for improvements, feel free to open an issue or submit a pull request on the GitHub repository.

A Glimpse into the Future

The limitless package has an exciting roadmap ahead, with plans for numerous enhancements and new features. Here's a sneak peek at what's in store:

Middleware Integration: Develop a middleware component that can be easily integrated into popular Golang web frameworks (e.g., Gin, Echo, Fiber) to streamline the application of rate limiting functionality.
Metrics and Reporting: Include options to expose metrics related to rate limiting, such as the number of requests processed, rejected requests, and the current rate limiting state.
Burst Capacity: Allow users to configure a burst capacity, enabling a maximum number of requests to be processed immediately, even if it exceeds the rate limit. This can be invaluable for handling sudden traffic spikes.
Adaptive Rate Limiting: Implement an adaptive rate limiting algorithm that can dynamically adjust the rate limit based on factors like current load, resource utilization, or custom metrics.
Multi-Dimensional Rate Limiting: Provide the ability to apply rate limiting based on multiple dimensions, such as client IP, user identity, API endpoint, or a combination thereof, enabling granular control over rate limiting policies.
Contextual Information: Pass contextual information (e.g., request metadata, user identity) through the rate limiting system, empowering users to make informed decisions or apply custom rate limiting rules.
Fallback Behavior: Define fallback behaviors for when the rate limiting storage (e.g., Redis, Memcached) becomes unavailable, such as allowing a default number of requests or completely blocking further requests.
Webhooks and Notifications: Allow users to configure webhooks or other notification mechanisms to be triggered when certain rate limiting thresholds are reached or exceeded, enabling timely action.
Grouping and Inheritance: Implement a mechanism for grouping rate limiting policies and allowing inheritance, making it easier to define common rules and apply them across multiple endpoints or clients.
Logging and Debugging: Provide robust logging and debugging capabilities, including detailed information about rate limiting events, applied limits, and rejection reasons.
HTTP/gRPC Integrations: Offer seamless integration with both HTTP-based and gRPC-based services, enabling rate limiting across your entire application stack.
Observability and Monitoring: Integrate with popular observability and monitoring tools (e.g., Prometheus, Grafana) to provide detailed metrics and dashboards for monitoring the rate limiting system's performance and health.
Backpressure Management: Implement mechanisms to handle backpressure, such as queuing and throttling, ensuring that the rate limiting system can gracefully handle sudden traffic spikes without causing cascading failures.

Stay tuned for more updates and join the limitless community to be part of this exciting journey towards robust and efficient rate-limiting solutions!

I hope this article helps someone out there.

If you liked the post, you can find more by:

Following me on twitter: @forkbikash
Following me on gitHub: @forkbikash
Following me on dev.to: @forkbikash

Tweet this post
Follow me on Twitter @forkbikash

The Actor Model in Go: Simplifying Concurrent Programming

Bikash Mishra — Sun, 12 May 2024 03:14:17 +0000

In the world of modern software development, concurrency is a necessity. With the rise of multi-core processors and distributed systems, applications need to be able to execute multiple tasks simultaneously to take full advantage of available hardware resources and ensure optimal performance.

One elegant solution to tackle concurrency is the Actor Model, a conceptual model for building concurrent and distributed systems. And now, with the power of Go, you can harness the benefits of this model with ease.

What is the Actor Model?

The Actor Model is a mathematical model of concurrent computation that treats actors as the universal primitives of concurrent computation. An actor is a lightweight, independent entity that operates concurrently and communicates with other actors by sending and receiving asynchronous messages.

In this model, each actor has its own mailbox, a queue where incoming messages are stored. The actor processes messages from its mailbox one by one, performing computations and potentially sending messages to other actors in response.

Introducing the Go Actor System

The Go Actor System is an implementation of the Actor Model in the Go programming language. It provides a framework for building concurrent applications using lightweight actors that communicate via message passing.

The Actor System consists of the following components:

Actor System Interface: The entry point for submitting tasks to the Actor System.
Task Queue: A queue that holds the tasks submitted by the Actor System Interface.
Assigner Actor: Responsible for reading tasks from the Task Queue and assigning them to available Actor instances.
Actors: Lightweight entities that execute the assigned tasks concurrently. Each Actor has its own Task Queue.
Auto Scaler: Dynamically increases or decreases the number of Actor instances based on the Task Queue size.

Using the Go Actor System

Using the Go Actor System is straightforward. Here's an example:

package main

import (
    "sync"
    "time"
    "github.com/forkbikash/aktor/actor"
    "github.com/forkbikash/aktor/actor_system"
    "github.com/forkbikash/aktor/entities"
)

type task struct{}

func (t *task) Execute() {}

func taskFunc() entities.Task {
    return &task{}
}

func main() {
    actorSystem := actor_system.CreateActorSystem("actor_system", &actor.Config{
        MinActor: 10,
        MaxActor: 100,
        AutoScale: actor.AutoScale{
            UpscaleQueueSize: 100,
            DownscaleQueueSize: 10,
        },
    })

    for i := 0; i < 1000; i += 1 {
        actorSystem.SubmitTask(taskFunc())
        <-time.After(2 * time.Millisecond)
    }

    systems := []*actor_system.ActorSystem{actorSystem}
    wg := &sync.WaitGroup{}
    wg.Add(len(systems))

    for _, system := range systems {
        go system.Shutdown(wg)
    }

    wg.Wait()
}

In this example, we create an Actor System with a minimum of 10 and a maximum of 100 actors. We then submit 1000 tasks to the system, with a short delay between each submission. Finally, we shut down the system and wait for all tasks to complete.

What's Next?

The Go Actor System is a powerful tool for building concurrent applications, but there's always room for improvement. Some potential future enhancements include:

Assigning task IDs to each task and providing functionality to wait for the completion of a specific task.
Support for distributed environments, allowing actors to communicate across multiple machines.

With the Actor Model and the Go Actor System, concurrent programming becomes more accessible and manageable. Embrace the power of concurrency and take your applications to new heights with this elegant and efficient approach.

I hope this article helps someone out there.

If you liked the post, you can find more by:

Following me on twitter: @forkbikash
Following me on gitHub: @forkbikash
Following me on dev.to: @forkbikash

Tweet this post
Follow me on Twitter @forkbikash

Last minute guide to React.useEffect()

Bikash Mishra — Thu, 02 Sep 2021 06:31:39 +0000

React.useEffect() is one of the React hooks that manages side-effects in functional React components. You can do so much by writing so little with the help of this hook.

useEffect accepts a callback function (also called the 'effect' function), and it runs after every render (by default).

If you want your effects to run less often, you can provide a second argument – an array of values. Think of them as the dependencies for that effect.

So, let us look at some examples in which I'll be showing how you can control the behavior of useEffect.

1. When no dependencies are provided

The callback function provided as the first argument will run after every rendering.

import { useEffect } from 'react';

function MyComponent() {
  useEffect(() => {
    // Runs after EVERY rendering
  });  
}

2. When an empty dependencies array([]) is provided

The callback function provided as the first argument will run only once after the initial rendering.

import { useEffect } from 'react';

function MyComponent() {
  useEffect(() => {
    // Runs ONCE after initial rendering
  }, []);
}

3. When dependencies array provided has props or state values [prop1, prop2, ..., state1, state2]

The callback function provided as the first argument will run only when any dependency value changes.

import { useEffect, useState } from 'react';

function MyComponent({ prop }) {
  const [state, setState] = useState('');
  useEffect(() => {
    // Runs ONCE after initial rendering
    // and after every rendering ONLY IF `prop` or `state` changes
  }, [prop, state]);
}

4. Effect with Cleanup

If the callback of useEffect returns a function, then useEffect() considers this as an effect cleanup.

useEffect(() => {
  // Side-effect...

  return function cleanup() {
    // Side-effect cleanup...
  };
}, dependencies);

It's pretty common to clean up an effect after some time. This is possible by returning a function from within the effect function passed to useEffect. Below's an example with addEventListener.

() => {
  useEffect(() => {
    const clicked = () => console.log('window clicked')
    window.addEventListener('click', clicked)

    // return a clean-up function
    return () => {
      window.removeEventListener('click', clicked)
    }
  }, [])

  return <div>
    When you click the window you'll 
    find a message logged to the console
  </div>
}

5. Multiple Effects

Multiple useEffect calls can happen within a functional component as shown below:

() => {
  // 🍟
  useEffect(() => {
    const clicked = () => console.log('window clicked')
    window.addEventListener('click', clicked)

    return () => {
      window.removeEventListener('click', clicked)
    }
  }, [])

  // 🍟 another useEffect hook 
  useEffect(() => {
    console.log("another useEffect call");
  })

  return <div>
    Check your console logs
  </div>
}

I hope this article helps someone out there.

If you liked this post, you can find more by:

Following me on Twitter: @forkbikash
Following me on GitHub: @forkbikash
Following me on this beautiful platform: @forkbikash

Tweet this post
Follow me on Twitter @forkbikash

My Learnings in LGMSoC’2021

Bikash Mishra — Sat, 21 Aug 2021 05:03:03 +0000

WHAT IS LET'SGROWMORE?

LetsGrowMore is a community of the students, for the students and by the students.

WHAT IS LGM-SOC?

LGM – SOC is an online program designed to encourage student participation in open source software development under the guidance of mentors from the open source community. As it’s the present demand and students need, so we come with LGM – SOC.

HOW DOES IT WORK?

Open source projects apply to be mentor organizations.
LGM chooses the organization interesting in participating.
Students submit project proposals to mentor organization.
Mentor organizations choose the students they’d like to accept.
Students are paired with a mentor for required guidance.
Now coding begins! Students work under their mentors over 10 weeks.

ELIGIBILITY

All you need to be is a student ready to grab learning opportunity.
Accepted into or enrolled in a graduate program by the students acceptance date.
Eligible to work in the country you reside.

MY LEARNINGS

I contributed to one of the open source repositories namely awesome-portfolio-websites. The project is aiming to provide a full-fledged template that anyone can use to build and put out their website within an hour.
I am one of the top contributors of the project. Written modularized code to add some features to the website, fixed bugs and raised some critical issues throughout the journey. Our mentors @smaranjitghose and @anushbhatia helped me a lot in improving the style of coding. I would like to thank them for their contributions in my journey.

I am glad to be a part of LGMSOC community. Looking forward to more events and learning opportunities like this.

If you want to know more about the program, head over to their website(letsgrowmore.in).

I hope this helps someone out there.

If you liked this post, you can find more by:

Following me on Twitter: @forkbikash
Following me on GitHub: @forkbikash
Following me on this beautiful platform: @forkbikash

Tweet this post
Follow me on Twitter @forkbikash

Closure in JavaScript

Bikash Mishra — Thu, 19 Aug 2021 19:58:46 +0000

Coding in JavaScript without an understanding of closures is like trying to speak English without an understanding of grammar rules — you might be able to get your ideas across, but probably a bit awkwardly.

Closure is one of important concepts in JavaScript. It is widely discussed and still confused concept. Let's understand what the closure is.

What are Closures?

As stated in MDN Web Docs, a closure is the combination of a function bundled together (enclosed) with references to its surrounding state (the lexical environment). In other words, a closure gives you access to an outer function’s scope from an inner function. In JavaScript, closures are created every time a function is created, at function creation time.

What is Lexical Scope?

Lexical scope is the ability for a function scope to access variables from the parent scope. We call the child function to be lexically bound by that of the parent function.

A Simple closure

Let’s look at a simple closure example in JavaScript:

function OuterFunction() {

    var outerVariable = 1;

    function InnerFunction() {
        alert(outerVariable);
    }

    InnerFunction();
}

In the above example, InnerFunction() can access outerVariable.

Now, InnerFunction() can access outerVariable even if it will be executed separately. Consider the following example.

function OuterFunction() {

    var outerVariable = 100;

    function InnerFunction() {
        alert(outerVariable);
    }

    return InnerFunction;
}
var innerFunc = OuterFunction();

innerFunc(); // 100

In the above example, return InnerFunction; returns InnerFunction from OuterFunction when you call OuterFunction(). A variable innerFunc reference the InnerFunction() only, not the OuterFunction(). So now, when you call innerFunc(), it can still access outerVariable which is declared in OuterFunction(). This is called Closure.

Above example also shows that the local variables are not copied in the closure: the closure maintains a reference to the original variables themselves. It is as though the stack-frame stays alive in memory even after the outer function exits.

Closure Scope Chain

Every closure has three scopes:

Local Scope (Own scope)
Outer Functions Scope
Global Scope

When to use Closure?

Closures are useful whenever you need a private state associated with a function. This is a very common scenario - and remember: JavaScript did not have a class syntax until 2015, and it still does not have a private field syntax. Closures meet this need.

Performance considerations

It is unwise to unnecessarily create functions within other functions if closures are not needed for a particular task, as it will negatively affect script performance both in terms of processing speed and memory consumption.

Final points:

Whenever a function is declared in JavaScript closure is created.
Returning a function from inside another function is the classic example of closure, because the state inside the outer function is implicitly available to the returned inner function, even after the outer function has completed execution.
A closure in JavaScript is like keeping a reference (NOT a copy) to the scope at the point of function declaration, which in turn keeps a reference to its outer scope, and so on, all the way to the global object at the top of the scope chain.
A new set of local variables is created every time a function is called.

I hope this helps someone out there.

If you liked this post, you can find more by:

Following me on Twitter: @forkbikash
Following me on GitHub: @forkbikash
Following me on this beautiful platform: @forkbikash

Tweet this post
Follow me on Twitter @forkbikash

9 Best Free Resources for learning HTML and CSS

Bikash Mishra — Sat, 03 Jul 2021 07:29:45 +0000

Looking for the best free resources to get you going in your journey towards learning HTML and CSS?
Looking to quickly brush up on your concepts of HTML and CSS?
Want some cheat sheets of HTML and CSS?

If any of the above questions' answer is yes for you, you are in the right place.

Check out the list of resources given below:

01. HTML Cheat Sheet

This HTML cheat sheet has a full list of all HTML elements, including descriptions, code examples, and live previews.

02. CSS Cheat Sheet

This cheat sheet will be ready and waiting for you in your bookmarks for those times when you need a reminder.

03. CSS-Tricks

For daily articles about CSS, HTML, JavaScript, and all things related to web design and development.

04. CSS Wizardry

If you want to write scalable and maintainable CSS, like the BEM methodology and refactoring, you should check out this site.

05. CodePen's Yearly Top Pens

If you want to have a look at some of the best live demos of things build using HTML and CSS, then this site is for you.
CodePen is also one of the best places to build, test, and discover front-end code.

06. Jen Simmons Lab

In this Experimental Layout Lab of Jen Simmons, he uses CSS to implement practical scenarios.

07. Kevin Powell

Kevin Powell is a great YouTuber who loves to simplify CSS.

08. MDN Web Docs

I personally like MDN for its up-to-date, clear and briefly defined content for each technology, which is required for starting your career as a web developer.

09. freeCodeCamp

freeCodeCamp has a step-by-step process to it where you don’t just watch, there are tasks for you to complete.

I hope this helps someone out there.

Don't forget to mention what resources you use in the comments below!

If you liked this post, you can find more by:

Following me on Twitter: @forkbikash
Following me on GitHub: @forkbikash
Following me on this amazing platform: @forkbikash

Tweet this post
Follow me on Twitter @forkbikash

Best Browser(chrome or firefox) extensions for students and professionals

Bikash Mishra — Tue, 29 Jun 2021 10:18:53 +0000

The browser(chrome or firefox) extensions listed below are the ones that I use for my productivity and convenience. And I am sure that some of you are already using these extensions or will start using them immediately after reading this post.

Some of these extensions are for developers only and the rest are for everyone including developers.

So, here is the list of browser extensions that I use daily:

AdBlocker Ultimate

AdBlocker Ultimate is a free extension that blocks ads and malicious domains known to spread malware. It also disables sneaky tracking.

Check out the extension:
For chrome
For firefox

I don't care about cookies

Remove cookie warnings from almost all websites!

The EU regulations require that any website using tracking cookies must get user's permission before installing them. Imagine how irritating that becomes when you surf anonymously or if you delete cookies automatically every time you close the browser.

Check out the extension:
For chrome
For firefox

Hide YouTube Fullscreen Controls

Hide the YouTube fullscreen controls when you move the cursor to the display border.

Check out the extension:
For chrome
For firefox

Video Speed Controller

Speed up, slow down, advance and rewind HTML5 audio/video with shortcuts.

Check out the extension:
For chrome
For firefox

Octotree - GitHub code tree (for developers only)

Browser extension that enhances GitHub code review and exploration.

Features:

Fast IDE-like code tree
Quick file search
Support GitHub themes
Support private repositories
Omni bookmarking
High performance, working with repositories of any size

The extension is free but you can also opt for pro.

Check out the extension:
For chrome
For firefox

If you use browser other than chrome or firefox, search for these types of extensions on the internet.

I hope this helps someone out there.

Don't forget to mention what extensions you use in the comments below!

If you liked this post, you can find more by:

Following me on Twitter: @forkbikash
Following me on GitHub: @forkbikash
Following me on this beautiful platform: @forkbikash

Tweet this post
Follow me on Twitter @forkbikash

Run Scripts on websites using this simple technique

Bikash Mishra — Thu, 24 Jun 2021 18:12:58 +0000

What are bookmarklets?

A bookmarklet is a bookmark stored in a web browser that contains JavaScript commands that add new features to the browser.

Developing a bookmarklet is simple and easy to use.

They can even make a post request with the fetch API.

How to develop one

Use javascript in href attribute of <a> tags in HTML.
An example would be

<a href="javascript: alert('hello world');">click me</a>

Make that in HTML and drag it into your bookmarks bar, you have just added a bookmarklet to your browser. Isn't it simple?

All the javascript in your bookmarklet has to be minified.

<a href="javascript: fetch('https://api.website.com/endpoint').then((data) => { alert('data'); })"></a>

Bookmarklet can be used to modify(or filter) the content of a website.
Below is an example:

<a href="javascript: document.body.innerHTML = '<h1>yeah!</h1>' })"></a>

The main reason you should consider developing or using a bookmarklet is for productivity.

How to install a bookmarklet?

There are many ways to install a bookmarklet. I will show one of them which is probably the simplest one.

Search for bookmarklets you want to install on the internet.
Drag the bookmarklet from the page to your Bookmarks Toolbar. It should show on the toolbar now.
If the Bookmarks Toolbar is not visible then you first have to show the Bookmarks Toolbar by right-clicking on an empty section of the Tab Strip and checking the Bookmarks Toolbar in the pop-up menu. Now repeat the above step.

How to use the installed bookmarklet?

Go on a website where you want to use your bookmarklet.
Click the bookmarklet on your Bookmarks Toolbar. You will see the magic happening.

You can find many more pre-built bookmarklets on the internet.

I hope this helps someone out there.

Don't forget to mention what you've made in the comments below!

If you liked this post, you can find more by:

Following me on Twitter: @forkbikash
Following me on GitHub: @forkbikash
Following me on this beautiful platform: @forkbikash

Tweet this post
Follow me on Twitter @forkbikash