DEV Community: param-19

Coop : An App for Students

param-19 — Thu, 02 Dec 2021 16:39:44 +0000

COOPS: Driving Information Distribution

The 21st century has been all about digitisation, information accessibility and rapid growth. As the internet gradually becomes more accessible, the users have started seeking information online. One of those important channels has been the online forums/communities, be it reddit or Facebook. Issue with these communities has been:

Overwhelming amount of information present
Verifying the authenticity of the information
Redundancy and the credibility of information

Solving the problem

COOPS solves this problems by introducing closed community exclusive forums. For instance, information shared by a trusted closed community, say, BITSians would be easier to trust, verify, and discuss since they are part of the institute culture.

The application is designed to have dedicated categories for necessary threads. Since there is no central authority, the information exchanged is moderated with user upvotes and down-votes and the whole system works on the community feedback.

Inside the COOPS

Application Features

Sign-in
Automatic user profile generation
Posts
- Read
- Comment
- Search
- Upvote/Downvote
- A tab to view all the user-made post
A place to view all comments made by the user in one place
Easy to access topic threads

Technological Features

Drawer Layout
Actions button
Fragments
Google Sign-in
No SQL Database
Hashmaps: as the main data structure
Intents
Recycler View
Classes and Objects
Tab View
Search Bar

The Architecture

After considering Model-View-Presenter, Model-View-ViewModel and Model-View-Controller (MVC) architectures, we chose to go ahead with MVC due to the advantages it has and the ease of implementation; important ones of them are:

Highly supports separation of concern
Multiple users can work on the application at the same time
Easier to update the application
Easier to debug
Write reusable code
Supports test-driven development

The Model View Controller is a predictable software design that can be used for development across multiple tech stacks like python, java, javascript etc. and is primarily used for developing web applications and mobile apps. It is designed such that multiple programmers in a team can work on different aspects of development without being dependent on each other. The main aim here is to separate the presentation layer from the logic and database.

Breaking it down:

Model: Stores and manages data. It is responsible for handling the domain logic(real-world business rules) and communication with the database and network layers.
View: It is a User Interface layer providing the visualization of the data stored in the Model.
Controller: Contains the core logic. It gets informed about the user's behaviour and updates the Model accordingly.

Choosing The Technology

1. Kotlin: Both Java and Kotlin can be used for Android Development. We chose Kotlin because of the advantages it has over Java. Kotlin leverages the language design expertise observing Java. It is very easy to learn, and reduces the boilerplate code ( or the extra code that we need to write ), for example, in java. Kotlin has a byte code structure that enhances the performance of the application. In addition, it allows both inline and lambda functions making the execution even faster than the same code in Java. Lastly, It is interoperable with Java, also it is more concise.

2. Firebase: We used the Firebase Firestore (a cloud database) since our application is in the beginning stage and does not have a large userbase that would need a real-time database. Provided by Google, it reduces the need to work with several third-party environments and allows server code; if the need ever comes to that. For an app like COOPS, a NoSQL database is preferred because of the dexterity and flexibility offered by the entire data structure, making Firebase the ideal choice as a database.

Views

1. Sign-in View As a user opens the application, he/she first sees a splash of the COOPS logo [1]; in the background, the application checks if the user has already signed in. If the user is yet to sign in, he/she is provided with the option to Sign-in with Google. Firebase handles the signing in and storing of the user on our application. Simultaneously, we also add the name and user details to our custom user database for our purposes. Once the sign-in is verified, he is redirected to his home page[2].

2. Home Page: This is the page the user would see post-signing in. The user would be able to see all their posts of all the topics he/she has subscribed to. The user can see the topic a particular post belongs to and can click on it to navigate to the more detailed Post View.

3. General Layout: Every activity in COOPS has an additional side panel and a topbar. The top bar is a search bar, that can be used for searching through the topics that have been created so far. The side panel is used for navigating through the application and moving through the various activities. As of now, the side panel has the user information (name, email and profile picture), the home page, the user profile page and the facility to navigate through to any of his followed topics within the application.

4. Search Bar: The search bar is present across views in the application which can be used to search for topics that are present in the application; whether the user is already following it or wishes to explore a new topic.

5. Side panel:
The Side panel has three main subparts:

Profile: This part consists of the user name, email and profile photo. Clicking on this would direct the user to the profile page.
Home: This is a home tab. The user can navigate back to the home page of the application by clicking the home icon.
Following (Topics): The Following tab is a scrollable list of all the topics that the user has been following at that point in time. The user can navigate to any of the topics from the tabs and go see all the posts within the respective topic as and when he/she wishes to.

6. Profile Page: The profile page is the page that contains all the information that we as developers have for each individual user. The layout has been segmented into 3 different tabs :

User-info Tab:

This tab displays the user based information like user name, their email, their profile picture etc. In the future, we also aim to include more information for users and customization options for them. Additionally, this also contains the sign-out functionality from which a user can sign out.

Posts Tab:

This tab contains the various posts that a user has made, be it whichever topic he has contributed to. He can see the post title, the post body as well as the topic name so that he has complete information about his content, and can navigate to see the entire post properly in the post view from there.
Comments Tab:

This tab contains all the comments that the user has made across various posts and topics. In effect, this is all the content contributed by the user and he can once more, navigate across the app to the respective post on which he commented on clicking on the comments.

*7. Topic View: *

The topic view has the heading with the topic name, referring to the respective topic which you are viewing. The user can reach here either by searching for it or going to it from the user side panel. This also shows the number of followers the topic currently has and gives the user option to follow the topic or unfollow it if he is already following it.
Below the header, the posts within the topics are shown to the user, and he can navigate to the respective posts by clicking on them.
Finally, there is also a floating action button, that can be used by the user to make a post within the respective topic. If he wishes to make a post under a different topic, he will have to search up the topic, go within it and then click on the make post button there.

8. Post View:

The post view has the post title as its header and the post body below it. The post body currently allowed is text only, we plan to add media support to the body very soon. The view also has the number of upvotes/downvotes that are given by the other users of the community. The user can also choose to upvote/downvote the post depending on how useful he found the content, and help the community. In addition, he also gets the option to comment his opinion, findings, inferences etc about the post in a text view below, and other users can also read them to gain valuable insights about it.

9. Make a Post:

Coming to contributing to the community, the users can make posts within respective topics. The process is relatively very simple: All they have to do is enter the topic title, and the topic body ( blanks are not allowed ), and press the floating tick button to post it. Once he makes a post, he is redirected back to the topic view, where he can see that his post has been posted successfully.

More on Technological Features

Drawer Layout
The android drawer layout is an inbuilt layout, that acts as a top-level container for all our layouts to be used. This allows for an interactive drawer type of layout that can be pulled out by the user on some actions. This is what supports our navigation panel inside the application.
Actions button
In any application, users love playing with buttons. We have added the minimal buttons that they might need for using the application in a smooth hassle freeway, and this includes two main types of buttons ( apart from the general buttons ): A toggle button to pull out the "drawer" containing our navigation panel, and a Floating Action Button to handle events within the views without really adding clunky bits of boxes within the activities.
Fragments
A fragment represents a reusable portion of the application UI. It defines and manages its own layout, has its own lifecycle and can handle all input events on its own. However, it needs to be hosted by activity or another fragment and gets attached to the host activity/fragment hierarchy.
Google Sign-in
Rather than all applications maintaining their own versions of user databases and the users having to remember all those credentials, it’s just easier these days to facilitate google sign in, allowing google to handle all that hassle and giving a very good user experience to our users. The feature is as simple as it sounds: Let users login into your app using google.
No SQL Database
A NoSQL database or Non-SQL database refers to any non-relational database. They can store the data in form of documents, key-value pairs etc, and the main features that distinguish them include: flexible schemas, horizontal scaling, ease of use ( for developers ) and relatively faster query times
Hashmaps: as a main data structure
We have mainly used hashmaps for storing our data, as it helps not only in retrieving but also updating and adding data directly back into firebase. Hashmaps are data structures that store data in the form of key-value pairs. They do not guarantee a specified order but are significantly faster than normal databases.
Intents
Putting it simply, intents are a sort of messaging object that we as developers can use to request an action from another app component. It contains the basic activity that is to be started, along with any additional data information that may be needed by the app component.
Recycler View
A recycler view is an android component that is used to display a relatively large amount of data within a small UI component. It enables us to sync the data and UI much more dynamically.
Classes and Objects
Its always easier to use OOP paradigms whenever possible, especially in bigger projects where the code complexity will increase with the increase in time.
Tab View
The tab layout in androidx library is a component that allows you to have multiple linear layouts with instances for TabLayout.Tab. Tabs in android applications are just like tabs in web browsers, allowing you to view multiple UIs with data within the same layout.
Search Bar
The android search widget with a text bar and a search button, that helps us with the search functionality that we have implemented to help users search topics.

Higher Order Functions

param-19 — Mon, 07 Dec 2020 13:23:32 +0000

Abstraction

Abstraction is the process of hiding information from the users. They give us the ability to understand and read code at a higher level, while hiding the details, to give us an overview.

There exists a filter method which builds a new array that contains the results that pass given test.

console.log(filter(SCRIPTS, script => script.living));
// → [{name: "Adlam", ...}, ...]

Maps

The map method transforms an array by applying a function to all of its elements and building a new array from the returned values. The new array will have the same length as the input array, but its content will have been mapped to a new form by the function.

function map(array, transform) {
    let mapped = [];
    for (let element of array) {
        mapped.push(transform(element));
    }
    return mapped;
}
let rtlScripts = SCRIPTS.filter(s => s.direction == "rtl");
console.log(map(rtlScripts, s => s.name));
// → ["Adlam", "Arabic", "Imperial Aramaic", ...]

The reduce method is another function that takes in the input, and a condition based on which it combines elements. You can easily understand how reduce works based on the given example.

console.log([1, 2, 3, 4].reduce((a, b) => a + b));
// → 10

Javascript : Arrays and Objects

param-19 — Mon, 07 Dec 2020 12:45:49 +0000

Arrays

Arrays are a data type that can store a list of sequences of values. It is written as a list of values between square brackets, separated by commas.
All arrays are 0 indexed in javascript, i.e., the first element starts off with index 0 rather than the conventional 1. This is standard across all coding languages, and has been kind of a tradition.

let list = [1, 2, 3, 4, 5];
//You can access each value inside this array as : 
console.log("The first element is : "+list[0]);
//The first element is 1

The two main ways to access properties in JavaScript are with a dot and with square brackets. Both value.x and value[x] access a property on value —but not necessarily the same property. The difference is in how x is interpreted.
When using a dot, the word after the dot is the literal name of the property.
When using square brackets, the expression between the brackets is evaluated to get the property name. Whereas value.x fetches the property of value named “x”, value[x] tries to evaluate the expression x and uses the result, converted to a string, as the property name.

Methods

Properties that contain functions are generally called methods of the value they belong to, for example, "toUpperCase" is a method of string.
We can manipulate the arrays in JS using two main methods : push and pop .

let sequence = [1, 2, 3];
sequence.push(4); //push method adds an element at the end of the array
sequence.push(5);
console.log(sequence);
// → [1, 2, 3, 4, 5]
console.log(sequence.pop()); //pop method removes the last element of the array
// → 5
console.log(sequence);
// → [1, 2, 3, 4]

Objects

Values of the type object are arbitrary collections of properties. We usually define objects using curly braces {} . We can access the elements of individual properties within an object using the . operator.

let day1 = {
squirrel: false,
events: ["work", "touched tree", "pizza", "running"]
};
console.log(day1.squirrel);
// → false
console.log(day1.wolf);
// → undefined
day1.wolf = false;
console.log(day1.wolf);
// → false

You can use the delete operator to delete a property of an object. For example

let anObject = {left: 1, right: 2};
console.log(anObject.left);
// → 1
delete anObject.left;
console.log(anObject.left);
// → undefined
console.log(anObject.right);
// → 2

console.log("left" in anObject);
// → false
console.log("right" in anObject);
// → true

The binary in operator can be used to check if an object has a property with the particular name. To find the keys in an object, you can use Object.Keys .

console.log(Object.keys({x: 0, y: 0, z: 2}));
// → ["x", "y", "z"]

Array loop

The first loop is below is a normal for loop, going over each element one by one. However, the counter here has no purpose other than referencing each element.

for (let i = 0; i < JOURNAL.length; i++) {
let entry = JOURNAL[i];
// Do something with entry
}

for (let entry of JOURNAL) {
console.log(`${entry.events.length} events.`);
}

The second loop also iterates through the entire array, and each element is sequentially taken as entry, and used inside the loop.
Both the loops are used and work well.

Some more methods

Just like push and pop work at the last index of an array, shift and unshift are used to add and remove elements at the start of an array.

let todoList = [];
function remember(task) {
todoList.push(task);
}
function getTask() {
return todoList.shift();
}
function rememberUrgently(task) {
todoList.unshift(task);
}

To search for a specific value, there is an indexOf method. This returns the first index from the start. If you wish to start searching from the last index, you have lastIndexOf .

console.log([1, 2, 3, 2, 1].indexOf(2));
// → 1
console.log([1, 2, 3, 2, 1].lastIndexOf(2));
// → 3
//Both these methods take in an optional second argument,
//that indicates from where to start searching

We also have the slice and concat methods to perform slicing and concatenation respectively.

function remove(array, index) {
return array.slice(0, index)
.concat(array.slice(index + 1));
}
console.log(remove(["a", "b", "c", "d", "e"], 2));
// → ["a", "b", "d", "e"]

Strings and their methods

One of the most useful ones are slice and indexOf .

console.log("coconuts".slice(4, 7));
// → nut
console.log("coconut".indexOf("u"));
// → 5

The trim method removes whitespaces, and other extra symbols from a given string.

console.log("Hey param \n ".trim());
// → Heyparam

The padStart method allows us to pad a given string, taking in the length and the padding character as arguments.

console.log(String(6).padStart(3, "0"));
// → 006

You can use the split and join methods on strings.

let sentence = "Secretarybirds specialize in stomping";
let words = sentence.split(" ");
console.log(words);
// → ["Secretarybirds", "specialize", "in", "stomping"]
console.log(words.join(". "));
// → Secretarybirds. specialize. in. stomping

You can use the repeat method to create multiple copies of a string

console.log("LA".repeat(3));
// → LALALA

Rest Parameters

Sometimes, we may want to have a function to have any number of arguments. This can be done by adding in 3 dots ... before the last parameter of the function.

function max(...numbers) {
let result = -Infinity;
for (let number of numbers) {
if (number > result) result = number;
}
return result;
}
console.log(max(4, 1, 9, -2));
// → 9

The JSON Object

We often need to store information in objects, or use it for later use. To do this effectively, we serialize the data. This means that it will be stored in a flat description. One of the most popular ways is to store it in JSON (JavaScript Object Notation) format. This is used not only for JS, but also used across the web to send and store information.

{
"squirrel": false,
"events": ["work", "touched tree", "pizza", "running"]
}

Functions in JS

param-19 — Sat, 05 Dec 2020 19:45:13 +0000

A function definition is a regular binding where the value of the binding is a function.For example,

const square = function(x) { return x * x; };

Each function will have both a definition and declaration.
- Declaration is basically you simply telling JS to make a particular function, and witholding the info on how the function will process your arguments.

function declare();

Definition on the other hand, will tell JS exactly what your function will do with the input arguments.

function declare(){ console.log("Hi, I am Param"); }

Scope : Each variable will have a scope, usually global or local.
- Global scope indicates that the variable can be used by any function or block of code in our program.
- Local scope means that the variable is valid only within our code block, for example, inside a function. No code segment outside our function(in the above example) will be able to access a local variable.
- Note : Nesting of functions is possible, i.e., you can declare functions within functions, code blocks within other code blocks. This means that we can have a lot of local variables and global variable pairs too.

The arrow notation :

Quoting from EloquentJS, "There’s a notation for functions, which looks very different from the others. Instead of the function keyword, it uses an arrow (=>) ."
Its syntax goes like :

const power = (base, exponent) => { let result = 1; for (let count = 0; count < exponent; count++) { result *= base; } return result; };
- The arrow comes after all the function arguments, and is followed by the normal function body, as in the usual syntax that we have seen above.

Optional arguments

A function can be given additional arguments, in the sense you can provide 3 arguments to it, when it has only one argument. This is perfectly fine, and JS will ignore you and do your work.
Also, you can make define a function as

const bio = (name, age = 25) =>{ //age is an optional argument console.log("Name :" + name + " Age :" + age); } //call 1 bio("param"); //call 2 bio("param",19); //output 1 : Name :param Age : 25 //output 2 : Name :param Age : 19

In the above function, both calls are perfectly valid.

Recursion

As stated above, you can have functions calling other functions, and even itself within the function. This way of calling a function within itself is known as recursion.

For recursion, the function will have 2 main things :
* A base condition, on which it will exit the recursive call
* The call to function itself
* Optional : Any other logic/programming, if required

function power(base, exponent) { if (exponent == 0) { return 1; } else { return base * power(base, exponent - 1); } } console.log(power(2, 3)); // → 8

Review

I would love your feedback on this guys, and feel free to revert back to me with any recommendations that you have for me. You can also mail me at padb19122000@gmail.com .

Javascript : Program structure

param-19 — Sat, 05 Dec 2020 19:22:39 +0000

We look forward to going over JS program samples here, and how the entire program is broken down into various parts. In addition, we shall also see how the parts interact with each other, and come together to give output that we desire.

Expressions

Any fragment of code that produces an output/value is called an expression . For example, these are expressions : 1; true?5+10:5-10;
- Note : JS doesn't make it compulsory to insert semicolons at the end of every statement like you would need to in C++. Neither can you just skip semi-colons everywhere like you would need in Python. It is required at some places, and at other places it is optional : It wont matter if you keep its fine, otherwise also its fine. ####Bindings or Variables
All numbers have a predefined value, and are recognised by JS. But what if you want to store some thing like 25? Writing 25 everywhere will be not only too tedious, but also make it hard to write. We can use variables to bind a value, or hold a value with yourself . For example, here ten is a variable

let ten = 10;
console.log(ten * ten);
// . 100

Keywords are special words that have been reserved for a specific purpose in a language. In the above example, the word let is a keyword. The following are the keywords in JS :

break case catch class const continue debugger default delete do else enum export extends false finally for function if implements import interface in instanceof let new package private protected public return static super switch this throw true try typeof var void while with yield

For naming any binding or variable, we can use any of the alphanumeric characters, along with the special character '_' . However, no variable name should start off with a number, special character or should resemble a keyword.
All these keywords, along with the variables and functions together make up the environment.

Functions

A function is a piece of program that is wrapped in a value. It can take in inputs (called arguments) , process and then return an expected value. It can also have other "side effects" , such as printing out some value, calling another function, and so on.
Each function will have both a definition and declaration.
- Declaration is basically you simply telling JS to make a particular function, and witholding the info on how the function will process your arguments.

function declare();

Definition on the other hand, will tell JS exactly what your function will do with the input arguments.

function declare(){
     console.log("Hi, I am Param");
}

Scope : Each variable will have a scope, usually global or local.
- Global scope indicates that the variable can be used by any function or block of code in our program.
- Local scope means that the variable is valid only within our code block, for example, inside a function. No code segment outside our function(in the above example) will be able to access a local variable.
- Note : Nesting of functions is possible, i.e., you can declare functions within functions, code blocks within other code blocks. This means that we can have a lot of local variables and global variable pairs too.

Conditionals

We cant have straight forward control of our program , always. We may often need to check for something, and our answer will be based on if the condition is met or not. In such cases, you have the following conditionals :

If block :
- It checks for a condition, and executes a code block if the condition is met, else it will move on.
```
   if(condition){
       console.log("I am inside the if block");
   }
```

If-else block :

It checks for a condition, and executes a code block if the condition is met, else it will execute another code block.

   if(condition){
       console.log("I am inside the if block");
   }
   else{
       console.log("I am inside else block. Condition is not met");
   }

Else-If ladder :

It checks for a condition, and executes a code block if the condition is met, else it will move on, untill a possible condition is met. If none of these are met, there is also an optional default code block that can be executed.

   if(condition){
       console.log("I am inside the if block");
   }
   else if(condition2){
   }
   else if(condition3){
   }
   .
   .
   .
    else{
       console.log("None of the conditions match, hence I am here");
   }

Nested Else-If :

It checks for a condition, and executes a code block if the condition is met, else it will move on, untill a possible condition is met. If none of these are met, there is also an optional default code block that can be executed.
You can think of this as another representation for the else if ladder.

   if(condition){
       console.log("I am inside the if block");
   }
   else{
     if(condition2){
     }
     else{
        if(condition3){
        .
        .
        .
                    else{
                       console.log("None of the conditions match, hence I am here");
                    }
         }
    }

The switch block :
- The switch block is an exclusive block that is used when we want to set some condition based on a given variable only.
- The break keyword is used to differentiate between the different conditions, else it will cascade down and all the statements after the { statement where the variable matched condition } will execute.
- The default statement will be executed in the event that none of our conditions match.

 switch(expression) {
  case x:
    // code block
    break;
  case y:
    // code block
    break;
  default:
    // code block
}

Looping

Often, in our programs, we may want to execute the same repetitive code block until a certain condition is met. It can be a simple addition or expanded to hundreds of lines of code. For such cases, we have loops to deal with in JS.

While loop : This loop will keep on being executed as long as the condition is not met.

while (condition) {
  // code block to be executed
}

Here, JS checks the condition first every single time, and then execute the code block.

Do-While loop : This is very similar to the while loop, and will keep on repeating until the condition is met. However, it is different from the while loop in the way it is executed

Here, JS executes the code block first and then checks the condition. Hence, it will always run for atleast 1 time.

do {
  // code block to be executed
}
while (condition);

For loop : Often, you may want to run a loop with a given iterator, which counts the number of times the loop is run. The condition can be anything, including based on your iterator. For these purposes, we have the for loop.

for (statement 1; statement 2; statement 3) {
  // code block to be executed
}
Statement 1 is executed (one time) before the execution of the code block.

Statement 2 defines the condition for executing the code block.

Statement 3 is executed (every time) after the code block has been executed.

Note : You can always suddenly break out of a loop using the break keyword, just like we saw in the switch block above.

Comments

Comments are written lines of code by the programmer, that are not shown or compiled by JS. These are used to enhance the readability and understanding of the code.
Another practice done to improve the readability is to indent the code. Ofcourse, JS will compile it the same whether you indent your code or not, but to enhance the readability of the code, divide it into proper segments, we indent the same.

Introduction to Javascript

param-19 — Sat, 05 Dec 2020 13:50:28 +0000

Recently, I started off on working with Javascript, after studiously trying to ignore it ( because people said a lot, and I get influenced easily ). I took to php , had decent projects and even managed to intern at a respectable institute using my knowledge. However, as the days passed, I realised something : I would have to learn and work with Javascript, sooner or later.I did do a couple of projects before, but never felt it worth it and always kept on ignoring it.

So after a year of ignorance, I got motivated enough to start working with it. It takes a great deal of hard work and self discipline to come out of your safe little bubble, and I feel lucky enough to finally come out of it. Thanks to the motivation offered by peers and mentor Mr.Tanay Pratap, I am finally going to switch to JS.

Starting off, I am reading the Eloquent JS , and this is the first blog in a long series of blog posts. I am reading through and learning all the things mentioned in the book, and logging each chapter as a blogpost.

Chapter 1 : Values, Types and Operators

As we are all familiar, all values numbers variables everything is stored in binary form and read and used by the computer, be it the internet , your CPU or the compiler. Hence, binary is all that we will consider our scales in.

Numbers

JS uses 64 bits to store the numbers, in the signed format, i.e., the MSB (Most significant bit) will be a 0 or 1 and decide the sign of our number, positive or negative.
For large numbers, the scientific notation of e is used.
- 2.99e8 = 2.99 * 10^8 *JS also allows for 3 special numbers, namely :
- Infinity : Positive infinity
- -Infinity : Negative infinity
- NaN : It stands for Not a number . This kind of numbers are obtained when you end up doing something weird, say a 0/0 , or Infinity - Infinity operation. ####Arithmetic operations
JS allows for a total of 5 arithmetic operators :
- Addition +
- Subtraction -
- Multiplication *
- Division /
- Modulo operator %
All these are carried out in the precedence order, for example, multiplication will be carried out before addition. However, if there are two operators of the same order , the operation will be carried out in a left to right fashion.
* Tip : Since brackets are allowed here, we can escape the entire precedence by just putting brackets as required.

Strings
JS uses 16 bits to represent each string, i.e., each string can describe upto a total of 2^16 characters. That is a lot !!
Each character is described in its ASCII value, for example, 'A' has an ASCII of 65, 'a' has an ASCII of 97, and so on.
There are also some special characters involved, like for the new line we use the \n character.
JS uses the backslash() operator to define such special characters, which may have some importance. It also by default folds down if there are two backslash() in a row, so both \n and \n will be treated as the same.
Template literal : ${} is the template literal. You can use this inside a string and it wont be printed as it is. Rather, its contents will be calculated and then the result will be printed out. If you are familiar with python, this works the exact same as that of a formatted string.

Operators

Now time for some operators 😄 . Wont be going into great details, as these are actually self explanatory
typeof : Returns the type of your object
> : Greater than operator
< : Less than operator
>=: Greater than equal to operator
<= : Less than equal to operator
== : Equal to operator
!= : Not equal
- Note : Both the equal and not equal operators above (last two) facilitate automatic type conversion in JS. This means that if you compare a string and a number, JS will convert the string to number, compare and then give you the results. If you dont want such type of automatic type conversions , go for the operators below :
=== : Equal to operator, compares without type conversion
!== : not equal operator, compares without type conversion
& : Boolean AND operator
&& : Logical AND operator
| : Boolean OR operator
|| : Logical OR operator
a?b:c : Conditional operator. It checks for condition a, and returns b if true else returns c.

Review

I would love your feedback on this guys, and feel free to revert back to me with any recommendations that you have for me. You can also mail me at padb19122000@gmail.com .