History of classes in JS

Pavan Kumar — Sun, 24 May 2020 13:48:47 +0000

What is a class in the programming language world?

Class gives a blueprint for creating objects, providing initial values for state (member variables) and implementations of behavior (member functions or methods)

By default almost all object-oriented languages(Python, Java, C++..) support classes. They provide a way to create objects with some state and behavior.

Example in Python:

# Class declaration
class Train:
    def __init__(self):
        self._source = ""
        self._destination = ""

    def set_source(self, source):
        self._source = source

    def set_destination(self, destination):
        self._destination = destination

    def go(self):
        print("Going from %s to %s"%(self._source, self._destination))

# Instantiation
train = Train()
train.set_source("Kadapa")
train.set_destination("Chennai")
train.go()

But Javascript doesn't have such feature in olden days before ES6. So developers came up with a pattern like below using the power of closures in the JS.

Example in Javascript - implementation 1:

// class-ish declaration
function Train() {
  var _source = ""
  var _desination = ""

  function set_source(source) {
    _source = source
  }

  function set_destination(destination) {
    _desination = destination
  }

  function go() {
    console.log(`Going from ${this._source} to ${this._desination}`)
  }

  return {
      set_source: set_source,
      set_destination: set_destination,
      go: go
    }
}

// Instantiation
train = Train()
train.set_source("Kadapa")
train.set_destination("Chennai")
train.go()

This gives same feel like other programing languages. But it is not so efficent because every intance of Train will hold entire copy of all functions and variables.

So below code is the ideal implementation developers follow in JS using the power of prototypes.

Example in Javascript - implementation 2:

// class-ish declaration
function Train() {
  this._source = ""
  this._desination = ""
}

Train.prototype.set_source = function(source) {
  this._source = source
}

Train.prototype.set_destination =  function(destination) {
  this._desination = destination
}

Train.prototype.go =  function() {
  console.log(`Going from ${this._source} to ${this._desination}`)
}

// Instantiation
train = new Train()
train.set_source("Kadapa")
train.set_destination("Chennai")
train.go()

Above code will use benifits we are getting from prototypes and function constructors in JS. So, all Train instances will have a different copy of members(source, destination) but single copy of methods for all instances.

Since we need to do this technique a lot to create a class like objects. JS core team added a class reserved keyword to the JS to make our life easier.
Under the hood it does the same thing as our prototype code. It is just syntactic sugar in javascript.

My beloved class implementation

// class declaration
class Train {
  constructor(){
    this._source = ""
    this._desination = ""
  }

  set_source(source) {
    this._source = source
  }

  set_destination(destination) {
    this._desination = destination
  }

  go() {
    console.log(`Going from ${this._source} to ${this._desination}`)
  }
}

// Instantiation
train = new Train()
train.set_source("Kadapa")
train.set_destination("Chennai")
train.go()

Brief intro on Celery

Pavan Kumar — Sun, 17 May 2020 11:43:41 +0000

What is celery?

Celery is an asynchronous task queue/job queue based on distributed message passing. It is focused on real-time operation but supports scheduling as well.

If we want to execute some piece of code in python asynchronously or If we want to schedule code to execute in the future. We can use celery.

Consider below scenario:
Suppose, User uploads an excel of 1000 rows to create a database record for each row. It is a time-consuming task. The user needs to wait until the task gets completed. It is not ideal to make the user wait and the browser will send timeout error if the response is taking too long. In this case, we should execute the time-consuming task asynchronously.

How it works?

In this post, I am focusing on the internal structure of celery. Refer to tutorial on how to implement the celery task.

Celery client - Publisher

When we execute the Task.apply_async()/task.delay() celery internally uses kombu which will serialize the task to JSON like message and send it to the Broker.

{
    "task": "myapp.tasks.Task",
    "id": "54086c5e-6193-4575-8308-dbab76798756",
    "args": [4, 4],
    "kwargs": {}
}

RabbitMQ - Broker

Celery needs the broker which follows the AMQP(Advanced Message Queuing Protocol) like RabbitMQ, Redis, etc.,
This broker will take the message and place it in the Queue. Whenever a worker is free (consumer) it gives the task to it.

Celery worker - Consumer

Celery worker takes the message and extracts the required information like task name, args, kwargs, etc., and executes it.
If the result backend is present then the task result will store in it.

DEV Community: Pavan Kumar