Whisker boxplot serves some sort of the same purpose as the standard deviation, but more visually. It lets us know the overall behavior or dispersion of the data without having to look into the dataset closely.

For understanding whisker boxplot, we need to be familiar with an important term widely used in statistics, that is 5-number-summary of a dataset. The 5 numbers include the minimum value, Quartiles (all 3 of them) and the Maximum value. I will explain all of them in the easiest way possible and lead you comfortably to our today’s agenda- Whisker boxplot.

Maximum and Minimum value: Just the largest and the smallest value/data within a dataset.

Quartiles: Quartiles have only three parts- Q1, Q2, Q3. Please note that Quarters and Quartiles are different things. Unlike Quarters, Quartiles have no Q4. However, Quartiles divide the data into four regions.

To plot a Whisker boxplot manually, finding all the quartiles is a must. Finding the quartiles are very easy. Q2 is simply the median value of a dataset. I will demonstrate the whole process.

Finding quartiles for an ODD number of data within a dataset:

Data: 8,9,2,10,3,5,7,12,15
Order: 2,3,5,7,8,9,10,12,15
So, Median 8 (Middle one). This is Q2. 

Q1 is the median that comes from the lower half of the data.
Now the lower half: 2,3,5,7,8
So, Q1 is 5.

Q3 is the median that comes from the upper half of the data.
Now, the upper half: 8,9,10,12,15
So, Q3 is 10.

Finding quartiles for an EVEN number of data within a dataset:

Data: 10,12,14,15,14,16,17,18,10,19,17,17
Order: 10,10,12,14,14,15,16,17,17,17,18,19

As the number of data is Even, so to find the median, we have to find the average of the middle two data.
Average of 15 and 16 is 15.5. 
So, Median is 15.5. This is Q2. 

Q1 is the median that comes from the lower half of the data.
Now the lower half: 10,10,12,14,14,15
Average of 12 and 14 is 13. 
So, Q1 is 13.

Q3 is the median that comes from the upper half of the data.
Now, the upper half: 16,17,17,17,18,1
Average of 17 and 17 is 17.
So, Q3 is 17.

Now that we all understand 5-number-summary of data, let's go with a real-world challenge that can be easily solved and visualized with whisker boxplot using our 5-number-summary theory.

Example scenario:

Professor Jarvis took an exam on two sections (let us name them Section A and Section B) under his department with the exact same question paper. He wanted to determine which section does better in the exam than the other one. He is pretty wise, like us, wanted to visualize the performance through a whisker boxplot. Therefore, he has collected the 5-number-summary of both classes for that exam; the maximum, the quartiles and the minimum score in each class.

We need to find out which class has done better than the other, which is a very common sort of comparison we have to conduct in our daily life. We may not have to deal with the same example, but we do something very similar to this, I reckon it strongly.

However, to compare the overall performance of the two sections visually, we need to draw a whisker boxplot. Just plot the 5-number-summary of both classes A and B irrespective of any axes (I have chosen Y-axis here), just like the below one. Make a rectangle (or the BOX) with the quartiles, keeping the maximum and the minimum values outside of the box and join them with a straight line to Q3 and Q1 respectively.

(I didn’t have any arrangements while writing this story. So, tried in the simplest way possible, merely on a piece of white paper, Excuse me for that. Thanks to my beloved colleagues for managing at least a scale for me!)

From the chart above, it is pretty clear that section B has done better, as the cluster is more congested and the majority of the marks (inside of the box) remains higher/at the upper side compared to section A, regardless of having the same maximum value. On the contrary, section A’s boxplot is more dispersed, which means some of the students have cut a poor figure in the exam (statistically, 25% of the students from section B scored below 24, whereas, 50% of the students in section A scored below 22).

For the demonstration purpose, I have tried to draw it manually. However, this is a popular chart and almost all the BI tools (including Microsoft Excel) have built-in integration for whisker boxplot chart, which, to be honest, takes a few clicks to build the same chart digitally.

I hope all the words I have said above make sense and will help you understanding as well as utilizing the acquired knowledge for any purposes you might come across.

If you’ve liked it, please hit clap and follow me for further reads on statistics and Business Intelligence. I promise to produce better reads ahead. ❤

Preface

JSON is a lightweight data-interchange format between clients, servers, and within programming languages. It is a subset of the JavaScript object and independent of any programming languages.

I have seen people having troubles while parsing or working with JSON data. Often they find it difficult to distinguish JavaScript Object and JSON data. In this story, I really want to vanish all your confusions regarding these two. The literal difference is very less between this two, but it can cost you a lot if you cannot differentiate it whenever needed. I will describe step by step and precisely with proper examples.

First of all, there’s nothing called JSON object, its either JSON string/text or JSON data. And yes, JavaScript Objects do exist.

All About JavaScript Objects:

Please give me some moments to talk about JavaScript Objects. It’s just a simple key-value pair. An example of an ideal JavaScript object is shown as follows:

var person = {name: “Depp”, address: “earth”};

//Note that some key-value pairs are enclosed with curly braces. //Keys are not enclosed with quotation sign.

→ JavaScript objects do not contain single or double quote marks around the keys when no spacing is used in the key name. So, if there’s spacing in the key name, quotes are used. An Example is given below:

var person= {first name: “Depp”, address: “earth”}; //invalid

// To prevent this error:
var person= {“first name”: “Depp”, "address": “earth”};

However, you cannot invoke any object’s values in a regular way if you have more than one word for the Key name. For example,

person.first name; //This will give an error.

To get rid of it,
person["first name"]; //This works fine.

→ Added that, any language keywords, i.e. if, else, for cannot be used as JavaScript object Keys without single/double quotes too! Look below:

var keywords= {if: “something”, for: “something1”}; //invalid     var keywords= {"if": “something”, "for": “something1”}; //good to go

→ Functions can be used inside JavaScript objects usually as values. It makes JS objects even more powerful.

var person= {firstname: “Johnny”, lastname: "Depp”, fullname : function(){
return (this.firstname+ ‘ ‘ + this.lastname);
}
};

document.write (person.fullname()); //this is gonna work perfect.

All About JSON

This is the era of object-oriented programming. Objects are made with attributes. When we want to exchange the value of attributes between client-server or within languages, we must use any proper format to do so. XML has served this service for quite a long time but it had some drawbacks, i.e. overhead issues. An XML file, carrying the same amount of payload as JSON is comparatively heavier than JSON data. So, JSON is sort of preferred and widely used these days.

→ JSON is basically the “String” version of JavaScript Object. Its simply a text-based data format and single quote is not allowed for JSON.

→ 6 types of data types are allowed to contain in a JSON data/string/text.

• Number
• String
• Array
• Boolean
• Null
• Object

However, Functions cannot be included in JSON data, unlike JavaScript Objects.

→ If you just go through the following statement, you’ll get the visible differences between JSON and JavaScript Object.

var person = {
"name": “Depp”, 
"address": “earth”
};
//A simple JSON data where the keys are enclosed with double quotes

→ This is so far the visible literal differences. Now I will introduce you to two methods which convert JavaScript objects into JSON string and vice versa.

• JSON.parse(); //Turns a JSON string into an JavaScript object.
• JSON.stringify(); //Turns a JavaScript Object into JSON string/data

→Please carefully follow the following statements. That’ll be all for today I believe.

var log = { page: "www.xyz.com", 
        item: "item1", 
        action: "action1" };

log1 = JSON.stringify(log);
console.log(log1);

//Now we know, as per the JSON.stringify() function definition, it will simply turn the object log into a JSON string.

//OUTPUT 
'{ "page": "www.xyz.com" ,"item": "item1","action": "action1" }'

//Again,
console.log(JSON.parse(log1));

//This function will again turn the log1 string into a valid JavaScript object

//OUTPUT
Object {
page   : www.xyz.com,  
item   : "item1",
action : "action1" }

So far I have shown whatever may arise as a confusion or error while working with JSON data and JavaScript. I have illustrated with examples so that no one who is reading this, gets any trouble understanding it.

If you have liked my story, please clap it and follow me to get advanced topics!

Have a good day :)

This is perhaps the most asked question in any interviews related to Software development or software quality assurance. I have seen from my experience that often many of us get confused or forget the definition and usage of abstract classes and interfaces. So, I want to make it the easiest so that no one’s having any troubles with it ever again.

Abstract class and interfaces are two very vital pivots in the Object Oriented Programming concept.

At first, I will explain Abstract class and it’s usage, and later on we will move into Interfaces.

Abstract Class:

Abstract class is nothing special to look at when you want to differentiate with a regular class. But it has got some methods which are unimplemented, or only declared, not defined. In that case, all those methods and the class itself are renamed with the “abstract” keyword.

An abstract class can have one or multiple number of unimplemented methods.

As an abstract class is not proper, or does not have ideally defined methods compared to a regular class, so abstract classes cannot be instantiated, that means we cannot create any direct objects of abstract classes.

The classes which Inherit/Extend this abstract class, have to implement/define all the abstract methods of the parent abstract class.

If any class fails to define any of the abstract methods, that class also becomes an abstract class.

Usage (An imaginary case study):

Let us suppose, in 1995, you have designed a car class which had an additional feature-it could fly. You designed the car class very nicely, all your methods were very standard and efficient, but back then, you knew it was quite impossible to implement the carFlying() method. So, you just kept the carFlying() method blank, or unimplemented (Now you know that is an abstract method as well as class!).

Today, I want to implement that flying car that you have already designed and the technology is no longer impossible. The car I am gonna build has all the features similar to your car, and additionally it can fly. So, what can I do is I can just inherit (“extends”-for Java) your abstract class and must define/implement that carFlying() abstract method. here you go! our flying car is ready to roll.

So, whenever we have some common features or behavior among various objects, we can make a general abstract class with that feature as a method implemented. But those object might have distinct behaviors, in that case, we will declare an abstract method and will implement those abstract methods differently according to the object’s need.

Example of Abstract Class:

public abstract class Wrestler {

    public void paymentForWork (int hours) {
       System.out.println("The wrestler will make $"+hours*250.00+);
    }
    public abstract void themeMusic();
    public abstract void finisher();
}

Once again, let us consider an example, a bunch of wrestlers get the same amount of money per hour for playing. but they have different theme music and finishing fight strategy. So, we can keep the payment method same for all and have it implemented in a class named Wrestler. lets declare the themeMusic() and finisher() methods as abstract because these two have to be implemented differently for different objects in some other classes which inherits our Wrestler Abstract class.

public class Kane extends Wrestler{

    @Override
    public void themeMusic() {
        System.out.println("Kane's Intro music...");
    }
    @Override
    public void finisher() {
        System.out.println("Kane's finishing TombStone...");
    }
}

and the main.java:

public class Main {
    public static void main (String [] args) {
        Wrestler wrestler1= new Kane();

        wrestler1.themeMusic();
        wrestler1.paymentForWork(5);
        wrestler1.finisher();
    }
}

Interface:

If you have gone through the upper part of this tutorial properly, understanding interface is going to be very easier for you.

Interface is not a class, its just interface. It has got some methods with no body inside it, just the method signature (they are basically abstract methods!), and may have some final and static variables. And, a typical class “implements” interfaces, not “extends”.

Multiple interfaces can be implemented (generally, inherited) at a time.

The classes which Inherit/implement the interfaces, must define all the abstract methods of the interface.

Methods inside interfaces are by default public, void and abstract.

interface is kind of multiple inheritance in Java programming language.

We cannot instantiate interfaces too just like abstract classes. Because they are incomplete entity, and should not be permitted to be realized. But sometimes an activity like instantiating can be applicable for it with the help of the anonymous inner class. That’s not our agenda here today.

Usage of Interface:

Interfaces save coding time. It can contain some static and final variables which can be accessed globally. and some methods which are abstract and readily available for further use anytime to whoever implements the interface.

Example of Interface:

In the above example of Abstract class, we saw that one method was same for all which had a body inside the Abstract class and other methods were abstract. but for Interfaces, all the methods are now just signature. The class StoneCold implements Wrestler interface and define all three abstract methods of it according to its need.

This time, different wrestlers get different amount of money per hour. So, its the most convenient to put the same method as abstract and define it elsewhere according to object’s need.

public interface Wrestler {

    public  abstract void paymentForWork (int hours);
    public abstract void themeMusic();
    public abstract void finisher();
}

and the following class implements the Wrestler interface.

public class StoneCold implements Wrestler {
    @Override
    public void paymentForWork(int hours) {
        System.out.println("Stone cold will make $" + hours*300.00);
    }
    @Override
    public void themeMusic() {       
        System.out.println("Stone cold's music playing...");
    }

    @Override
    public void finisher() {        
        System.out.println("Stone cold's finishing stunner...");
    }
}

For the main.java:

public class Main {
    public static void main (String [] args) {
        Wrestler wrestler2= new StoneCold();

        wrestler2.themeMusic();
        wrestler2.paymentForWork(5);
        wrestler2.finisher();
    }
}

For object initiating in case of Abstract class or interface, you can keep the following in mind,

A obj= new B();
//where A is an interface/abstract class. B is the concrete(implements/extends “A”)class which gives it’s memory to A’s obj to have access into B class and utilize its defined methods.

That was a lot of talk. I could not make it any shorter with proper explanation and examples. But I hope you have understood all of it and aren’t gonna forget at least in recent times! I do have all the references of information used here, knock me to get it.

If you have liked it, Please clap it and follow me. I must come back with some more tutorials soon. Have a good day :)

When I started using medium for the first time, I was having the same problem that you’re going through now and reading this story.

Let us solve it together. :)

If you’re on a windows pc, just hit:

ctrl+alt+6

For Mac users:

cmd+6

If you’re on a new line and press those keys, you’ll be headed to a blank code block to write codes inside of it.

If your cursor is at the end of the line, the whole passage/line will be moved to a single code block.

However, Medium has got you some other useful keyboard shortcuts too. To see all the shortcuts in windows, press:

ctrl+alt+?

Again, for Mac users:

cmd+?

Thank you for staying with me till the end. Clap, Follow, Share, and Suggest me if you have any information to make it better. Have a good day. :)

Preface

Hey everyone, I welcome you all to my new tutorial on how you can set up a very basic private MQTT broker in windows PC using Node.js. The prerequisite for this lesson is you should at least be familiar with MQTT basics and Node.js. Node must be installed on your computer.

While a public broker can be vulnerable to your important data or is often loaded with massive internet traffic, you can easily create your own MQTT broker in your PC. Currently, I am using Windows 10 and I am going to demonstrate how you can create a basic private MQTT broker using Node.js and npm’s Mosca API inside of your computer.

Kernel

You must have node modules installed in your project directory. You also have to require mosca and mqtt packages globally or inside of your project folder.

#cmd inside project directory
npm init
npm install mosca --save

which will results in creating node modules folder and package.json file inside the project directory.

Just to get a glimpse of MQTT basics, a MQTT system is made of with a broker, subscribers, and publishers. So, we got to build a broker first which will relay the messages between the publishers and subscribers.

#broker.js

var mosca = require('mosca');
var settings = {
		port:1883
		}

var server = new mosca.Server(settings);

server.on('ready', function(){
console.log("ready");
});

You have to tell Mosca which port it’s going to occupy i.e. the default port 1883 is given here as a JavaScript object named settings, and then pass this object inside the Server function to get it ready to work. Finally, the mosca server, aka, the broker is turned on with an event “ready”, followed by an anonymous callback function.

A broker is useless unless it’s listening to some publishers and rendering the messages to the subscribers. So, let’s create our publisher.js file.

#publisher.js

var mqtt = require('mqtt');
var client  = mqtt.connect('mqtt://your_ip_address_of_pc');

client.on('connect', function () {

setInterval(function() {
client.publish('myTopic', 'Hello mqtt');
console.log('Message Sent');
}, 5000);

});

Both the publisher and subscriber have to require mqtt package in order to avail all the functions to get working with it. Connecting the broker needs a domain name or corresponding IP address (i.e. iot.eclipse.org- which is a free broker). In this case, we are using our pc as broker, so we have to put the IP address of our pc. To know your ip address, type as follows in cmd (windows), get it and put it right where ”your ip_address_of_pc” is written above:

ipconfig

I suppose you already understand the latter part which demonstrates to publish a message on a particular topic. If you don’t, you can follow this link where I have explained the entire process in the most convenient way.

Here we go with our subscriber.js file.

#subscriber.js

var mqtt = require('mqtt')
var client  = mqtt.connect('mqtt://your_ip_address_of_pc')

client.on('connect', function () {
    client.subscribe('myTopic')

})

client.on('message', function (topic, message) {

context = message.toString();
console.log(context)
})

There should be no ambiguity or confusion in the above code snippet. However, just because the data comes in the form of a buffer, to print it in the console as raw string, I used the toString() function.

You can obviously put all three code snippets together in a single file, but there’s something called clean code you know! So, I ran the project in three separate files, and got a chanting output like this:

Well, if you wish, you can now test your mqtt connection through other mqtt clients like android’s mqtt dashboard, chrome’s mqtt lens extension and so forth using your pc’s ip address as broker ip.

I am ending it here. Feel free to ask me any queries regarding this project. If there’s any mistakes or suggestions, please let me know.

Have fun with your self-made private broker! :)

Message Queue Telemetry Transport, aka, MQTT is one of the most widely used lightweight protocol to carry minimal data overhead. It’s a hot cake for the developers who are specially working with Internet of Things (IoT).

As an IoT developer, I came across different projects or applications that need to send smaller chunks of data in a very fraction of time. This article is intended for the developers or users who have at least a minimum familiarity with MQTT (I wish to compose another story on the basics and evolution of MQTT!).

Using MQTT protocol in Node.js has been easier than ever due to the MQTT API provided by npm. Now we can easily implement MQTT protocol in our Node.js project. I am going to demonstrate a basic MQTT establishment in the following code with proper comments.

const mqtt = require ('mqtt');
var client  = mqtt.connect('mqtt://iot.eclipse.org');

In the code above, I have required the MQTT API in an object called mqtt. Using the mqtt object, I have called the connect function and passed the brokers’s URL as argument.

It’s a good practice to use subscribe and publish functions separately.

client.on('connect', function () {
  client.subscribe('Topic07');

  console.log('client has subscribed successfully');
});

We created a client object which invokes the on() method. The on method took two parameters, one is the connect event and another is a callback function to subscribe to a Topic. For our better understanding, I have asked for a console view on success.

client.on('connect', function(){
  setInterval(function(){client.publish('Topic07','cricket');},3000); 
});

This is pretty much similar to the (could be even same except the keyword “publish” only!) previous chuck of code, but you are clever enough now to understand that this is for the publishing purpose now. Yet, I am here to clarify! Please have a look to the below paragraph.

The code above publishes a message, i.e. “cricket” to the topic “Topic07” at a 3 seconds time interval. I could use it without the setInterval method, but that would have stopped just after sending a single message for once.

client.on('message', function (topic, message){
  console.log(message.toString()); //if toString is not given, the message comes as buffer
});

You are supposed to receive some messages published to the topics that you have subscribed to.

The message usually arrives as buffer, so I had to convert it to string data type.

Well, this part is one of the most used parts in MQTT protocol. Basically, one has to spend most of the time in this part while working with MQTT.

Wherever the device might be subscribed to, all the received messages hit right in this section of program. You are the creator and you decide what you’re gonna do with the received messages, you may even start your car with a message, the same you can start your toaster to have your meal.

You can very easily test and play with MQTT data transmission with Free mobile MQTT client or Google Chrome’s MQTT Lens client. That would be fun for newbies!

Hereby, I finish this small and simplest section of basic MQTT connection in Node.js program. I hope this might be helpful for the beginners. Feel free to suggest any improvements. Have a good day :)