• "="

• "=="

• "==="

What is ( = ) in programming languages?

• A single equals symbol (=) is also called an assignment operator.

• In simple terms, when I say " a = 5 ", this means that I am putting the value '5' inside the variable ' a '.

• Now, when I try to print the value of ' a ', I will get the value ' 5 '.

•     const a = 5;
      console.log(a); // 5
  

What is ( == ) in programming languages?

• The pair of equal signs ( == ) when put together acts as a comparison operator.

• This means that it will check for equality in the two values that are placed on both the left and right sides of this operator.

•     const a = 5;
      const b = "5";
      console.log(a == b); // true
  

• We can see in the above example that the value of ' a ' is of Integer data type and the value of ' b ' is of String data type and when checking the equality for these values, it results in ' true '.

• This equality ( == ) operator does not consider the data type while checking for equality of the values. It only compares the values and if the values are the same, it results in ' true ' or else ' false '.

• But before comparison actually takes place, coercion comes into the picture for this operator.

• Coercion refers to the automatic conversion of one data type to another.

• First, one of the values is converted from one data type into the data type that fits the other value. For eg: The string data type is converted to a Number data type.

• After coercion, a comparison between the two values takes place.

• For this reason, this operator is also called the loose equality operator.

What is ( === ) in JavaScript?

• If we want to compare the data types also while checking for equality in values, then we have the triple equals operator ( === ) aka strict equality operator.

• When used, this operator checks for equality in data types of the values along with equality in values.

• If the values are of different data types then it will result in ' false '.

•     const a = 5;
      const b = "5";
      console.log(a === b) // false
  

• We can see in the above example, even though the values are the same but they have different data types and for this reason, the expression results in ' false '.

• Coercion does not take place here.

• This operator checks for equality for data type along with the value, this operator is also known as the strict type operator.

This is all about the ( = ) operator in javascript. JavaScript can be really tricky but I will make sure to explain these complex concepts and topics in as simple way as I possibly can.

Git is an open-source version control system. Now, you might be thinking what the heck this means... but don't worry, I will explain to you every single word that I have written like I am explaining to a 5-year-old.
- Git is just a name that has been given to this version control system, which is an open-source software maintained by some amazing developers.

- Version Control System is a system that has been developed to manage, maintain and to be in sync with your collegues and other collaborators who are working on the same project.

- There are projects, software, applications, etc being built, by some developers and their source code is made available to the public so that developers around the world can see, go through the code, fix the existing issues and contribute to the code base in order to maintain and improve the software. This is what exactly open source software means.

Why VCS?

Imagine a scenario, where you and two of your other friends are working from home because of covid, on a project that needs to be build with multiple features in it. Now, think of all the ideas by which you can collaborate with each other. If you think of sending the finished project files via email, then the attachments can be too large. If you think of doublt-tripple compression, even then the file will be too large and another hassle to decompress the file multiple time comes to the picture. If you think that you will upload the files to gdrive or something like that then there can be big conflicts in the file structure and can result in breaking the appli,cation.
So, exactly for this reason, the version control system aka VCS was developed.

The VCS helps teams solve these kinds of problems. It tracks every individual changes by each and every contributor, helps in preventing conflicts. It basically takes a snapshot of all the work you have done so far. Each of the contributors can work on their feature independently and merge everything into one after they are done with their work on the project.

How to use git?

To use git, like every software, we need to download and install git on our systems and where do we download and install git from? We download and install git from here.

What after installing git?

• After installing git, open your terminal and type:

git --version

This will show you the currently installed version of git.

• To work with git or in other words, in order for git to track all the changes in the project, you need to ask git to do that for you and how do you ask git to track your project? You simply type:

git init

This command will initialize an empty git repository for you. Basically this means that git will now start to track all the changes made in your project.

• Git will also tell you the status of all the tracked and untracked files when you type:

git status

• For git to add the files to it's tracking list, you will need to add the files manually by using the command:

git add file_name
# if you want to add all the files to the tracking list, then use the command:
git add .

• After adding the files to the tracking list, you will need to cofirm that you want to make the changes permanent by commiting that change in the tracking list by using the command:

git commit -m 'commit-msg'

• If you want to work on a differnt feature of the project that you are building and work in a way that the changes you make in your code does not change anything in the final code until you are satisfied with your work then you can create different branches by using the command:

git branch branch-name

• You can create multiple branches and work on multiple feature independently of other features by creating multiple branches.

• To get an overview of all the branches you or your team mates have created so far you can use the command:

git branch

• To switch between various created branches you can use the command:

git checkout branch-name

• To combine the work you and your friends have done you can use the command:

git merge branch-name

• To send your changes to the production, you will need to push your code to your repository by using the command:

git push remote-repository branch-name

• If you want to check history of everything that has happened to a git repository then you can use the command:

git log

• Now what is this production and repository?

  • Production is the final environment in a software developement process. When a code is pushed to production then it means that all the changes made in the code is finally available for the public to use.

  • Repository is the collection of file and folder structure containing all the different versions of a project.

• If you have to collaborate on some existing projects that is already being worked upon, then you will need to pull the code from you github or gitlab account by using this command:

git pull remote-repository-url

• What is a remote repository?

  • A remote repository is a repository that is not on your local system but at a remote location like github or gitlab.

• What is github and gitlab?

  • Github, gitlab and there are other services also. These are the companies that offer cloud based git repository hosting service which makes it easier to collaborate on any project.

This is all the information that was required to understand the version control system - git. I have covered all the basic and most used commands that we use in our day to day life as a software developer. I tried to explain everything in a way as if I was explaining to a 5 year old.

Drop down your comments, suggestions or something important that I missed on. I will try to cover it up on my next blog.

If you want to get in touch with me or know more about me then just google "clevercoderjoy".

In this blog, we will learn about conditions and loops. In my previous blog flow of control, I talked about the flow chart where we discussed how the flow of a program works by taking some input, doing some processing which involves taking decisions and doing some repetitive tasks, and then producing the desired output. We have already discussed the inputs and outputs here so now, we will discuss the processing part in detail.

Conditions

• In our code, there are times when we need to make decisions, and based on those decisions we want the flow of control in our code to be diverted to a particular action corresponding to those decisions.
• This making decision and diverting the flow of control is done by the "if" statement.
• With the "if" statement, we can have check conditions in our code.
• If the condition is satisfied then the code inside the if block executes.
• If the condition is not satisfied then the flow of control of the program will not get inside the if block and the if block will be skipped.
• The syntax for the "if" condition is:

    if(boolean expression True or False){
        //body...
    }
  

• We also have the "else" statement that can be used with the "if" statements.
• When the "if" condition is not satisfied we can either choose to skip the if block or we can add an "else" block.
• The "else" block executes when the condition given for the if statement is not satisfied.
• The syntax for the "if-else" statement is:

    if(boolean expression True or False){
        //body...
    }
    else{
        //body
    }
  

• Amongst the "if-else" statement, only one of the two will execute while the other will be skipped.
• We can also write multiple "if-else" statements.
• The syntax for multiple "if-else" statements is:

    if(boolean expression True or False){
        //body...
    }
    else if(boolean expression True or False){
        //body
    }
    else{
        //body
    }
  

• Only one amongst "if, else if, else" will execute.
• Here's a simple program based on what we studied just now

A program to check if a number is positive, negative, or zero.

    import java.util.*
    public class Number{
        public static void main(String[] args){
            int n = 5;
            if(n > 0){
                System.out.println("number is positive.");
            }
            else if(n < 0){
                System.out.println("number is negative.");
            }
            else{
                System.out.println("number is zero.");
            }
        }
    }

Loops

• Let's suppose that we want to write all the numbers from 1 to 5.
• We can simply use:

    System.out.println(1);
    System.out.println(2);
    System.out.println(3);
    System.out.println(4);
    System.out.println(5);
  

• Although we had to write the printing statement five times, we did it since it was doable.
• What if we want to write all the numbers from 1 to 100 or maybe 1000 or 10000 or some other large number then what? Printing these values with just the print statement is not doable at all. We will have to write the print statement many many times.
• So, to tackle this issue we have loops.
• With loops, we can perform repetitive actions as many times as we want without having to write the code snippet so many times.
• We have three types of loops:
  • for loop
  • while loop
  • do-while loop

For Loop

• Let's take a closer look into for loop.
• The syntax of for loop is:

    for(initialization, condition, updation){
        // body
    }
  

• Here, the initialization part is where we initialize our variable with which we want to perform certain actions inside the loop.
• The condition part is where we have our exit condition.
• Exit condition means the condition which defines when will the flow of control exit out of the loop.
• The updation part is where after every iteration, the initial value will be updated to a new value.
• Let me show you an example:

    import java.util.*
    public class Number{
        public static void main(String[] args){
            int n = 5;
            for(int i = 1; i <= n; i++){
                System.out.println(i);
            }
        }
    }
  

• Here, inside the for loop, i is initialized to 1 which means that initially, the value of 1 will be 1.
• i <= n means that the flow of control of the program will exit out of the for loop once the defined condition is hit.
• i++ means that after printing the value of i, the flow will go to the updation part where the value of i will be updated. Here, the i++ means that the value of i is increased by 1.
• The program will end once the value of i becomes 6.
• Note that when the value of i becomes 6, the flow of the program will not go inside the loop as per the defined condition.

While Loop

• The syntax for while loop is:

    while(condition){
        // body
    }
  

• Let me convert the above code into the while loop so that you can see the major difference between the two.

    import java.util.*
    public class Number{
        public static void main(String[] args){
            int n = 5;
            int i = 0;
            while(i <= n){
                System.out.println(i);
                i++;
            }
        }
    }
  

• Unlike the for loop, in while loops we have to manually define and control the initialization and the updation part.
• We can use any loops of the two anywhere we want.
• It is however advisable to use the for loop when we know how many times the loop is going to run and while loop when we don't know how many times the loop is going to run.

do-while loop

• We have another loop called the do-while loop.
• The syntax of do-while loop is:

    do{
        // body
    }
    while(condition);
  

• Let me convert the above code into the while loop so that you can see the major difference between while and do-while loop.

    import java.util.*
    public class Number{
        public static void main(String[] args){
            int n = 5;
            int i = 0;
            do{
                System.out.println(i);
                i++;
            }
            while(i <= n);
        }
    }
  

• In case of do-while loop, the flow of control of the program will enter the loop at least once regardless of what condition is given in the code.
• The body will be executed once and then the condition will be checked.

This is all about Conditions and loops in JAVA. I hope that you will be able to understand everything very well.

In the next blog, I will cover switch case in a JAVA program in the next blog.

Let me know comments down below if you like what you read or have some suggestions for me and make sure to follow me on all my social handles from here to stay connected. If you want to get started with JAVA for the first time then you can hop back to my very first blog of this series.

In this blog, I will walk you through type conversion and some important key points around the concept.

Type Conversion

The conversion of one data type into another data type is called type conversion. When one type of data is assigned to another type of variable, then automatic type conversion will take place if the following conditions are met:

• The two types should be compatible (String and characters are not compatible with int, float, and long).
• The destination type should be greater than the source type (taking an integer and providing a float or a decimal value as an input will result in an error but vice versa will work).
• JAVA also performs automatic type conversion when storing integer constants into variables of types like byte, short, long, and even char sometimes by using their ASCII values.

Type Casting

• If the destination type is smaller than the source, then that type of conversion is also called type casting or narrowing conversion.
• Simply put, compressing the bigger number into a smaller data type explicitly is called type casting.
• Type casting is also known as coercion.
• If we have multiple types of data for a particular expression, then the result for the entire expression will be converted into the biggest data type.

JAVA follows Unicode principles so we can put any language inside it to print it via System.out.print("any language");

This is all about type casting and type conversion in JAVA. I hope that you will be able to understand everything very well.

In the next blog, I will cover loops and conditionals in a JAVA program in the next blog.

Let me know comments down below if you like what you read or have some suggestions for me and make sure to follow me on all my social handles from here to stay connected. If you want to get started with JAVA for the first time then you can hop back to my very first blog of this series.

In this blog, I will cover the data types and how can we take inputs from the user for a particular data type.

Data Types

To take input from the user in JAVA, the programming language must know what type of input to take beforehand. This means that there are multiple types of data that we can take as input from the user. In JAVA, there are two types of data:

• Primitive Data Type
• Non-Primitive Data Type

These data types can be further categorized into various types.

Primitive Data Types

• These data types are single-value data types that can not be broken down any further.
• We can assign only a single value to these data types.

Primitive data types can be further categorized into various data types:

• int: For taking whole numbers (int n = 56)
• char: For taking character inputs (char ch = 'a')

• float: For taking decimal values (float n = 65.69f)

  • Why do we use 'f' at the end of the digits while using float?

    Ans: All the decimal values that we have are of type double by default. So, we explicitly need to use f to tell the compiler that we need a float value, and just declaring the data type as float is not enough.

• double: Also for taking decimal values(double d = 454554.4567)

• long: For taking large integer values (long n = 1456546546545L)

  • Why do we have long when we have int?

    Ans: This has to do something with the size of input that a particular data type can store. Long can store larger values than int.

• boolean: For taking true or false values (boolean check = false)
• There are a few more but those are not as much used as those mentioned above.
• Every data type has a size and range up to which they can store the data.
• You can check the image attached below for more clarity.

Non-Primitive Data Types

• These are the multi-value data types that can be broken down even further into primitive data types.
• We can assign multiple values to these data types.

Non-Primitive data types can be further categorized into various data types:

• Strings: For taking a series of characters or words ( String s = " s f a g blogs clevercoderjoy")
• Arrays: For taking a series of numbers ( int[] arr = {5, 6, 9, 8, 3} )
• There are some more non-primitive data types but we will cover them in later blogs.

Here is a pictorial representation of various data types:

Taking input for each primitive data type

• We will cover taking input for non-primitive data types in later blogs.
• For each of the primitive data types, we can assign values directly to the type of variables we want to use in our program. ( int a = 5; or char ch = 'a';)
• There is a specific syntax for each data type if we want to take input from the user.
• Assuming you have already written the main function and have created a Scanner object "sc" to take input from the user.
• int: int n = sc.nextInt();
• char: char ch = sc.next().charAt(0);
  • This charAt(0) means that take the character at the 0th index as an input.
• float: float n = sc.nextFloat();
• double: double d = sc.nextDouble();
• long: long n = sc.nextLong();
• boolean: boolean check = sc.nextBoolean();

Program to take two numbers as input from the user and print their sum

Code

    import java.util.Scanner;
    public class Main
    {  
        public static void main(String args[])   
        {
            Scanner sc = new Scanner(System.in);
            System.out.println("Enter the first number: ");
            int num1 = sc.nextInt();
            System.out.println("Enter the second number: ");
            int num2  = sc.nextInt();
            int sum = num1 + num2;
            System.out.println("The sum of the two numbers is: " + sum);  
        }
    }

Input

num1 -> 5

num2 -> 6

Output

The sum of the two numbers is: 11

Comments in JAVA

There are times when we just want to make notes in our code file or we might want to write down some important pointers on what a particular function is doing. So, for that we have comments. We can write anything in the comments because comments in any programming language are ignored by their compilers.

We have two types of comments:

• Single-line comments:
  • We can use single-line comments by using two forward slashes ( // )

    // int x = 56;
    // hey clevercoderjoy
    // hey kunal
    

  • We can highlight multiple lines on our program and press the key combination of ctrl+/ to comment on all those highlighted lines.
• Multi-line comments:
  • We can use multi-line comments by using a forward slash and an asterisk to denote the start of multi-line comments and an asterisk and a forward slash to denote the end of the multi-line comment ( /* */ ).

       /* int x = 56;
       hey clevercoderjoy
       hey Kunal */
    

• To add multi-line comments along with pointers we can use a forward slash and two asterisks to denote the start of multi-line comments with pointers and two asterisks and a forward slash to denote the end of the multi-line comment.( /** **/ )

    /**
    * int x = 56;
    * hey clevercoderjoy
    * her kunal
    **/
  

• Every time we press enter, we will have an asterisk at the start of the next line

Literals

• In primitive data types, the values assigned to their variables are called literals.
• In ( int x = 56; ), 56 is a literal that is assigned to the variable x of type integer.

Identifier

• Identifiers are used for identification purposes.

    public class Test
    {
         public static void main(String[] args)
        {
            int a = 20;
        }
    }
  

• In the above java code, we have 5 identifiers namely :

    - Test : class name.
    - main : method name.
    - String : predefined class name.
    - args : variable name.
    - a :  variable name.
  

Rules for naming an identifier

There are certain rules to naming any identifier and violating these rules will result in an invalid identifier.

• The only allowed characters for identifiers are all alphanumeric characters([A-Z],[a-z],[0-9]), ‘$‘(dollar sign) and ‘_‘ (underscore).
• Identifiers should not start with digits([0-9]).
• Java identifiers are case-sensitive.
• Reserved Words or keywords can’t be used as an identifier.

This is all about data types in JAVA. We have also covered some other topics too and I hope that you will be able to understand everything very well.

In the next blog, I will cover type casting and automatic type conversion in a JAVA program in the next blog.

Let me know comments down below if you like what you read or have some suggestions for me and make sure to follow me on all my social handles to stay connected. Links are on the top-right corner of this page and if you want to get started with JAVA for the first time then you can hop back to my very first blog of this series.

In this blog, I will cover how can we take an input from the user and display some output on the screen.

Inputs in JAVA

There are multiple ways to take input in JAVA but we will look into the easiest and the simplest of all of them.

• In JAVA, we have a class named "Scanner".
• We can use this "Scanner" class to take input from the user.
• This class resides in a special package named "util".
• So, to use this class, we will first have to import this package into our JAVA program using the keyword "import".
• The syntax for this would look something like this:

    import java.util.Scanner;
    public class Main{
        public static void main(String[] args){
            Scanner sc = new Scanner(System.in);
            sc.close();
        }
    }
  

  Now, let me explain to you everything word by word on what it means and why we use them.
• To be able to use some of the special libraries in our code, we need to import them using keyword import and so we have used the keyword import.
• Most of the libraries and classes are defined inside a package named java, so to use them we need to tell the location of the package name java to our program which is why we have used the package name java.
• Inside JAVA, there is another package named util, where the Scanner class that we want to use is located. So, to get inside or access that util package, we need to use "." (dot operator) to access the contents inside a package or a class.
• To use the Scanner class in our program, we need to import the Scanner class and then end the line with a ";".
• We could have also written import java.util.*; and * here means everything so it will import everything that is inside the util package including the Scanner class.
• I have already explained to you about the public class and public static void main so I will skip this part but if you want to understand this part you can jump on to this blog for all the required explanation.
• Now, inside the main function, Scanner is the name of the class that we want to use.
• "sc" is just a variable name which means you can use any name here. Even your name.
• To use the Scanner class, we will have to create its object. The keyword "new" is used to create an object in JAVA.
• So, this statement Scanner sc = new Scanner() is creating the object of the Scanner class and we can then use the reference variable "sc" of this class to use this object for taking input later in our program.
• Now, inside the brackets, we have System.in. This denotes the mode that we want to use for taking input from the user.
• We need to pass the source from where we want to take input from the user inside these brackets.
• Here, System.in points to the input devices attached to our computer systems which are keyboard, mouse, etc.
• Once we are done taking input, it is a good practice to close the input stream that we opened in order to avoid risks and free some memory.
• We use sc.close(); to close the input stream.
• After the input stream is closed, we can not take any more inputs unless we open the input stream again by creating a new object of the scanner class using the statement Scanner sc = new Scanner(System.in).

Outputs in JAVA

• To print anything in JAVA we use the syntax System.out.println("Hello, World!");
• System here is an in-built class that is written by those who have created JAVA.
• . is used to access the contents inside a class of a package which we have already covered in the inputs in the JAVA section.
• "out" is a variable inside the class System which is of type PrintStream.
• PrintStream is basically used for printing data.
• Simply put, "out" is just like a reference variable of PrintStream (don't stress too much on this part but just have an idea of what it is).
• "println" is a method inside "out" and we access this method using the command System.out.println("").
• Inside the brackets of System.out.println(""), we have "" and anything we type inside these "" will be printed as it is.
• This is how we print anything we want in JAVA.
• Now, there is another method named print and there is a slight difference between print and println.
• The difference between print and println is that when we use System.out.print(""), anything we type inside the "" will be printed in a single line and the cursor pointer stays there where the printing has stopped but when we use System.out.println(""), anything that we print inside the "" will be printed and after printing what we want it to print the cursor pointer will move to the next line so the next time when we try to print something it will print from the next line.

This is all you need to know about input and output as of now.

Now that you know about how we can take input from the user and print the output to be displayed on the screen, we can jump on to the data types in a JAVA program in the next blog.

Let me know comments down below if you like what you read or have some suggestions for me and make sure to follow me on all my social handles to stay connected. Links are on the top-right corner of this page and if you want to get started with JAVA for the first time then you can hop back to my very first blog of this series.

To get started, we will need to install JAVA and an IDE or a code editor. If you have not done the prerequisites before starting out then follow the instructions given in this blog.

Hello, World!

We will finally learn how to write our first JAVA program. But first, let's learn about the structure of a JAVA program.

A package is simply the folder where your JAVA program is located.

Structure of a JAVA program:

• Every file that is with an extension of ".java" is a class itself.
• Class is basically a named group of properties and functions (we will cover this topic in detail in later blogs).
• The class name will always be the same as the file name.
• So, if we create a file named "Main.java", then it will have a class named "Main" (Class names always start in capital letters for good practice).
• We will write our code inside this "Main" class.
• The "Main" class will be a public class.
• The "public" here, is an access specifier that deals with the privacy or access of the code.
• This "public" means the class can be accessed from anywhere (covered in a later blog so do not stress this too much).
• Any code that we write inside a class or a function has to be enclosed within the curly braces ({})
• This is how a class is written:

    public class Main{
    }
  

• Inside this class, we will have to create a "main" function.
• The name "main" is important. It is a reserved word.
• The reserved words of any programming language can only be used where it is required and cannot be randomly used anywhere.
• The functions created inside classes are also called methods.
• This "main" function denotes the starting point of the program.
• Without the "main" function the program will not run.
• A function is just a collection of code that we can reuse later.
• This is how the main function is written inside the class:

    public class Main{
        public static void main(String[] args){
        }
    }
  

  Main Function Breakdown:

• Although the entire main function syntax will be explained in detail in a later blog, I will still cover what these words represent.
• "public" here is the access specifier.
• When a JAVA code is compiled, an object is created for every variable and function that we have in the class.
• When we know that the main function is the entry point of our program and nothing runs before that, we need to run it without creating an object.
• We will not create an object of the main function.
• We have also read in the previous blog that the static variables and functions do not depend on the objects.
• Simply put, objects will not be created for any function that has static in their declaration.
• So, we have used static here because we do not want the object to be created for the main function.
• The keyword "void" here is the return type of the function.
• The return type is the type of data we want to return from the function (type of data or the data types will be covered in the next blog).
• Simply put, whenever a function will stop executing, it will give some value and we do not want this main function to give any value.
• "main" is a keyword here and we have discussed this in the above-mentioned points.
• "String[] args" is an array of String data type.
• An array is a collection of the same type of data (covered later).
• "args" is the name of the variable given to the String type array. We can use anything in place of "args".
• This "String[] args" array is used to store the command-line arguments or the input that we provide to the program while running it through the terminal window.
• This, as a whole is the complete structure of a JAVA program.
• Now, following this structure, we can write our first JAVA program.
• This is our first JAVA program.

    public class Main{
        public static void main(String[] args){
            System.out.println("Hello, World!");
        }
    }
  

• "System.out.println("");" prints anything that we provide within the quotes.

Now that you know about the structure of a JAVA program and have written your first program, we can jump on to inputs and outputs in a JAVA program in the next blog.

Let me know comments down below if you like what you read or have some suggestions for me and make sure to follow me on all my social handles to stay connected. Links are on the top-right corner of this page and if you want to get started with JAVA for the first time then you can hop back to my very first blog of this series.

Before deep-diving into the JAVA architecture, let me first make you familiar with some of the new JAVA-specific technical jargon.

• JDK stands for JAVA Development Kit. It contains the JRE and some development tools.
• JRE stands for JAVA Runtime Environment. It contains the JVM and some library classes.
• JVM stands for JAVA virtual machine. Yes, this is the same JVM about which you read in this blog. It contains the JIT.
• JIT stands for Just In Time compiler.
• A hierarchal representation of the above-mentioned components can be pictured like this:

What is a JDK?

• JDK stands for JAVA Development Kit.
• JDK is a package (a set of files) that we can download from the internet.
• It provides an environment to develop and run JAVA programs.
• It contains the JRE which is used to run a JAVA program.
• It contains a compiler called javac. Yes, this is the same compiler you read about in this blog.
• It contains an archiver called jar which is used to archive our files.
• It contains a Javadoc to generate docs.
• It contains an interpreter and loader which is used to interpret and load files.
• This means that if we want to build an application, we will need the JDK because it contains all the required files and libraries required to build and run an application.

What is JRE?

• JRE stands for JAVA Runtime Environment.
• Architecturally, it exists inside the JDK.
• It is an installation package (a set of files) that provides an environment to only run the program.
• It consists of:
  1. Deployment technologies
  2. User interface toolkits
  3. Integration libraries
  4. Base libraries
  5. JVM
• After we get the ".class" file from the compiler, the next steps take place during the runtime inside the JRE.
  1. The class loader loads all the classes needed to execute the program.
  2. JVM sends the entire code (.class file) to the byte code verifier to check the format of the code.

What happens during compile time?

• The ".java" file (source code) is passed on to the compiler (javac) where it gets compiled and generates a ".class" file (byte code).
• The next step takes place during the runtime.

What happens during the runtime?

• The JVM has a component called the class loader which works in 3 steps.
  • Loading:
    1. It will read the ".class" file and generate binary data of that file.
    2. An object of that file is created in the heap memory (we have read that objects of classes are created in the heap memory).
    3. In simple terms, all the required files will be loaded into the heap memory.
  • Linking:
    1. JVM verifies the ".class" file for any errors.
    2. It will allocate memory to the class variables and default values declared in the code.
    3. It will replace the symbolic references from the type with direct references.
    4. This means in our code, whatever variables that we have declared and the values we have assigned to those variables will be linked to each other respectively.
  • Initialization:
    1. All the static variables are assigned with their values defined in the code and static block (if there is any static block).
    2. Static variables are the variables that do not depend on the objects of the classes. In other words, these variables are object-independent (do not worry if this confuses you. We will cover this in later blogs in detail but for now just try to get a basic idea).

JVM contains the stack and the heap memory allocations.

What happens during the JVM execution?

• The JVM has a built-in interpreter that reads the ".byte" code line by line and executes it.
• When one method is called multiple times, the interpreter should interpret the same method again and again but this is not a very efficient way. So, to solve this issue the JVM has a runtime compiler called the just-in-time compiler.
• The JIT compiler directly provides machine code for any method that is called multiple times and so those methods are not interpreted again and again.
• JIT makes the execution of code faster.
• Garbage collection also hits during this step of JVM execution. Pictorial representation of everything you've read so far.
• So, to sum it up in just five steps,
  1. The JAVA source code or the code you write, goes into the JDK.
  2. The JDK then compiles the code ".java file" using the javac compiler into the byte code ".class file".
  3. This byte code goes into the JVM where it gets converted into an executable code.
  4. The executable code then goes into the JRE where it runs.
  5. The result is then displayed on your computer screen.

JVM vs JRE:

• JRE can just be thought a box-like structure.
• JVM is the actual content inside the box.
• The work done by JVM is done with the help of JRE.
• Whatever files, libraries, and everything that JVM needs are provided by the JRE.
• So, in short, JRE is JVM plus some extra files.

Now that you know about the architecture of JAVA, we can finally jump on to writing our first JAVA program in the next blog.

Let me know comments down below if you like what you read or have some suggestions for me and make sure to follow me on all my social handles to stay connected. Links are on the top-right corner of this page and if you want to get started with JAVA for the first time then you can hop back to my very first blog of this series.

Now, let's talk about how a JAVA program executes.

When we write code, it is in a human-readable format that is not understood by the computer. The computer only understands 0s and 1s and nothing else except for these two values. It is practically impossible for us to write code purely in 0s and 1s so, for that purpose we use a programming language. The code that we write goes through some kind of processing in the back-end which then gets converted into machine-readable code before it gets executed.

JAVA is a platform-independent language.

What happens when a JAVA code is executed?

• All the JAVA code that we will write will get saved with an extension of ".java". This file is in a human-readable format. This file is also called the source code.
• This ".java" file is sent to the compiler for further processing.
• A compiler is the software that converts the source code into the machine code(0s and 1s) in one go.
• The JAVA compiler converts this ".java" file to a ".class" file. This file is also called a byte code which is specific to JAVA.
• Byte code is an intermediate language of JAVA.
• This file will not directly run on a system but we need a software called JAVA Virtual Machine also known as JVM (will be covered in detail in the next blog).
• JVM with the help of an interpreter will interpret this byte code line by line and convert it into the machine code (0s and 1s).
• An interpreter is software that that converts the source code into the machine code line by line.
• The machine code is then finally executed.
• Because of the existence of byte code, JAVA is a platform-independent language.

  What is platform independence?

• Platform independence means that the program/software can be executed on any platform or operating system in existence.
• We need to convert the source code into the machine code so that the computer can understand it.
• Compiler does this by converting the source code into an executable code.
• This executable code is a set of instructions for the computer.
• In other programming languages, after compiling we get is an executable code that is platform dependent but in the case of JAVA, we get a byte code that is platform independent.
• This byte code (.class) file can run on all operating systems.
• JVM converts this byte code into the machine code (executable code).
• JAVA is platform-independent but JVM is platform dependent which means that we need to download JVM for the respective operating system that we want it to run on.

Now that you know how a JAVA program executes, we can jump on to the architecture of JAVA in the next blog.

Let me know comments down below if you like what you read or have some suggestions for me and make sure to follow me on all my social handles to stay connected. Links are on the top-right corner of this page and if you want to get started with JAVA for the first time then you can hop back to my very first blog of this series.

Flowchart

Every piece of code that we write, follows five key steps that make that program complete. These key steps are also known as flowcharts. A flowchart is a tool to visualize our thought process. It can be used to code even the most complex programs too. It is used by representing with symbols what steps to take to achieve a particular goal. A flowchart has five important steps:

• Start/Stop: The program will start and end. This step is represented by an oval shape.
• Input/Output: The program would take some input and display an output. This step is represented by a parallelogram.
• Processing: The program will process some information while executing. This step is represented by a rectangle.
• Condition: The program will have to make some decisions to achieve a particular goal. This step is represented by the rhombus.
• Flow of direction of the program: This denotes the direction in which the program will execute. This step is symbolized by an arrow.

This is how it looks graphically.

To understand this even better, let me explain this to you with the help of an example. Let's say that we want to take an input "salary" and if the salary is greater than 10,000, we add a bonus of 2000 otherwise we want to add a bound of 1000. How will we do this in terms of a flowchart? Well. here's the answer:

• Our program will start (oval).
• We will take input of salary (parallelogram).
• We will check if the salary is greater than 10,000 which means we will add a condition in our program (rhombus).
• Depending on the fact that if the condition is being satisfied or not, we will add 2000 or 1000 to our salary input which means that we are processing our input here (rectangle).
• After the processing step is complete, we will print the final answer which means that we are displaying an output (parallelogram).
• Once all the required steps are completed, our program will stop (oval).

  Pseudocode

  A basic but very important concept of computer science is pseudocode. This is another way of representing the steps we need to take to complete a particular task. When we want to share the algorithm (steps involved to complete a task) of our code and don't care much about the syntax during this process of sharing, we only care about explaining what the algorithm for the code is and how it functions, we use pseudocode. Pseudocode can be thought of as a rough code common for all programming languages. This is what the pseudocode for the above example will look like:

• We start the program.
• We take input.
• We check the condition if the salary is greater than 10,000 using the if (I will cover this later in a separate blog) keyword.
• Next step will be adding the bonus of 2000 to our salary input which will occur inside the if condition only if the condition is satisfied so, we have left a tab space to represent it clearly.
• If the above condition is not satisfied, we use the else keyword to display the alternate steps to take which will occur inside the else condition so we have left a tab space for that too.
• Basically, whatever steps take place inside any condition or loop has to be displayed by leaving a tab space so that it is evident what steps are taking place inside those conditions or loops.
• After the processing part is done we simply output the salary.
• We stop our program.

This was a gist of how the flow of control of a program works and how we can represent the steps we will take to complete the given task via flowchart and via pseudocode. Although I have tried to keep things as simple and detailed as possible but for even more detailed information you can watch this video and you will get a very clear idea of these topics. In the next blog, I will try to cover how a JAVA program executes so, hang on tight!

Let me know comments down below if you like what you read or have some suggestions for me and make sure to follow me on all my social handles to stay connected. Links are on the top-right corner of this page and if you want to get started with JAVA for the first time then you can hop back to my very first blog of this series.

In the world of programming, there are two types of memories that majorly play their part when we throw any piece of code into our computer systems i.e. stack memory and heap memory.

Stack Memory

• A stack memory is a contiguous block of memory (I will cover this later in a separate blog so don't worry too much about it but just try to get an idea of what it is).
• The size of memory to be used for a particular program is decided by the compiler.
• You can picture a stack memory like a pile of books placed on top of each other.

  Heap Memory

• A heap memory is used to store the objects that are created during the execution of a program.
• You can picture a heap memory as a big bubble that stores the objects to the references that are stored in the stack memory (confused right? Don't worry I've got you!).

  How do the stack and the heap memory work together?

• In programming languages, we declare and initialize variables to use them later in the program.
• This int n = 10; is how we declare and initialize a variable in the JAVA programming language (I will cover more on this later in a separate blog but for now just try to follow along without getting too much into the syntax).
• Now here, "int" is the data type of any variable that we declare.
• "n" is the name of the variable. It is actually called a reference variable. We can give any name we want but for now, let's just keep it simple.
• "=" is the assignment operator used to assign values to the reference variables.
• "10" is the value assigned to the variable n but this value "10" is actually an object of the reference variable "n".
• The reference variables that we declare are created inside the stack memory.
• The objects that we initialize for these reference variables get stored inside the heap memory at a random memory location.
• Every location in the heap memory has a unique address.
• The reference variables point to their corresponding objects stored at some unique memory address.
• Now when we ask the computer by writing some relevant piece of code to display the value of "n", it checks which object is the reference variable pointing to and displays the result as "10";
• To give you a pictorial representation of things I just talked about here's what things look like:

• Now just like the reference variable "n", we can have multiple other reference variables with the same value as that of "n".
• In this case, if the compiler goes on and allocates multiple heap memory locations to every other variable with the same value, the system will crash or in other words, we will get some kind of overflow error.
• What actually happens is that if we create multiple variables with the same value or same objects then all those different variables will point to a single object in the heap memory because all the variables have the same value.
• For example: int n = 10; int m = 10; int x = 10; all these variables will point to a single heap memory location where the object "10" is stored.
• To make this even more understandable and simple, let's say my name is Joy but my brother calls me bro, my mother calls me son and my dog calls me woof.
• Now if my brother says bro I will hear, if my dog says woof I will hear and if my mother says son then also I will hear.
• So, multiple variables (mother, brother, dog) can have the same object (me) and different objects with the same values (me) will not be created.
• Any changes made to the object by any of the reference variables, the object will change for all the other variables too since all the variables are still pointing to the same object.
• For example, if my mother asks me to shave my head bald, my dog, my brother, and my mother, all of them will be able to see my clean shaved bald head since all of them are pointing towards the same object (me).

  Garbage Collection

• Garbage collection is a way to free the computer's memory (I will cover this in detail later but for now, I'll just give you an idea about what it is).
• Let's consider this scenario, my name is Joy and I have a girlfriend (right now the ref variable girlfriend is pointing towards Joy). She met a new guy named pig whom she started dating and dumped me(now the ref variable girlfriend is pointing towards the new variable "pig"). Because my girlfriend dumped me I got very depressed and decided to leave this materialistic world and forsake my name and become a monk. After some time since I have no name (no ref variable pointing towards me), I will be forgotten and removed from the memory of those who knew me as Joy.
• Any object that does not have a reference variable pointing towards them, will be removed from the memory when garbage collection hits.
• Garbage collection hits automatically.
• To give you a pictorial representation of things I just talked about here's what things look like:

Now that you know about how memory is managed under the hood, we can move on to the next topic in the next blog and learn about how a program flows from one step to another and we will also learn about decision making in a programming language. So, hang on tight!

Let me know in the comments down below if you like what you read or have any suggestions for me and make sure to follow me on all my social handles to stay connected. Links are on the top-right corner of this page.

Types of Programming Languages:

Everything that our computers work on is just a bunch of 0s and 1s. So any instruction that we pass to our computer with some clicks and taps from our keyboard and mouse gets converted into a bunch of 0s and 1s internally in order for the computers to understand what we actually want it to do. Now there are various ways in which these instructions can be passed on to the computer. Depending on how these instructions are passed on to the computer, programming languages can be classified into three types i.e. Procedural, Functional, and Object-Oriented.

Procedural Programming Language:

• This language specifies a series of well-structured steps and procedures to compose a program.
• It contains a systematic order of statements, functions, and commands to complete the given task.

Functional Programming Language:

• In this type of language, we aim to write programs only in terms of pure functions (don't worry about it if you don't know about functions. I will cover it later in a separate blog). This means that don't modify any variable but only create new ones as an output.
• The basic idea behind a functional programming language is to bundle the piece of code inside a function and reuse the same function instead of writing the same thing over and over.

Object-Oriented Programming Language:

• This type of language revolves around objects.
• I will cover objects later in a separate blog too but just to give you an insight or an intuition about what object-oriented programming looks like, it's just some code and data all wrapped up together in one (code + data = object).
• This paradigm of language was developed to make it easier to develop, debug, reuse and maintain any software.

Apart from the fashion in which the instructions are passed, a programming language can also be classified into another type which determines how a programming language is typed.

Statically Typed:

The rules followed by statically typed language are:

• Type checking is performed at compile time.
• Errors will show at compile time.
• Declare the type of data for the variable before initializing and using it in the code. Compilation means the conversion of human-readable code to machine-readable code and compile-time means during the process of compilation.

  Dynamically Typed:

  The rules followed by dynamically typed language are:
• Type checking is done at runtime.
• Errors will show at runtime.
• No need to declare the type of data before initializing and using it in the code. Runtime means during the time when the program is finally running after compilation is done.

Now that you know about the types of programming languages, we can move on to the next topic in the next blog which is "memory management in programming languages" so hang on tight! we are just getting started.

Let me know in the comments down below if you like what you read or have any suggestions for me and make sure to follow me on all my social handles to stay connected. Links are on the top-right corner of this page.

Learning your first programing language can be quite a challenging task when you are just starting out to build your career in tech. When I started learning to code I started with python programing language because it has a very simple syntax and is easy to pick up but also because I never understood JAVA and its complicated syntax, because we have to write so many lines of code just to write a simple hello world program. Here's an example of a simple "Hello World!" program in JAVA and python just to give you an idea of the syntax for both the language:

Python:

JAVA:

Did you see that? How easy it is to write code in python compared to JAVA. Just one single line printed our "Hello World!" in python whereas JAVA needs 8 freaking lines for the same thing. Then why do we need JAVA or other languages with such lengthy and complicated syntax and why not python or some other programing language which has such simple syntax like python? The answer to this question is that every single language or technology that has ever been created solves a real-life problem but none of those technologies are perfect. So to improve on the previous or outdated tech new tech is being created all the time and so today, we have numerous different programming languages and technologies, each of them serving its own purpose to help in solving some or the other real-life problem.

Knowing the fact that it gets so overwhelming to understand the whys and why nots while learning any programing language, I will share what I have learned so far while learning JAVA by breaking down my knowledge of every concept involved in this language through these blogs so that it gets easier for others to understand the underlying concepts.

I am also sharing the resource from where I am learning so that you can refer to it too and trust me you'll this is one of the best resources out there over the internet. The JAVA DSA Playlist by Kunal Kushwaha If you want to practice what you are learning then you can refer to this GitHub repository by Kunal Kushwaha:. This has some amazingly organized topic-wise LeetCode questions for interview perspective. You will also need a good code editor to practice what you are learning. There are plenty of code editors out there but for JAVA it is recommended to use the IntelliJ idea which you can download from this link here or if you want to use an online code editor then repl.it would be your go-to online IDE. If you choose to use an offline code editor then you will have to install JAVA so make sure you do that too.

Sit tight once you are done setting up your work environment and we will get started from the very next blog.

Let me know in the comments down below if you like what you read or have any suggestions for me and make sure to follow me on all my social handles to stay connected. Links are on the top-right corner of this page.

Before I start let me give you a brief introduction about myself. I'm Joy, extremely lazy, hate maths, failed in 6th standard, repeated 9th standard, being extremely demotivated by someone; I opted for commerce, dropped commerce after a month, opted for science, again failed in 11th standard. I couldn't clear any of the competitive exams because I'm not that good with maths but getting 11 marks in exams like IIT Entrance felt like an achievement to me.

After much struggle somehow I got into a college named ABESIT, Ghaziabad. Starting from the first year I started studying hard so that I could pass my semester exams. I had to cram up most of the things because of numerical and mathematical questions since I didn't understand math and nor did I do up till today's date. Even after studying so hard, I got my first backlog in the first semester itself and then this process of getting and clearing backlogs continued like some kind of tradition. Every semester I had a couple of backlogs that I had to clear later in the next semester.

"When you know things it'll be easier for you to do."

I took costly coaching for learning java programming language when I was in 10th standard because I did not understand even a single line of code back then. But later since I knew and understood coding a little bit I took computer science in my intermediate school as well but didn't write a single line of code the whole year until my exams were on my head. This made me realize that I've forgotten everything I learned so I took up the same costly coaching again but this time I did not understand coding even after the coaching classes but somehow managed to clear my board exams.

During my time in college, I took part in some coding events in the college club, and a hackathon where my role was just to fill the space for a team member and did not code at all in the event. All these events took place when I was in the odd semester of my third year and because of the tension of clearing my backlogs and my exams, I stopped coding. I had no one to guide me on what should I do, how should I clear my backlogs or how should I clean up the mess that I made of my life. I didn't even think if I'd be able to secure a job from college placements but to my surprise, I was able to crack the placement offers for two companies. Let's say one of them was company 'X' and the other one was company 'Y'.

When my exams were almost over, someone called me from the company 'Y' and mentioned that I'll have to join the office from X date and further information would be provided in another couple of days. After my exams were finally over, I kept calling the company folks but ended up with no response at all. So I finally decided to join company 'X'.

During the onboarding process, I was told that the process in which I will be in has a semi-technical job and it will not involve picking up calls but later when I went to the work location I found myself picking up calls mostly from ridiculously brain-dead Indian customers who kept buying tech from a particular brand which they knew is gonna break and its repair would cost them double the purchase amount. Many of those customers had already received warnings regarding the product from their friends and relatives but still bought the product anyway and later call us up to abuse how pathetic the product was.

I was literally being abused on the job every single day and not only this those brain-dead customers used to call during the nighttime and demanded that their devices be taken on remote connection and once done they'd flash their nudes through the device camera. Some of them used to get drunk and call us just to entertain themselves with ridiculous questions and uncomfortable topics.

Despite all of this nonsense, I had gotten too comfortable with the work environment there and somewhere in my mind, I made myself believed that coding was not for me. Coding was hard and one needed to be really good to be coding for any company. I disqualified myself from coding. After working there for seven months, I got to know that the process for which I was working in company 'X' was shutting down. I took advantage of this situation and went for a job change because I was earning just Rs 10,000 per month and my room rent was Rs 2,000 more than my salary. I joined the company 'Z' which, again was a call center but at least I was not being abused there by brain-dead customers but the work there, I didn't understand at all.

"You are whom you surround yourself with."

I started working here picking up calls every single day just to earn Rs 25,000 per month. While I was working, I had a good friend who was a mechanical engineer and jobless at the same time since the mechanical industry had completely collapsed. He started learning to code since there's a lot of money and life with code just gets better and better. This made me think if a mechanical engineer can shift his career to coding, well, I was from the Information Technology branch so I could do it too.

NOTE: Read my remaining journey in Part - 2 of this blog from the link here: My journey from being a failure to a software developer