DEV Community: Poushmita Paul

☁️ Day 3 — My First Steps in AWS: IAM, Regions, Billing, Free Tier & Security

Poushmita Paul — Tue, 01 Sep 2026 11:17:09 +0000

In my previous cloud computing articles, I was mainly learning the concepts and theory.

But today, I started moving from:

“What is cloud computing?”

to:

“Okay, how do I actually start using AWS?” 😄

And while doing that, I realized that there are some basic things I should understand before creating EC2 instances, databases, or other cloud resources.

So, in today's learning, I explored:

Creating an AWS account
Root User vs IAM User
IAM Groups & Permissions
AWS Regions
Metered Billing
AWS Budgets
AWS Free Tier
Free Tier Usage Alerts
Billing Alarms
MFA

I found these topics quite important because when we are beginners, we usually focus only on creating resources.

But there is another question we should ask:

“How do I use AWS safely without accidentally losing money or compromising my account?”

So let's understand everything step by step. 👇

🟢 1. Creating an AWS Account

The first step is obviously creating an AWS account.

When we create an AWS account, AWS asks for our basic information and a payment method.

But there is something important I learned here.

The account that we create initially has a Root User.

And the Root User is not just an ordinary login account.

It has very high-level access to the AWS account.

So my first thought was:

“If this is my AWS account, can't I just use this account for everything?”

But that's not a good practice.

Instead, we should create another user for our regular AWS activities.

And this is where IAM comes in.

📸

🔐 2. What is IAM?

IAM stands for:

Identity and Access Management

I understood IAM as the system that helps us answer three simple questions:

Who are you?
      ↓
What are you allowed to access?
      ↓
What are you allowed to do?

For example, imagine a company has 10 people using AWS.

Do we want all 10 people to have complete access to everything?

Probably not.

Maybe one person works with EC2.

Another person works with S3.

Another person manages databases.

And maybe only one or two people should have administrator-level access.

IAM helps us control these permissions.

So instead of giving everyone the “key to the whole house”, we can give them access only to the rooms they actually need. 😄

👑 3. Root User vs IAM User

This was one of the most important things I learned today.

👑 Root User

The Root User is the highest-level identity associated with the AWS account.

It has very powerful permissions.

Because of that:

⚠️ We should not use the Root User for normal everyday activities.

Instead, we should create an IAM User and use that for our regular work.

I found it easier to remember like this:

AWS Account
    │
    ├── 👑 Root User
    │       └── Highest-level access
    │
    └── 👤 IAM Users
            ├── Developer
            ├── Admin
            └── Other Users

So the basic idea is:

Root User → Keep it protected and use it only when necessary

IAM User → Use it for normal AWS activities

The IAM setup also allows us to provide console access to the user we create.

📸

👥 4. IAM Groups & Permissions

While creating an IAM User, I also came across Groups.

Instead of assigning permissions separately to every user, users can be organized into groups.

For example:

Admin Group
     ↓
Administrator Permissions
     ↓
Admin Users

Or:

Developer Group
     ↓
Development-related Permissions
     ↓
Developer Users

One thing that stood out to me was that Administrator access is very powerful.

So we shouldn't simply give administrator permissions to everyone.

A better approach is:

Give a user only the permissions they actually need.

This makes the account easier to manage and also improves security.

In simple words:

More permission ≠ Better

Instead:

Required permission = Better

This idea is often called the principle of least privilege — giving only the access that is actually required.

🌍 5. What is an AWS Region?

After understanding IAM, I came across another concept that is very important when working with AWS:

AWS Regions

When we open the AWS Management Console, we can see a selected region.

For example:

US East (N. Virginia)

But what exactly is a Region?

A simple way I understood it is:

An AWS Region represents a geographic location where AWS has infrastructure for providing cloud services.

AWS has multiple regions around the world.

So when we create certain resources, we need to know which region we are creating them in.

📸

🤔 Why should I care about Regions?

Suppose I create an EC2 instance in:

US East (N. Virginia)

Then later I accidentally switch my AWS console to another region.

Now I open EC2 and don't see my instance.

My first reaction might be:

“Where did my EC2 instance go? 😐”

But the instance hasn't disappeared.

I'm simply looking at a different region.

This is something I think beginners can easily get confused about.

So whenever you're following an AWS tutorial and suddenly can't find a resource:

First check your selected AWS Region.

This is a small thing, but it can save a lot of confusion later.

🌎 6. Regional vs Global Services

This was another interesting point I learned.

Not every AWS service behaves in exactly the same way with regions.

For example, EC2 resources are associated with a region.

If I create an EC2 instance in one region, I shouldn't expect to see that same instance when I switch to another region.

Conceptually:

Region A
   ↓
EC2 Instance

Switch to:

Region B
   ↓
The EC2 instance created in Region A
may not appear here

But some AWS services have a global scope.

The examples I came across while learning were:

CloudFront
S3

So one thing I want to remember is:

Before creating or searching for an AWS resource, understand whether that service is regional or global.

📸

💰 7. AWS Uses Metered Billing

Now comes the part that I think every AWS beginner should pay attention to:

💸 Billing

One major advantage of cloud computing is that we don't necessarily have to purchase and maintain physical servers ourselves.

Instead, we can use cloud resources and pay according to our usage.

This is called metered or usage-based billing.

I understood it like this:

Use a resource
      ↓
AWS measures the usage
      ↓
You are charged based on the usage

This can be great because we're not necessarily paying for a huge infrastructure setup upfront.

But...

There is a dangerous side too. 😅

If we create a resource and forget to stop or delete it, the cost can continue increasing.

So cloud gives us flexibility, but it also gives us responsibility.

⚠️ Always keep an eye on what resources you are running.

😨 8. The AWS Bill Can Surprise You!

There was a practical example in the learning material that made this point very clear.

A resource was created for testing, but the selected configuration was more expensive than what was actually needed.

The important lesson here isn't really about that particular AWS service.

The lesson is:

Don't blindly click “Create”.

Before creating a resource, check:

What type of resource am I creating?
What configuration am I selecting?
Is there a cheaper option?
How much could it cost?
Do I actually need to keep it running?

Think about this:

Small hourly cost
       ↓
Running for many hours
       ↓
Running for many days
       ↓
💸 Unexpected bill

Even a small amount can become significant when a resource keeps running.

So now I want to build a habit:

Before creating a resource, check the configuration and the possible cost.

📸

📊 9. AWS Budgets — My First Cost Safety Net

After learning about unexpected spending, naturally my next question was:

“How can I keep track of my AWS spending?”

One option is AWS Budgets.

AWS Budgets allows us to define a budget and monitor our spending against it.

For example, suppose I decide:

Monthly Budget
      ↓
     $100

Now I can monitor things such as:

Actual Cost
     +
Forecasted Cost
     ↓
Compared with Budget

We can also configure alerts.

For example:

Budget = $100

80% reached
     ↓
📧 Send Alert

So before the spending becomes a bigger problem, I can get a notification.

This is something I would definitely configure while experimenting with AWS.

📸

🆓 10. What is the AWS Free Tier?

Another thing I learned today was the AWS Free Tier.

When we are beginners, this is obviously interesting because we want to experiment with AWS without spending a lot of money.

The Free Tier provides certain AWS services with free usage under specific limits and conditions.

And here I want to highlight one important word:

Conditions

Because:

❌ Free Tier does NOT mean everything in AWS is completely free.

Different services can have different:

Usage limits
Time periods
Eligibility conditions
Resource types

So before using a service, we should check exactly what is included.

For me, the easiest way to remember it is:

Free Tier = Free usage within specific rules and limits

Not:

Free Tier = Everything is free ❌

📸

📌 11. Free Tier Usage Alerts

While learning about the Free Tier, I also learned that we can enable Free Tier usage alerts.

This is useful because AWS usage can increase without us realizing it.

The basic idea is:

AWS Usage
    ↓
Approaching Free Tier Limit?
    ↓
📧 Email Alert

So instead of manually checking everything all the time, we can receive an alert when our usage is approaching or exceeding the relevant Free Tier limits.

For someone learning AWS, I think this is a very useful safety feature.

It gives us one more way to keep track of our usage while experimenting.

🚨 12. Billing Alarms with CloudWatch

Another way to monitor our AWS spending is through CloudWatch billing alarms.

I understood the basic idea like this:

AWS Cost
   ↓
Crosses a threshold
   ↓
CloudWatch Alarm
   ↓
📧 Notification

For example, I could set a threshold of:

$50

If the monitored cost crosses that threshold, the alarm can move into an alarm state and trigger a notification.

This gives us another layer of protection.

📸

🔔 13. Where does SNS come into this?

While setting up the billing alarm, I also came across SNS.

SNS stands for:

Simple Notification Service

I found it easier to understand SNS as a service that helps send notifications.

For example:

Billing Alarm
      ↓
     SNS
      ↓
📧 Email Notification

So if an alarm is triggered, SNS can help send the notification to the configured destination.

I don't need to understand everything about SNS right now.

For now, I just want to remember:

SNS = Notification Service

🔐 14. MFA — One More Layer of Security

Finally, we come to something very important:

MFA — Multi-Factor Authentication

Suppose someone somehow gets my password.

Does that automatically mean they should be able to access my AWS account?

With MFA enabled, there is an additional verification step.

So instead of:

Password
   ↓
Access

we have:

Password
   +
MFA Verification
   ↓
Access 🔐

For example, we can use a virtual MFA application on our phone.

The application generates a temporary code which changes periodically.

During login:

Enter Password
      ↓
Enter MFA Code
      ↓
Access AWS 🔐

There are also hardware security keys that can be used for MFA.

But the important lesson for me is not which option I use.

The important lesson is:

MFA should be enabled, especially for the AWS Root User.

🧠 What I Learned From Day 3

If I had to summarize today's learning in one flow, I would write it like this:

Create AWS Account
        ↓
Protect Root User
        ↓
Create IAM User
        ↓
Understand Permissions
        ↓
Understand AWS Regions
        ↓
Check Resource Configuration
        ↓
Monitor AWS Spending
        ↓
Set AWS Budget
        ↓
Monitor Free Tier
        ↓
Set Billing Alerts
        ↓
Enable MFA 🔐

And honestly, these may look like small topics.

But I realized that they are actually the foundation for using AWS properly.

Because learning AWS isn't only about:

“How do I create an EC2 instance?”

It is also about:

“How do I create it safely, in the correct region, with the correct permissions, while keeping an eye on the cost?”

💡 My Biggest Takeaway

The biggest thing I learned today is:

Before learning how to build on the cloud, I should first learn how to use the cloud responsibly.

As a beginner, I don't want my first AWS experience to be:

“I created something for practice.” 😄
              ↓
“I forgot to delete it.” 😐
              ↓
“Why is my AWS bill so high?” 😭💸

So from now on, whenever I create an AWS resource, I want to get into the habit of checking:

✅ Which region am I using?

✅ What exactly am I creating?

✅ Is it within my Free Tier?

✅ How much could it cost?

✅ Do I need to keep it running?

✅ Have I configured billing alerts?

✅ Is my account properly secured?

☁️ Day 3 Complete!

So that's what I learned on Day 3 of my Cloud Computing journey.

Today wasn't about building a big application or launching something complicated.

Instead, I learned the basic AWS setup, security and cost-management concepts that I should know before going further.

I'm learning cloud step by step and sharing what I understand along the way so that someone who is also starting from zero can learn with me. 😊

If you're also learning AWS:

What was the first AWS service you tried?

I'd love to know! 👇

🚀 See you in Day 4!

C++ Operator Overloading Explained from Zero — A Complete Beginner-Friendly Guide with a `Time` Class

Poushmita Paul — Sun, 30 Aug 2026 17:39:50 +0000

A step-by-step guide where we don't just learn what the code does — we understand why every word, symbol, parameter, and line of code is used.

👋 Why I Created This Guide

Recently, a friend asked me to help her understand Operator Overloading in C++ because she was having difficulty understanding it from her training.

When I looked at the code, I realized something important.

The problem wasn't necessarily the Operator Overloading itself.

The problem was that many small C++ concepts were being used together.

For example, a beginner may see:

Time Time::operator+(const Time &t)

and immediately have questions:

❓ Why are there two Times?
❓ What does Time:: mean?
❓ Why is the function called operator+?
❓ What does const mean?
❓ What does & mean?
❓ What is t?
❓ Where did the first object go?
❓ Why do we need temp?
❓ Why are we returning Time?
❓ What is this?
❓ Why does postfix ++ have int?
❓ Why are ostream and istream used?
❓ Why are << and >> used?

If these small questions aren't answered, it becomes very easy to memorize the syntax without understanding the concept.

So in this article, I want to explain Operator Overloading the way I would explain it to a friend sitting beside me.

The goal is not:

❌ "Memorize this code."

The goal is:

✅ "Look at the code and understand why every part is there."

📚 What We Will Learn

By the end of this article, you should understand:

Classes and objects
Operators and operands
Unary vs Binary operators
Operator Overloading
Member operator functions
operator+()
operator-()
operator=()
Prefix ++
Postfix ++
Prefix --
Postfix --
Why postfix operators use a dummy int
this
*this
const
References using &
Return types such as Time and Time&
ostream
istream
operator<<
operator>>
Time addition
Time subtraction
Borrowing
Time normalization
How C++ can be thought of as translating operator expressions into function calls

🧱 Part 1 — Before Operator Overloading

Before learning Operator Overloading, let's understand the object we are going to use.

We will create a class called Time.

1. What Is a Class?

Consider this:

class Time
{
    int hours;
    int minutes;
};

If you've already studied classes, this may look simple.

But let's slow down.

What does `class` mean?

class is a C++ keyword used to create a class.

A simple way to understand a class is to think of it as a blueprint.

Imagine an architect creates a blueprint for a house.

The blueprint describes:

rooms
doors
windows
structure

But the blueprint itself is not the actual house.

Similarly, our Time class is a blueprint.

It tells us:

"A Time object will contain information related to hours and minutes."

Visualize it like this:

             Time
        ┌───────────────┐
        │   BLUEPRINT   │
        │               │
        │    hours      │
        │    minutes    │
        └───────────────┘

2. What Are `hours` and `minutes`?

Inside the class we have:

int hours;
int minutes;

What is `int`?

int is a C++ data type used for storing whole numbers.

For example:

int age = 21;

Here:

int → data type
age → variable name
21 → value

Similarly:

int hours;
int minutes;

means our Time object will contain two integer variables:

hours
minutes

For example:

hours   = 2
minutes = 40

represents:

2 hours 40 minutes

3. What Is an Object?

We have created our blueprint:

class Time
{
    int hours;
    int minutes;
};

But we still haven't created an actual Time object.

To create one:

Time t;

Let's read this from left to right:

Time        t
 ↓          ↓
type       name

Time is the class type we created.

t is the name of the object.

So:

Time t;

simply means:

Create an object named t whose type is Time.

You can visualize it like this:

             Time class
          ┌──────────────┐
          │   blueprint  │
          │              │
          │    hours     │
          │    minutes   │
          └──────┬───────┘
                 │
            create object
                 ↓
          ┌──────────────┐
          │      t       │
          ├──────────────┤
          │    hours     │
          │    minutes   │
          └──────────────┘

4. Class vs Object

This distinction is extremely important.

🟦 Class

A class is the blueprint or definition.

class Time
{
    int hours;
    int minutes;
};

🟩 Object

An object is an actual object created from that class.

Time t;

We can create many objects from the same class:

Time t1;
Time t2;
Time t3;

Visual:

                 Time class
              /      |      \
             ↓       ↓       ↓
          ┌─────┐ ┌─────┐ ┌─────┐
          │ t1  │ │ t2  │ │ t3  │
          └─────┘ └─────┘ └─────┘

All three objects are created from the same class.

They have the same structure, but their values can be different.

For example:

t1 → 2 hours 40 minutes

t2 → 1 hour 30 minutes

t3 → 5 hours 10 minutes

5. Objects Can Also Use Functions

A class can contain variables as well as functions.

For example:

class Time
{
public:

    int hours;
    int minutes;

    void display()
    {
        cout << hours << " hours "
             << minutes << " minutes";
    }
};

Now:

Time t;

creates an object called t.

That object can call the function:

t.display();

This means:

Call the display() function for object t.

Keep this idea in mind.

Later we will see:

t1.operator+(t2);

The same basic idea is involved:

An object can call a member function that belongs to its class.

⚙️ Part 2 — Understanding Operators

Now let's move to operators.

You have already used operators many times.

For example:

int a = 10;
int b = 20;

int c = a + b;

Look at:

a + b

There are three things:

a       +       b
↑       ↑       ↑
operand operator operand

The + is the operator.

a and b are the operands.

6. What Is an Operand?

An operand is the value or object on which an operator works.

For:

10 + 20

the operator is:

and the operands are:

10
20

Visual:

             +
            / \
           /   \
         10     20
         ↑       ↑
      operand  operand

7. What Does the `+` Operator Already Know?

C++ already knows how to use + with built-in data types.

For example:

10 + 20

produces:

C++ already knows rules for operations such as:

int + int
float + float
double + double

But now we have created our own type:

Time

And this creates a problem.

❓ Part 3 — The Problem We Need to Solve

Suppose we have:

Time t1;
Time t2;

and:

t1 = 2 hours 40 minutes

t2 = 1 hour 30 minutes

Now suppose we want to write:

Time t3 = t1 + t2;

What should + do?

C++ knows:

10 + 20

But C++ does not automatically know what this means:

t1 + t2

when t1 and t2 are Time objects.

We need to tell C++ what + should mean for our Time class.

And that is where:

⭐ Operator Overloading

comes in.

8. What Is Operator Overloading?

A simple definition is:

Operator Overloading means giving an existing C++ operator a special meaning when it is used with objects of our own class.

Notice an important point:

We are not creating a new operator.

The operator already exists.

For example:

+
-
=
++
--
<<
>>

We are simply teaching C++:

"When this operator is used with my Time objects, perform this operation."

For example:

t1 + t2

can be made to mean:

Add hours
   +
Add minutes
   +
Convert extra minutes into hours

9. Why Is Operator Overloading Useful?

Without Operator Overloading, we could create a normal function:

Time addTime(Time t1, Time t2);

and then:

Time t3 = addTime(t1, t2);

That works.

But with Operator Overloading, we can write:

Time t3 = t1 + t2;

This looks much more natural.

We are making our custom objects behave more like the built-in types we already know.

🔢 Part 4 — Unary vs Binary Operators

Before writing the operator functions, we need to understand one simple question:

How many operands are involved?

Binary Operator

A binary operator works with two operands.

Example:

t1 + t2;

Visual:

        +
       / \
     t1   t2

There are two operands.

Therefore:

2 operands → Binary operator

Other examples:

t1 - t2;
t1 = t2;

Unary Operator

A unary operator works with one operand.

Example:

++t1;

Visual:

       ++
        |
       t1

There is only one operand.

Therefore:

1 operand → Unary operator

Examples:

++t1;
--t1;
t1++;
t1--;

🧠 Easy Rule

Remember this:

┌─────────────────────────┐
│  2 operands → BINARY    │
│  1 operand  → UNARY     │
└─────────────────────────┘

That's enough to classify the operators we are using.

➕ Part 5 — `operator+()`

Now let's finally overload +.

We want this:

Time t3 = t1 + t2;

to work.

So we define:

Time Time::operator+(const Time &t)
{
    Time temp;

    temp.hours = hours + t.hours;
    temp.minutes = minutes + t.minutes;

    temp.hours = temp.hours + temp.minutes / 60;
    temp.minutes = temp.minutes % 60;

    return temp;
}

Don't try to memorize this.

We are going to take it apart piece by piece.

10. Understanding the Function Header

Look at:

Time Time::operator+(const Time &t)

Break it into parts:

Time        Time::        operator+        (const Time &t)
  ↑            ↑              ↑                   ↑
return      belongs        operator            parameter
 type       to Time        being used           object

Now let's understand every part.

11. The First `Time`

Time Time::operator+

The first Time is the return type.

What is a return type?

A function can produce a result.

For example:

int add(int a, int b)
{
    return a + b;
}

The result is an integer.

Therefore:

int

is the return type.

Our operator function returns:

Time

Why?

Because:

Time + Time

produces another Time.

For example:

     2 hours 40 minutes
   + 1 hour 30 minutes
   -------------------
     4 hours 10 minutes

The result is still a Time.

Therefore:

Time

is the return type.

12. What Does `Time::` Mean?

The symbol:

::

is called the scope resolution operator.

It tells C++ which class something belongs to.

So:

Time::operator+

means:

The operator+ function belonging to the Time class.

Think:

Time
  ↓
class
  ↓
operator+
  ↓
belongs to Time

13. What Does `operator+` Mean?

This part:

operator+

means:

We are defining the behavior of the + operator.

Similarly:

operator-

defines -.

operator=

defines =.

operator++

defines ++.

And so on.

14. Understanding `(const Time &t)`

Now look at:

(const Time &t)

This is the parameter list.

A parameter is information that a function receives.

For example:

int add(int a, int b)

has:

a
b

as parameters.

Our function receives:

const Time &t

Let's understand each piece.

15. What Does `Time` Mean Here?

Look at:

Time t

This means:

t is of type Time.

Remember:

Time t1;

means:

Create a Time object called t1.

Similarly, inside our function:

Time t

means:

t refers to a Time object received by the function.

16. What Does `&` Mean?

Here:

Time &t

the & means reference.

A reference is another name or alias for an existing object.

Instead of creating a completely separate copy of the object, the parameter refers to an existing object.

For our expression:

t1 + t2;

we can think of the call as:

t1.operator+(t2);

Inside the function:

t1
 ↓
current object

t2
 ↓
parameter t

So t refers to the second object.

17. What Does `const` Mean?

Now we have:

const Time &t

const means:

We promise not to modify the object through this reference.

Why?

Because while calculating:

t1 + t2

we only need to read t2.

We don't want addition to change t2.

So:

const Time &t

can be understood as:

"Give me a reference to another Time object. I only want to read it, not modify it."

⭐ 18. Where Did `t1` Go?

This is one of the most important ideas in understanding member operator functions.

Suppose we write:

t1 + t2;

Because operator+ is a member function of Time, we can think of it as:

t1.operator+(t2);

Now everything becomes easier to understand.

t1.operator+(t2)
 ↑              ↑
 |              |
current         parameter
object          t

So:

t1 → current object

t2 → parameter t

Inside the function:

hours

means the hours belonging to the current object.

So we can mentally think:

hours

as:

t1.hours

And:

t.hours

means:

t2.hours

This mental model is extremely important.

🧮 19. Let's Actually Add Two Times

Suppose:

t1 = 2 hours 40 minutes

t2 = 1 hour 30 minutes

We want:

       2 h 40 m
     + 1 h 30 m
     -----------
       4 h 10 m

First we add the hours.

temp.hours = hours + t.hours;

The current object's hours:

t1.hours = 2

The parameter object's hours:

t2.hours = 1

Therefore:

2 + 1 = 3

So:

temp.hours = 3

20. Adding the Minutes

temp.minutes = minutes + t.minutes;

We have:

t1.minutes = 40

t2.minutes = 30

Therefore:

40 + 30 = 70

Now:

temp = 3 hours 70 minutes

But this isn't the normal way we represent time.

We normally want minutes to be:

0 to 59

So we need to convert the extra minutes.

🔄 21. What Is Normalization?

We can call this process normalization.

Normalization simply means:

Convert a value into its proper or standard form.

For example:

3 hours 70 minutes

can be converted to:

4 hours 10 minutes

because:

70 minutes = 1 hour 10 minutes

22. Why Do We Use `/ 60`?

The code says:

temp.hours = temp.hours + temp.minutes / 60;

Suppose:

temp.minutes = 70

Then:

70 / 60 = 1

Because these are integers, this is integer division.

We are interested in how many complete hours are contained inside 70 minutes.

The answer is:

1 complete hour

So:

3 hours + 1 hour
=
4 hours

23. Why Do We Use `% 60`?

temp.minutes = temp.minutes % 60;

The % operator gives the remainder after division.

For example:

70 % 60 = 10

So:

70 minutes

contains:

1 complete hour
+
10 minutes remaining

Therefore:

4 hours 10 minutes

is our final answer.

24. Why Do We Create `temp`?

Look at:

Time temp;

Why are we creating another object?

Because we need a separate object to store the result.

We don't want:

t1 = 2:40

t2 = 1:30

to be changed when we calculate:

t1 + t2

Instead:

        t1                 t2
        │                   │
       2:40                1:30
        \                   /
         \                 /
          \               /
            operator+
                 |
                 ↓
               temp
                 |
                4:10

So:

Time temp;

means:

Create a temporary Time object that we can use to build the result.

25. What Does `return temp` Mean?

At the end:

return temp;

means:

Give the calculated Time object back to the code that called the function.

Remember:

Time t3 = t1 + t2;

The flow is:

t1 + t2
   ↓
operator+()
   ↓
create temp
   ↓
calculate 4:10
   ↓
return temp
   ↓
t3 receives the result

So:

t3 = 4 hours 10 minutes

🔍 26. Complete `operator+()` Flow

The expression:

Time t3 = t1 + t2;

can be mentally understood as:

Time t3 = t1.operator+(t2);

Then:

t1
 ↓
current object

t2
 ↓
parameter t

operator+
 ↓
create temp
 ↓
add hours
 ↓
add minutes
 ↓
convert extra minutes
 ↓
return temp
 ↓
t3

If this flow is clear, you already understand the core idea of Operator Overloading.

➖ Part 6 — `operator-()`

Now let's understand subtraction.

Time Time::operator-(const Time &t)
{
    Time temp;

    temp.hours = hours;
    temp.minutes = minutes;

    if (temp.minutes < t.minutes)
    {
        temp.hours--;
        temp.minutes = temp.minutes + 60;
    }

    temp.hours = temp.hours - t.hours;
    temp.minutes = temp.minutes - t.minutes;

    return temp;
}

Most of this is already familiar.

The main new idea is:

Borrowing

27. Why Is `-` Binary?

Look at:

t1 - t2;

There are two operands:

t1     -     t2
↑            ↑
operand    operand

Therefore:

- is a binary operator.

28. Why Do We Need Borrowing?

Suppose:

t1 = 3 hours 20 minutes

t2 = 1 hour 40 minutes

We want:

3 h 20 m
-1 h 40 m

But:

20 - 40

doesn't give us a valid positive minute value.

So we borrow one hour.

Remember:

1 hour = 60 minutes

Therefore:

3 hours 20 minutes

becomes:

2 hours 80 minutes

Now:

80 - 40 = 40 minutes

and:

2 - 1 = 1 hour

Final:

1 hour 40 minutes

29. The Borrowing Code

if (temp.minutes < t.minutes)
{
    temp.hours--;
    temp.minutes = temp.minutes + 60;
}

Let's read it like a human.

First:

if (temp.minutes < t.minutes)

means:

If the minutes we currently have are smaller than the minutes we want to subtract...

Then:

temp.hours--;

means:

Take one hour away.

For example:

3 hours
↓
2 hours

Then:

temp.minutes = temp.minutes + 60;

means:

Convert that borrowed hour into 60 minutes.

So:

20 minutes + 60 minutes
=
80 minutes

Now the subtraction can continue.

30. Complete Subtraction

After borrowing:

temp.hours = temp.hours - t.hours;
temp.minutes = temp.minutes - t.minutes;

For:

2 h 80 m
-1 h 40 m

we get:

2 - 1 = 1 hour

80 - 40 = 40 minutes

Final result:

1 hour 40 minutes

🟰 Part 7 — Assignment Operator `=`

Now let's understand:

t1 = t2;

This means:

Copy the data from t2 into t1.

We can overload it:

Time& Time::operator=(const Time &t)
{
    if (this != &t)
    {
        hours = t.hours;
        minutes = t.minutes;
    }

    return *this;
}

31. Why Is `=` Binary?

Look at:

t1 = t2;

There are two operands:

t1     =     t2
↑            ↑
operand    operand

Therefore:

= is a binary operator.

🧭 32. What Does `this` Mean?

Now we encounter:

this

Inside a member function, this is a pointer to the current object.

Suppose:

t1 = t2;

is being handled by:

operator=

Then:

current object → t1

other object   → t2

So:

this
 ↓
t1

In simple words:

this tells us which object is currently calling the member function.

33. What Does `*this` Mean?

If:

this

is a pointer to the current object, then:

*this

means the actual current object.

Think:

this
 ↓
address of current object

*this
 ↓
actual current object

Therefore:

return *this;

means:

Return the current object.

34. Why Do We Check `this != &t`?

The code contains:

if (this != &t)

This checks for self-assignment.

For example:

t1 = t1;

Here the left and right objects are the same.

We don't need to copy an object onto itself.

So the condition asks:

"Is the current object different from the object being assigned?"

If yes, perform the copy.

35. Why Does `operator=` Return `Time&`?

Notice:

Time&

instead of:

Time

The & means the function returns a reference to the existing Time object.

Returning a reference allows assignment expressions to behave naturally and supports expressions such as:

t1 = t2 = t3;

For a beginner, remember:

Time& means we return the existing Time object by reference instead of creating another separate object.

⬆️ Part 8 — Prefix `++`

Now let's move to unary operators.

Suppose:

t1 = 2 hours 59 minutes

We want:

++t1;

to increase the time by one minute.

We define:

Time& Time::operator++()
{
    minutes++;

    if (minutes >= 60)
    {
        minutes = 0;
        hours++;
    }

    return *this;
}

36. Why Is `++` Unary?

Look at:

++t1;

Visual:

       ++
        |
       t1

Only one operand exists.

Therefore:

++ is a unary operator.

37. What Does `minutes++` Mean?

Inside the function:

minutes++;

means:

Increase the current object's minutes by one.

If:

minutes = 40

then:

minutes = 41

If:

minutes = 59

then:

minutes = 60

But normal time representation doesn't keep 60 minutes.

So we need:

if (minutes >= 60)

38. What Happens at 60 Minutes?

If:

minutes = 60

we do:

minutes = 0;
hours++;

So:

2 hours 60 minutes

becomes:

3 hours 0 minutes

Therefore:

2:59
 ↓
++t1
 ↓
3:00

39. What Is Prefix?

Prefix means the operator appears before the object:

++t1;

The basic idea is:

CHANGE FIRST
     ↓
USE NEW VALUE

For example:

Before → 2:59

++t1

After  → 3:00

So prefix returns the updated object.

That's why we use:

return *this;

⬆️ Part 9 — Postfix `++`

Now look at:

t1++;

It is also unary, but its behavior is different.

The implementation is:

Time Time::operator++(int)
{
    Time temp = *this;

    minutes++;

    if (minutes >= 60)
    {
        minutes = 0;
        hours++;
    }

    return temp;
}

40. Why Does Postfix Have `int`?

This is one of the most confusing parts for beginners.

Compare:

operator++()

and:

operator++(int)

The int is a dummy parameter.

It is used to distinguish the two forms.

operator++()
      ↓
   PREFIX

operator++(int)
      ↓
  POSTFIX

The int is not used to perform the increment.

It exists so C++ can distinguish prefix and postfix versions.

41. Why Do We Need `temp` for Postfix?

Suppose:

t1 = 2:59

When we write:

t1++;

postfix means:

Use the old value first, then change the object.

So first:

Time temp = *this;

Remember:

*this

means the current object.

Therefore:

temp = 2:59
t1   = 2:59

Then we increment the original object:

t1 = 3:00

But postfix needs to return the old value.

So:

return temp;

returns:

2:59

Final situation:

Returned value = 2:59

Current t1     = 3:00

42. Prefix vs Postfix

This is one of the most important things to remember.

Prefix

++t1;

OLD VALUE
    ↓
CHANGE
    ↓
NEW VALUE
    ↓
RETURN NEW VALUE

Postfix

t1++;

OLD VALUE
    ↓
SAVE OLD VALUE
    ↓
CHANGE ORIGINAL
    ↓
RETURN OLD VALUE

🧠 Easy memory trick

Prefix → change first

Postfix → save/use old value first

⬇️ Part 10 — Prefix `--`

The same basic idea applies to decrement.

Time& Time::operator--()
{
    minutes--;

    if (minutes < 0)
    {
        minutes = 59;
        hours--;
    }

    return *this;
}

Suppose:

t1 = 3:00

Then:

--t1;

does:

3:00
 ↓
minutes becomes -1
 ↓
borrow from hour
 ↓
minutes = 59
hours = 2
 ↓
2:59

43. Why Do We Check `minutes < 0`?

Normally minutes should stay between:

0 and 59

If:

minutes = 0

and we subtract one:

minutes = -1

That's not a valid minute value.

So we convert:

3:00

into:

2:59

This is essentially the reverse idea of carrying an extra hour during addition.

⬇️ Part 11 — Postfix `--`

The postfix version is:

Time Time::operator--(int)
{
    Time temp = *this;

    minutes--;

    if (minutes < 0)
    {
        minutes = 59;
        hours--;
    }

    return temp;
}

Again:

t1--
 ↓
save old value
 ↓
decrement original
 ↓
return old value

Exactly the same pattern as postfix ++.

44. `++` and `--` Summary

Expression	Type	Meaning
`++t1`	Unary	Prefix increment
`t1++`	Unary	Postfix increment
`--t1`	Unary	Prefix decrement
`t1--`	Unary	Postfix decrement

Remember:

Prefix:
change first → return new value

Postfix:
save old value → change → return old value

🖨️ Part 12 — Output Operator `<<`

Now let's understand one of the most confusing parts.

We already know:

cout << 10;

prints:

But what happens with:

Time t1;

cout << t1;

C++ doesn't automatically know how to print our custom Time object.

So we define what << should do for Time.

ostream& operator<<(ostream &out, const Time &t)
{
    out << t.hours << " hours "
        << t.minutes << " minutes";

    return out;
}

45. What Does `cout << t1` Mean?

Think of:

cout << t1;

as:

       <<
      /  \
   cout   t1

There are two operands:

cout
t1

But there is an important difference from our earlier operators.

The left operand is:

cout

not:

Time

That is why stream operators are commonly implemented as non-member functions.

46. What Is a Non-Member Function?

A non-member function is simply a function that does not belong to the class as a member function.

Our earlier function was:

Time Time::operator+(...)

Notice:

Time::

So it belongs to the Time class.

But:

ostream& operator<<(...)

doesn't have:

Time::

before it.

So it is a non-member function.

Why?

Because:

cout << t1;

has:

left operand  → cout
right operand → t1

The left operand isn't a Time object.

47. What Is `ostream`?

ostream means:

Output Stream

cout is an output stream.

Therefore:

ostream &out

means:

out is a reference to an output stream.

Inside the function:

out << t.hours;

means:

Send the hours to the output stream.

48. Why Is `const Time &t` Used for Output?

We have:

const Time &t

because printing the object should only read its values.

We don't want:

cout << t1;

to change:

t1.hours
t1.minutes

So:

OUTPUT
  ↓
read object
  ↓
don't modify it
  ↓
const Time&

49. Why Do We Return `out`?

At the end:

return out;

This allows output chaining.

For example:

cout << t1 << t2;

After printing t1, the stream is returned, allowing the next operation:

<< t2

That's why stream output operators commonly return:

ostream&

⌨️ Part 13 — Input Operator `>>`

Now let's look at:

cin >> t1;

We want the user to enter a time and store it inside the Time object.

So we overload >>:

istream& operator>>(istream &in, Time &t)
{
    cout << "Enter hours: ";
    in >> t.hours;

    cout << "Enter minutes: ";
    in >> t.minutes;

    t.hours = t.hours + t.minutes / 60;
    t.minutes = t.minutes % 60;

    return in;
}

50. What Is `istream`?

istream means:

Input Stream

cin is an input stream.

Therefore:

istream &in

means:

in is a reference to an input stream.

51. Why Is `Time &t` Used for Input?

Notice:

Time &t

not:

const Time &t

Why?

Because input needs to modify the object.

Suppose:

cin >> t1;

The user enters:

2
90

The function needs to store these values inside t1.

Therefore:

cin
 ↓
input values
 ↓
modify Time object

So the Time object cannot be const.

52. Why Does Input Normalize the Time?

Suppose the user enters:

hours   = 2
minutes = 90

The code:

t.hours = t.hours + t.minutes / 60;
t.minutes = t.minutes % 60;

does:

90 / 60 = 1

Therefore:

2 + 1 = 3 hours

And:

90 % 60 = 30

So:

2 hours 90 minutes

becomes:

3 hours 30 minutes

🔄 Part 14 — `<<` vs `>>`

A very easy way to remember them:

Output

cout << t1;

Think:

Time object
     ↓
   goes OUT
     ↓
   cout

Therefore:

<< → OUTPUT

Input

cin >> t1;

Think:

cin
 ↓
data goes INTO
 ↓
Time object

Therefore:

>> → INPUT

🗺️ Part 15 — Complete Operator Map

Now let's put everything together.

                    OPERATOR OVERLOADING
                            |
          ┌─────────────────┼─────────────────┐
          ↓                 ↓                 ↓
       BINARY             UNARY             STREAM
          |                 |                 |
      +   -   =           ++   --           <<   >>
          |                 |                 |
     2 operands          1 operand       input/output

📋 Quick Reference Table

Operator	Example	Type	Function
`+`	`t1 + t2`	Binary	`operator+()`
`-`	`t1 - t2`	Binary	`operator-()`
`=`	`t1 = t2`	Binary	`operator=()`
`++`	`++t1`	Unary	`operator++()`
`++`	`t1++`	Unary	`operator++(int)`
`--`	`--t1`	Unary	`operator--()`
`--`	`t1--`	Unary	`operator--(int)`
`<<`	`cout << t1`	Stream	`operator<<()`
`>>`	`cin >> t1`	Stream	`operator>>()`

⭐ Part 16 — The Most Important Mental Model

If you remember only one thing from this entire article, remember this.

When you see:

t1 + t2;

think:

t1.operator+(t2);

When you see:

t1 - t2;

think:

t1.operator-(t2);

When you see:

t1 = t2;

think:

t1.operator=(t2);

When you see:

++t1;

think:

t1.operator++();

When you see:

t1++;

think:

t1.operator++(int);

For output:

cout << t1;

conceptually:

operator<<(cout, t1);

For input:

cin >> t1;

conceptually:

operator>>(cin, t1);

🧠 One Big Picture

Think of Operator Overloading like this:

                    t1 + t2
                       |
                       ↓
              "What should + do
               for Time objects?"
                       |
                       ↓
                operator+()
                       |
                       ↓
                  calculate
                       |
                       ↓
                 return Time

And for unary operators:

                    ++t1
                      |
                      ↓
                operator++()
                      |
                      ↓
                 change t1
                      |
                      ↓
                return result

And for streams:

                 cout << t1
                      |
                      ↓
                 operator<<()
                      |
                      ↓
                read Time object
                      |
                      ↓
                   display

❓ Part 17 — Common Beginner Questions

❓ Why can't I simply use `t1 + t2`?

Because C++ doesn't automatically know what + should mean for two objects of your custom Time class.

We define that behavior through Operator Overloading.

❓ Why is `+` binary?

Because:

t1 + t2

contains two operands.

❓ Why is `++` unary?

Because:

++t1

contains one operand.

❓ Why does postfix `++` have `int`?

Because C++ needs a way to distinguish:

operator++()

from:

operator++(int)

The first represents prefix.

The second represents postfix.

❓ What is `this`?

this is a pointer to the current object.

❓ What is `*this`?

*this represents the actual current object.

❓ Why is `const` used?

When we don't want a function to modify an object through a parameter.

For example:

const Time &t

means:

We can read the object, but we cannot modify it through t.

❓ Why is `&` used?

It creates a reference.

A reference allows us to work with an existing object instead of creating another separate object.

❓ Why do we need `temp`?

For + and -, temp is used to build and store the result.

For postfix ++ and --, temp is used to save the old value before changing the original object.

❓ Why is output `const`?

Because output only needs to read the object.

❓ Why isn't input `const`?

Because input needs to change the object and store the entered values inside it.

🧪 Part 18 — Practice Questions

Before looking at the answers, try these yourself.

Question 1

Is this unary or binary?

t1 + t2;

Question 2

Is this unary or binary?

++t1;

Question 3

Which function handles this?

t1 + t2;

Question 4

Which function handles this?

t1++;

Question 5

Why does postfix ++ have int?

Question 6

What does this represent?

Question 7

What does *this represent?

Question 8

Why do we use % 60?

Question 9

Which operator handles:

cout << t1;

Question 10

Which operator handles:

cin >> t1;

✅ Answers

1. Binary

t1 + t2;

has two operands.

Therefore:

Binary

2. Unary

++t1;

has one operand.

Therefore:

Unary

3.

operator+()

4.

operator++(int)

5.

The int is a dummy parameter used to distinguish postfix ++ from prefix ++.

6.

this is a pointer to the current object.

7.

*this represents the actual current object.

8.

To keep minutes within the normal range of:

0–59

For example:

70 % 60 = 10

9.

operator<<()

10.

operator>>()

📝 Part 19 — Final Cheat Sheet

╔══════════════════════════════════════════════╗
║          C++ OPERATOR OVERLOADING            ║
╚══════════════════════════════════════════════╝

BINARY
──────────────────────────────────────────────
t1 + t2  → operator+()
t1 - t2  → operator-()
t1 = t2  → operator=()

UNARY
──────────────────────────────────────────────
++t1     → operator++()
t1++     → operator++(int)

--t1     → operator--()
t1--     → operator--(int)

STREAM
──────────────────────────────────────────────
cout << t1 → operator<<()
cin >> t1  → operator>>()

IMPORTANT
──────────────────────────────────────────────
2 operands → Binary
1 operand  → Unary

++t → Prefix  → change first
t++ → Postfix → save old value first

--t → Prefix  → change first
t-- → Postfix → save old value first

<< → Output
>> → Input

this  → pointer to current object
*this → actual current object

const → don't modify through this reference
&     → reference

🎯 Final Takeaway

Operator Overloading can look complicated when we first see:

Time Time::operator+(const Time &t)

But if we break it down:

Time
 ↓
return type

Time::
 ↓
belongs to Time class

operator+
 ↓
defines +

const
 ↓
don't modify the parameter

Time
 ↓
parameter type

&
 ↓
reference

t
 ↓
parameter name

Suddenly the declaration isn't so mysterious.

Then look at the body:

create result object
        ↓
add hours
        ↓
add minutes
        ↓
convert extra minutes
        ↓
return result

And the complete flow becomes:

t1 + t2
   ↓
t1.operator+(t2)
   ↓
operator+()
   ↓
calculate
   ↓
return Time object

That's the real idea behind Operator Overloading.

Don't memorize the syntax. Understand the relationship between the operator, the object, the function, and the result.

Once that mental model becomes clear, Operator Overloading stops looking like a collection of strange symbols and starts becoming a normal C++ concept.

📂 Complete Notes & Practice Material

If you want to go beyond this article, I've also organized the complete learning material in my GitHub repository.

It includes:

📖 Detailed beginner-friendly notes
🎨 Visual study notes
💻 Complete C++ code
🔍 Step-by-step concept explanations
🧪 Practice questions with answers
📌 Quick-reference / cheat sheets

👉 Explore the complete repository:
https://github.com/Poushmita/cpp_doubtClearance

You can use the repository alongside this article to read the concepts, explore the code, revise visually, and practice them yourself.

💭 Why I Like Learning This Way

This guide started with a simple situation: a friend asked me for help understanding Operator Overloading.

While explaining it, I realized that sometimes a concept feels difficult not because the concept itself is extremely complicated, but because too many small things are assumed to be already understood.

A beginner may understand Time but not Time&.

They may understand ++ but not why:

operator++(int)

contains int.

They may understand cout but not why:

ostream& operator<<(ostream &out, const Time &t)

looks different from:

Time Time::operator+(const Time &t)

So I decided to write these notes with one simple rule:

Don't just explain what the code does. Explain why the code is written that way.

If you're learning C++ and Operator Overloading has ever felt confusing, I hope this guide helps you understand it one small piece at a time.

And if you're helping someone else learn it, feel free to use these notes as a teaching resource. ❤️

If you find something that could be explained more clearly, feel free to suggest an improvement.

Java Variables, Data and int : 8 Questions I Had as a Beginner

Poushmita Paul — Mon, 17 Aug 2026 17:59:10 +0000

Java Learning Notes — Telusko Core Java | Video 05

After learning how to set up Java and write my first Java program, I reached one of the most fundamental topics in programming:

Variables and data.

At first, variables seemed simple.

I saw code like:

int num = 3;

and thought:

"Okay, num contains 3. That's all."

But when I started looking at the statement more carefully, several questions came up:

What exactly is a variable?
Why do I need to tell Java the type?
What does int actually mean?
Why is text stored using String?
What does = really do?
Why are there both print() and println()?
Can I perform calculations directly using variables?
Why would I store a calculation in another variable instead of printing it directly?

These questions helped me understand that variables are not just something to memorize.

They are one of the basic building blocks of programming.

This article contains what I understood from Video 05 — Variables, Data & the int Type, along with additional explanations and examples that helped me make the concepts clearer.

What This Article Covers

In this article, I will answer these eight questions:

What is a variable?
Why does Java require a variable type?
What does int mean?
What is String used for?
What does = do?
What is the difference between print() and println()?
Can variables be used in arithmetic expressions?
Why store an intermediate result in another variable?

I will also cover:

Data and processing
Database vs variable
Strong typing
Semicolons
Blocks
Recompiling after changes
Common beginner mistakes

1. What is a variable?

What I understood first

A variable is one of those programming concepts that sounds complicated until it is explained with a simple example.

A useful beginner-friendly way to imagine a variable is:

A named storage location that holds a value while the program is running.

For example:

int num = 3;

Here, num is a variable.

I can think of it as a named box:

```text id="7e8f6c"
num
┌────────┐
│ 3 │
└────────┘




The name `num` allows me to refer to that stored value later.

For example:



```java
int num = 3;

System.out.println(num);

The output is:

Instead of repeatedly writing the value 3, I can use the variable name num.

Why are variables useful?

Imagine I am building a student application.

I might need to work with:

Student name
Age
Marks
Balance
Number of subjects

Instead of putting values directly everywhere, I can give them meaningful names.

For example:

String name = "Poushmita";
int age = 22;
int marks = 85;

Now the program has named pieces of data that I can use later.

Variables can change

A variable can generally hold a different value later, as long as the new value is compatible with its declared type.

For example:

int score = 10;

score = 20;

System.out.println(score);

The output is:

The variable score initially held 10, and later it was assigned 20.

This is one reason it is called a variable.

Variable vs database

This distinction was also useful for me.

A database is generally used for persistent storage.

A variable is temporary working storage used while a program is executing.

A simple comparison:

Concept	Purpose
Database	Persistent storage
Variable	Temporary working storage during program execution

For example, an application might retrieve a user's name from a database and temporarily store it in a variable while processing the request.

```text id="9h3yik"
Database
↓
Stored data
↓
Application
↓
Variable
↓
Processing




### 🧠 Easy to Remember

> **Variable = named storage for a value during program execution**

Think:

> **Name → Value**

For example:



```text
num → 3

🎯 Short Interview Answer

A variable is a named storage location used to hold a value during program execution. It allows a program to store, access, and modify data.

2. Why does Java require a variable type?

What I understood first

This was one of the things that made Java look stricter than some other languages.

For example, in Java I write:

int num = 10;

I don't simply write:

num = 10;

I have to specify:

int

Why?

Because Java is a strongly typed language.

What does strongly typed mean here?

When I declare a variable, I specify the type of data that the variable is intended to hold.

For example:

int age = 22;

Here:

int
 ↓
Type

age
 ↓
Variable name

22
 ↓
Value

The type tells Java what kind of value the variable is designed to store.

Another example:

String name = "Poushmita";

Here:

String
 ↓
Type

name
 ↓
Variable name

"Poushmita"
 ↓
Value

Why is this useful?

Suppose I have:

int age = 22;

Java knows that age is intended to hold an integer value.

If I try to assign incompatible data to it, Java can detect the problem.

For example:

int age = "twenty two";

This is not valid because "twenty two" is text, not an integer.

This type checking helps catch many mistakes before the program runs.

Types also communicate meaning

The type doesn't only help the compiler.

It also helps me as a developer understand the code.

Compare:

int age = 22;

with:

String age = "22";

Both may display 22, but they represent different kinds of data.

The first is a number.

The second is text.

That difference becomes very important when performing calculations.

🧠 Easy to Remember

Java wants to know what kind of data a variable is supposed to hold.

Think:

Type → Variable → Value

🎯 Short Interview Answer

Java is strongly typed, so variables are declared with a type that specifies the kind of data they are intended to store. This provides type checking and helps make code more predictable and maintainable.

3. What does `int` mean?

What I understood first

int is one of the first data types I encountered in Java.

It represents an integer, meaning a whole-number value without a fractional part.

Examples include:

int num = 5;
int score = 10;
int balance = -5;

So int can represent both positive and negative integer values within its defined range.

What is an integer?

An integer is a whole number.

Examples:

These are integers.

But:

6.5
3.14
10.75

are not integers because they contain fractional parts.

So this is not appropriate:

int price = 6.5;

because 6.5 is not an integer.

Java has other types for values that require fractional parts, which I will explore in later lessons.

Breaking down `int num = 5`

Let's look at:

int num = 5;

It contains several pieces:

```text id="h5lq0m"
int
↓
Data type

num
↓
Variable name

=
↓
Assignment operator

5
↓
Value

;
↓
End of statement




Understanding this small statement is actually very important because the same pattern appears throughout Java:



```text
type variableName = value;

More examples

int age = 22;
int marks = 85;
int temperature = -5;
int count = 100;

All of these store integer values.

🧠 Easy to Remember

int = integer = whole-number values

Think:

int → -5, 0, 10, 100

but not:

int → 6.5

🎯 Short Interview Answer

int is a Java primitive data type used to store integer values, including positive and negative whole numbers.

4. What is `String` used for?

What I understood first

When I wanted to store text, I couldn't use int.

For example:

String name = "Poushmita";

Here, String is used to represent text.

What is a String?

A String represents a sequence of characters.

Examples:

String name = "Poushmita";
String city = "Kolkata";
String message = "Hello World";

The text is written inside double quotes.

Why can't I use `int` for text?

Because int is designed for integer values.

This is valid:

int age = 22;

This is also valid:

String age = "22";

But they are not the same thing.

In the first case:

22 → number

In the second:

"22" → text

That difference becomes important when I perform operations on the values.

For example:

int a = 10;
int b = 20;

System.out.println(a + b);

produces:

But string concatenation behaves differently:

String a = "10";
String b = "20";

System.out.println(a + b);

produces:

This is a useful example of why the type of a variable matters.

🧠 Easy to Remember

String → text

Examples:

"Hello"
"Java"
"Poushmita"

🎯 Short Interview Answer

String is used to represent text, which is a sequence of characters. String values are commonly written inside double quotes.

5. What does `=` do?

What I understood first

The symbol:

looks like a mathematical equal sign.

But in a Java statement such as:

int num = 3;

it does something slightly different.

In Java, = is the assignment operator.

It assigns the value or result of the expression on the right to the variable on the left.

Think right → left

For:

int num = 3;

I can think:

3
↓
num

or:

Put the value 3 into num.

So:

```text id="uq3jdu"
Right-hand side
↓
assigned to
↓
Left-hand side




### Example



```java
int num = 3;

means:

Create an integer variable called num and assign 3 to it.

Then:

num = 10;

means:

Assign 10 to the existing variable num.

Assignment can use expressions

The right side doesn't have to be a single value.

For example:

int num1 = 3;
int num2 = 5;

int result = num1 + num2;

The expression:

num1 + num2

is evaluated, and its result is assigned to result.

Conceptually:

num1 + num2
     ↓
     8
     ↓
 result

Assignment vs comparison

This distinction is extremely important.

In Java:

means:

Assignment

It does not mean "check whether two values are equal."

Comparison for equality uses:

==

For example:

if (num == 10) {
    ...
}

I don't need to go deeply into == yet, but remembering the difference now will prevent confusion later.

🧠 Easy to Remember

= → assignment

Think:

Right side → left side

🎯 Short Interview Answer

The = operator is the assignment operator in Java. It assigns the value of the expression on the right-hand side to the variable on the left-hand side.

6. What is the difference between `print()` and `println()`?

What I understood first

Both methods can display output.

For example:

System.out.print(5);

and:

System.out.println(5);

Both display:

So what's the difference?

The difference is what happens after the output is printed.

`print()`

print() displays the value and keeps the cursor on the same line.

For example:

System.out.print(5);
System.out.print(15);

Output:

Both values appear on the same line.

`println()`

println() displays the value and then moves to the next line.

For example:

System.out.println(5);
System.out.println(15);

Output:

5
15

So:

print()
↓
Print and stay on same line

println()
↓
Print and move to next line

A simple example

System.out.print("Hello ");
System.out.print("Java");

Output:

Hello Java

But:

System.out.println("Hello");
System.out.println("Java");

Output:

Hello
Java

Why is this useful?

When creating console applications, controlling how output appears can be important.

For example, if I want a sentence to be constructed on one line, I can use print().

If I want each piece of output on its own line, I can use println().

🧠 Easy to Remember

print() → same line

println() → new line

The ln in println is a helpful reminder:

ln → line

🎯 Short Interview Answer

print() displays output without moving to the next line, while println() displays output and then moves the cursor to a new line.

7. Can variables be used in arithmetic expressions?

What I understood first

Yes.

This is one of the main reasons variables are useful.

Instead of writing values directly into every calculation, I can store them in variables and then use those variables in expressions.

For example:

int num1 = 3;
int num2 = 5;

System.out.println(num1 + num2);

The output is:

What actually happens?

The expression:

num1 + num2

uses the values currently stored in those variables.

Conceptually:

num1 → 3
num2 → 5

3 + 5
 ↓
 8

Then System.out.println() prints the result.

Other arithmetic operations

Variables can also be used with operators such as:

+
-
*
/
%

For example:

int a = 10;
int b = 3;

System.out.println(a + b);
System.out.println(a - b);
System.out.println(a * b);
System.out.println(a / b);
System.out.println(a % b);

The exact behavior of operations such as integer division and remainder becomes more important as I learn Java's numeric types.

Why use variables instead of values directly?

Compare:

System.out.println(3 + 5);

with:

int num1 = 3;
int num2 = 5;

System.out.println(num1 + num2);

The second version is more meaningful when the values represent real data.

For example:

int price = 500;
int discount = 100;

System.out.println(price - discount);

Now the code communicates what the numbers mean.

🧠 Easy to Remember

Variables can participate in expressions just like values can.

Think:

Variable → stored value → expression → result

🎯 Short Interview Answer

Yes. Variables can be used in arithmetic expressions. Java uses the values currently stored in the variables when evaluating the expression.

8. Why store an intermediate result in another variable?

What I understood first

Suppose I have:

int num1 = 3;
int num2 = 5;

System.out.println(num1 + num2);

This works perfectly.

But I can also write:

int num1 = 3;
int num2 = 5;

int result = num1 + num2;

System.out.println(result);

At first, I wondered:

Why create another variable when I can print the calculation directly?

The answer is that storing the result gives the value a name.

Direct calculation

System.out.println(num1 + num2);

The calculation happens and the result is immediately printed.

Store the result

int result = num1 + num2;

System.out.println(result);

Now the calculation and output are separate.

Conceptually:

Input values
    ↓
Calculation
    ↓
Result variable
    ↓
Output

Why is this useful?

In a small example, it may not seem necessary.

But imagine a larger program where I need to use the result several times.

For example:

int price = 500;
int discount = 100;

int finalPrice = price - discount;

Now finalPrice can be used in multiple places:

System.out.println(finalPrice);

or:

// use finalPrice in another calculation

The variable also makes the code easier to understand.

Compare:

System.out.println(price - discount);

with:

int finalPrice = price - discount;
System.out.println(finalPrice);

The second version tells me what the result actually represents.

Intermediate results in larger programs

Real applications often perform multiple steps:

Input
 ↓
Process
 ↓
Intermediate result
 ↓
More processing
 ↓
Final result

Variables make it possible to store those intermediate values.

This becomes extremely important as programs become more complex.

🧠 Easy to Remember

Store a result in a variable when you need to reuse it, name it, or make the calculation easier to understand.

Think:

Input → Calculation → Result variable → Output

🎯 Short Interview Answer

An intermediate result can be stored in another variable so that it can be reused, given a meaningful name, or used in later calculations. It can also improve code readability.

💾 Why Applications Work With Data

What I understood from the lesson

Almost every useful application works with data.

For example:

A banking application works with account information and transactions.
An e-commerce application works with products and orders.
A student application works with names, marks, and attendance.
A social-media application works with users, posts, comments, and messages.

A simplified view is:

```text id="7h5f3w"
Input
↓
Processing
↓
Storage




Data may come from:

* Users
* Files
* APIs
* Databases
* Sensors
* Other applications

The program processes that data and produces some result.

### Persistent vs temporary data

This is where the database vs variable distinction becomes useful.

A database is generally used for **persistent storage**.

A variable is generally used as **temporary working storage during program execution**.

For example:



```text id="s4ppx4"
Database
   ↓
Retrieve user balance
   ↓
Variable
   ↓
Perform calculation
   ↓
Updated value
   ↓
Database

So variables and databases solve different problems.

✏️ Java Statements and Semicolons

What I understood first

I noticed that many Java statements end with:

For example:

int num = 3;

The semicolon marks the end of a Java statement.

Example

int num = 3;
System.out.println(num);

Both are statements, and both end with semicolons.

What about curly braces?

Curly braces define blocks of code.

For example:

{
    int num = 3;
    System.out.println(num);
}

The braces themselves are not simply "another kind of semicolon."

They define a block containing statements.

This distinction becomes much more important when I learn:

Classes
Methods
if
else
Loops

🧠 Easy to Remember

; → ends a statement

{ } → defines a block

🔄 Compile Again After Changing Code

What I understood from this lesson

This is an easy mistake to make when starting out.

Suppose I write:

System.out.println("Hello");

Then compile:

javac Hello.java

and run:

java Hello

I get:

Hello

Now I change the source code:

System.out.println("Hello Java");

If I immediately run the old compiled class without compiling the changed source again, I may still see the previous output.

That's because the .class file hasn't been updated.

The correct workflow

After changing the source:

```text id="k4t8ve"
Edit
↓
Save
↓
Compile
↓
Run




For example:



```bash
javac Hello.java
java Hello

🧠 Easy to Remember

Changed .java → compile again before running

Think:

Edit → Compile → Run

⚠️ Common Beginner Mistakes

Declaring a variable without a type

Incorrect:

num = 3;

At this stage, Java expects a declaration such as:

int num = 3;

Trying to store a decimal in `int`

Incorrect:

int price = 6.5;

6.5 is not an integer.

Forgetting the semicolon

Incorrect:

int num = 3

Correct:

int num = 3;

Confusing `=` with comparison

Remember:

=  → assignment
== → equality comparison

Forgetting to recompile

If I modify:

Hello.java

I should compile again before running the updated program.

Using `print()` when I need separate lines

This:

System.out.print(5);
System.out.print(15);

produces:

while:

System.out.println(5);
System.out.println(15);

produces:

5
15

🧠 One-Minute Revision Sheet

If I need to revise this lesson quickly, this is what I want to remember:

Variable
↓
Named storage for a value

Java
↓
Strongly typed

String
↓
Text

int
↓
Integer / whole number

=
↓
Assignment

;
↓
End of statement

print()
↓
Same line

println()
↓
New line

Variables
↓
Can be used in expressions

Intermediate result
↓
Store calculation in another variable

After editing
↓
Compile again
↓
Run

And the basic variable pattern is:

type variableName = value;

For example:

int num = 3;

🎯 8 Interview Questions — Super Short Answers

What is a variable?

A variable is a named storage location used to hold a value during program execution.

Why does Java require a variable type?

Java is strongly typed, so a variable declaration specifies the kind of data the variable is intended to store.

What does `int` mean?

int is a primitive data type used to store integer or whole-number values.

What is `String` used for?

String is used to represent text or a sequence of characters.

What does `=` do?

= is the assignment operator. It assigns the value of the right-hand expression to the variable on the left.

What is the difference between `print()` and `println()`?

print() stays on the same line, while println() moves to a new line after printing.

Can variables be used in arithmetic expressions?

Yes. Java uses the values currently stored in variables when evaluating arithmetic expressions.

Why store an intermediate result?

To give the result a meaningful name, reuse it later, or make the program easier to understand.

What I Learned From This Lesson

This lesson changed how I looked at a simple statement like:

int num = 3;

Before, I saw it as just one line of Java code.

Now I can break it down:

int
 ↓
What kind of data?

num
 ↓
What is the variable called?

=
 ↓
Assign the value

3
 ↓
What value should it hold?

;
 ↓
Statement is complete

That small line contains several important programming concepts.

I also started seeing the relationship between data and processing more clearly:

Input
 ↓
Variables
 ↓
Processing
 ↓
Intermediate Results
 ↓
Output

And that is essentially what many programs do at a basic level.

A Note for Other Beginners

If variables feel confusing at first, don't try to memorize every data type immediately.

Start with the basic idea:

A variable is a named place where a program can temporarily store data.

Then learn the pattern:

type variableName = value;

For example:

int age = 22;
String name = "Poushmita";

Once this pattern becomes familiar, other data types and more complex expressions become much easier to understand.

Also remember that:

means assignment.

It does not mean comparison.

And whenever you change your Java source code:

Edit → Save → Compile → Run

That small workflow will save a lot of confusion when you're starting.

📚 Related Java Learning Resources

This article is part of my Java Learning Notes — Telusko Core Java series.

If you are following the series from the beginning:

👉 Video 01 — Java Introduction: 8 Questions I Had as a Beginner and Their Easy Answers

👉 Video 02 — Setting Up Java: 6 Questions I Had About JDK, VS Code, LTS and PATH

👉 Video 03 — Writing Your First Java Code: 5 Questions I Had as a Beginner

If you have also covered the JVM/JRE/JDK lesson, add that article here as well:

👉 Video 04 — JVM, JRE and JDK

🔗 My Java Learning Notes

I am maintaining the complete structured notes and resources in my GitHub repository.

👉 Java Learning Notes — Telusko Core Java

The GitHub repository contains my concise learning notes and resources, while these DEV.to articles go deeper into the questions and concepts that I found confusing during my learning.

Final Takeaway

For me, this lesson made the idea of data inside a program much clearer.

The simple mental model I want to remember is:

Data
 ↓
Variable
 ↓
Processing
 ↓
Result
 ↓
Output

And the basic Java syntax:

int num = 3;

can be understood as:

int
→ type

num
→ variable name

=
→ assignment

3
→ value

;
→ end of statement

The most important things I want to remember from this lesson are:

Variable → named storage

String → text

int → integer

= → assignment

print() → same line

println() → new line

Edit → Compile → Run

These are small concepts, but they form the foundation for much more advanced Java programming.

And now that I understand how Java stores and processes basic data, the next step is to learn more about the different data types Java provides and how they behave.

This is part of my ongoing Java learning journey. I'm documenting what I learn, the questions I get stuck on, and the explanations that finally make the concepts click for me — hopefully they can help another beginner too.

JVM, JRE, JDK, Bytecode & main(): 8 Questions I Had as a Beginner

Poushmita Paul — Mon, 17 Aug 2026 17:21:52 +0000

Java Learning Notes — Telusko Core Java | Video 04

In the previous lesson, I finally wrote my first Java program and learned the basic:

Write → Compile → Run

workflow.

But after writing a simple Java program, I realized that there was much more happening behind the scenes.

I kept seeing terms like:

Bytecode
.class
JVM
JRE
JDK
main()
javac
WORA

And I had questions like:

What exactly is bytecode?

Why doesn't Java run the .java file directly?

What is the difference between JDK, JRE and JVM?

If Java is platform independent, why is the JVM platform dependent?

And why does Java need public static void main(String[] args)?

This lesson helped me connect these pieces.

As I worked through it, I realized that the easiest way to understand Java's execution model is to follow the journey of a Java program from the moment I write it until I see the output.

This article explains what I learned from the lesson, along with additional research I used to make these concepts easier to understand.

What This Article Covers

In this article, I will answer these eight questions:

What is bytecode?
What does javac do?
Why is Java considered platform independent?
Why is the JVM platform dependent?
What is the purpose of main()?
What is the difference between java Hello and javac Hello.java?
What do JDK, JRE and JVM stand for?
What does WORA mean?

I will also connect all of these concepts into one simple execution flow.

1. What is bytecode?

What I understood first

Before this lesson, I knew that Java code gets compiled.

But I didn't really understand:

Compiled into what?

The answer is:

Bytecode.

When I write Java source code in a file such as:

Hello.java

the Java compiler does not normally convert it directly into machine code specific to Windows, Linux, or macOS.

Instead, it converts the Java source code into bytecode.

The simplified process is:

Java Source Code
      ↓
     javac
      ↓
   Bytecode
      ↓
    JVM
      ↓
   Execution

The bytecode is usually stored inside a .class file.

For example:

Hello.java
    ↓
Hello.class

So I can think of:

.java
↓
Source code

.class
↓
Bytecode

Why doesn't Java directly create Windows or Linux machine code?

This is where Java's portability becomes important.

If the compiler generated machine code specifically for Windows, that output would not necessarily work directly on Linux or macOS.

Instead, Java uses an intermediate representation:

Bytecode

The JVM on each supported platform understands and executes that bytecode.

So:

             Same Bytecode
                  │
       ┌──────────┼──────────┐
       ↓          ↓          ↓
    Windows      Linux      macOS
      JVM         JVM        JVM

This design is one of the major reasons Java became known for portability.

Is bytecode the same as machine code?

No.

This distinction is important.

Machine code is instructions designed for a specific processor architecture.

Java bytecode is an intermediate instruction format designed for the JVM.

So I remember:

Java Source Code
      ↓
    Bytecode
      ↓
      JVM
      ↓
Platform-specific execution

🧠 Easy to Remember

Bytecode = compiled Java instructions stored in .class files and executed by the JVM.

🎯 Short Interview Answer

Bytecode is the intermediate instruction format produced by the Java compiler from Java source code. It is stored in .class files and executed by the JVM.

2. What does `javac` do?

What I understood first

I already learned about javac in Video 03, but this lesson helped me understand its role in the complete Java execution model.

javac is the:

Java compiler

Its job is to compile Java source code into bytecode.

For example:

javac Hello.java

If the source code is valid, the compiler can produce:

Hello.class

So:

Hello.java
    ↓
  javac
    ↓
Hello.class

The .class file contains the bytecode.

What does the compiler actually check?

The compiler doesn't simply convert text into another file.

It also checks whether the Java source code follows the language's rules.

For example, if I write invalid Java syntax, the compiler can report an error.

Suppose I forget a semicolon:

System.out.println("Hello World")

Running:

javac Hello.java

can produce a compilation error.

So I can think of javac as the stage that takes my Java source code and prepares it for execution by the JVM.

`javac` vs `java`

This distinction is extremely important:

javac
 ↓
Compile

java
 ↓
Run

For example:

javac Hello.java

compiles the source file.

Then:

java Hello

runs the compiled class.

🧠 Easy to Remember

javac → compile

java → run

🎯 Short Interview Answer

javac is the Java compiler. It compiles Java source code into bytecode, which is stored in .class files and later executed by the JVM.

3. Why is Java considered platform independent?

What I understood first

This was one of the most important concepts for me.

We often hear:

Java is platform independent.

But what exactly does that mean?

It does not mean that Java magically ignores the operating system.

It means that Java's execution model allows the same compiled bytecode to be used across different supported platforms through their appropriate JVM implementations.

The complete picture

Suppose I write:

Hello.java

I compile it:

javac Hello.java

and get:

Hello.class

That .class file contains bytecode.

Now imagine I move that compiled application to another supported operating system.

The JVM available on that platform can execute the bytecode.

So:

              Java Source
                   ↓
                 javac
                   ↓
              Bytecode
                   ↓
        ┌──────────┼──────────┐
        ↓          ↓          ↓
   Windows JVM  Linux JVM  macOS JVM
        ↓          ↓          ↓
      Run        Run        Run

This is the basic idea behind Java's platform independence.

What is actually platform independent?

The important distinction is:

Java bytecode is designed to be portable.

The JVM itself is not identical across operating systems.

There can be different JVM implementations for different platforms.

That brings us to the next question.

🧠 Easy to Remember

Same bytecode + different platform JVMs = Java portability

🎯 Short Interview Answer

Java is considered platform independent because Java source code is compiled into platform-independent bytecode that can be executed on different supported operating systems through compatible JVM implementations.

4. Why is the JVM platform dependent?

What I understood first

At first, I found this confusing:

Java is platform independent, but the JVM is platform dependent. How can both be true?

The answer becomes simple when I separate the two.

Java bytecode is portable

The bytecode generated from Java source code is designed to be portable across supported platforms.

For example:

Hello.class

can be transferred to another compatible platform.

The JVM interacts with the operating system

The JVM, however, needs to work with the underlying operating system and hardware.

For example, a JVM running on Windows needs to interact with Windows.

A JVM running on Linux needs to interact with Linux.

A JVM running on macOS needs to interact with macOS.

So we can think of:

             Same Java Bytecode
                     │
       ┌─────────────┼─────────────┐
       ↓             ↓             ↓
 Windows JVM     Linux JVM     macOS JVM
       ↓             ↓             ↓
    Windows        Linux         macOS

The bytecode remains portable, but the JVM implementation is adapted to the platform.

This is the important distinction

Java/bytecode → platform independent

JVM → platform dependent

This distinction cleared up the apparent contradiction for me.

🧠 Easy to Remember

Java bytecode travels.

The JVM adapts to the platform.

🎯 Short Interview Answer

The JVM is platform dependent because each operating system and hardware environment requires a JVM implementation capable of interacting with that specific platform. Java bytecode remains portable because compatible JVMs execute it on different platforms.

5. What is the purpose of `main()`?

What I understood first

In the previous lesson, I saw code like:

```java id="r8w3tz"
System.out.println("Hello World");




But that statement alone wasn't enough to create a normal Java application.

I needed something like:



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

The important new part was:

public static void main(String[] args)

At this stage, I don't need to memorize the meaning of every keyword yet.

The most important thing is to understand:

main() provides the standard entry point for a Java application.

What does "entry point" mean?

Think about a program as a journey.

The JVM needs to know:

"Where should I start executing this application?"

For a standard Java application launched with the Java launcher, the main() method provides that starting point.

So conceptually:

Start Java Application
        ↓
Find main()
        ↓
Begin execution
        ↓
Run statements
        ↓
Output

The standard main method

The traditional form introduced here is:

public static void main(String[] args)

For now, I remember the complete signature.

Later, I can learn what:

public
static
void
String[]
args

actually mean.

Trying to understand every keyword immediately can make the first Java lesson unnecessarily overwhelming.

Example

public class Hello {

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

}

Here:

class Hello
      ↓
contains main()
      ↓
JVM starts application execution there

Is `main()` the only possible entry point in Java?

For the traditional standalone Java application model being taught here, the main method is the standard entry point.

Different Java technologies can have different application startup mechanisms, but for learning Core Java fundamentals, the important rule is:

The JVM looks for the recognized main method when launching a standard Java application.

🧠 Easy to Remember

main() = starting point of a standard Java application

🎯 Short Interview Answer

The main() method serves as the standard entry point for a standalone Java application. The Java launcher invokes this method to begin application execution.

6. What is the difference between `java Hello` and `javac Hello.java`?

What I understood first

These two commands look very similar, so it is easy to mix them up:

javac Hello.java

and:

java Hello

But they perform completely different jobs.

`javac Hello.java`

This means:

Compile the Java source file.

The process is:

Hello.java
    ↓
  javac
    ↓
Hello.class

The .java file is the source code.

The .class file contains bytecode.

`java Hello`

This means:

Launch the compiled Hello class.

The Java launcher starts the JVM and loads the class so that the standard application entry point can be invoked.

The command normally uses the class name, not the .java or .class filename extension:

java Hello

not:

java Hello.java

for the traditional compile-then-run workflow being introduced here.

And not:

java Hello.class

The complete sequence

Write:
Hello.java
   ↓
Compile:
javac Hello.java
   ↓
Creates:
Hello.class
   ↓
Run:
java Hello
   ↓
JVM
   ↓
Output

🧠 Easy to Remember

javac Hello.java → Create bytecode

java Hello → Run the compiled class

🎯 Short Interview Answer

javac Hello.java compiles the Java source file into bytecode, while java Hello launches the compiled class and starts the application through the JVM.

7. What do JDK, JRE and JVM stand for?

What I understood first

This was probably the most confusing group of terms for me.

I kept seeing:

JDK
JRE
JVM

They all sounded like different versions of the same thing.

The easiest way I found to understand them is to think about their roles.

JDK
└── JRE
    └── JVM

This is the conceptual hierarchy used in the lesson.

JVM — Java Virtual Machine

The JVM is responsible for:

Executing Java bytecode.

Think:

.class
  ↓
Bytecode
  ↓
JVM
  ↓
Execution

JRE — Java Runtime Environment

The JRE represents the environment required to run Java applications.

The lesson's conceptual model includes:

JVM
Runtime libraries/components

So:

JRE
 ├── JVM
 └── Runtime libraries/components

The key idea is:

JRE → runtime

JDK — Java Development Kit

The JDK is for development.

It includes development tools such as the Java compiler.

So:

JDK
 ├── Development tools
 └── Runtime components
       ↓
      JRE
       ↓
      JVM

This is a conceptual model that is useful for learning.

A practical modern note

One thing I discovered while researching this topic is that modern Java distributions don't always package a separate downloadable product called a "JRE" in the same way older Java distributions did.

For learning the architecture, the:

JDK → JRE → JVM

model is still useful.

But when installing modern Java, I generally install a JDK for development rather than looking for a separate JRE download.

The simplest distinction

If I forget everything else, I want to remember:

JDK
↓
Develop Java

JRE
↓
Run Java

JVM
↓
Execute bytecode

🧠 Easy to Remember

JDK → Development

JRE → Runtime

JVM → Executes bytecode

Or:

JDK contains the tools I need to build; the runtime environment lets Java applications run; the JVM executes the bytecode.

🎯 Short Interview Answer

JDK stands for Java Development Kit and provides development tools. JRE stands for Java Runtime Environment and provides the environment required to run Java applications. JVM stands for Java Virtual Machine and executes Java bytecode.

8. What does WORA mean?

What I understood first

I first encountered WORA in the introduction lesson:

Write Once, Run Anywhere

But this lesson made the idea much clearer because now I understood bytecode and the JVM.

How WORA works

Suppose I write:

```text id="o4y7q1"
Hello.java




I compile it:



```bash id="n3k5r8"
javac Hello.java

and get:

Hello.class

The .class file contains bytecode.

Now I can think of that bytecode as being portable across supported platforms because each platform can have a compatible JVM.

             Hello.class
              Bytecode
                  │
       ┌──────────┼──────────┐
       ↓          ↓          ↓
    Windows      Linux      macOS
      JVM         JVM        JVM
       ↓          ↓          ↓
      Run        Run        Run

That's the basic idea behind:

Write Once, Run Anywhere

Why isn't the JVM itself portable in the same way?

Because the JVM has to interact with the underlying operating system and hardware.

So:

Bytecode
  ↓
Portable

JVM
  ↓
Platform-specific implementation

This distinction is the key to understanding Java's platform independence.

Is WORA an absolute guarantee?

Not literally.

A Java application can still depend on things such as:

Native libraries
Operating-system-specific features
External services
Environment configuration
File-system assumptions

So I understand WORA as a description of Java's portable bytecode + JVM execution model, not as a promise that every application will work everywhere without any configuration.

🧠 Easy to Remember

WORA = Write Once, Run Anywhere

And the mechanism is:

Source → Bytecode → Platform-specific JVM → Execution

🎯 Short Interview Answer

WORA stands for Write Once, Run Anywhere. Java achieves this portability by compiling source code into bytecode that can be executed on different supported platforms through compatible JVM implementations.

🔄 The Complete Java Execution Model

After learning all these concepts, I found it much easier to understand Java as a complete process instead of memorizing separate definitions.

Step 1 — Write source code

I create:

Hello.java

and write:

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

Step 2 — Compile

I run:

javac Hello.java

The compiler converts the source code into bytecode.

Hello.java
    ↓
  javac
    ↓
Hello.class

Step 3 — Launch

I run:

java Hello

The Java launcher starts the runtime and loads the class.

Step 4 — JVM executes bytecode

The JVM loads and executes the bytecode.

Step 5 — `main()` provides the starting point

The standard main() method provides the entry point from which the application begins execution.

Step 6 — Output appears

Finally:

Hello World

So the complete picture becomes:

       Hello.java
           │
           ↓
         javac
           │
           ↓
       Hello.class
        Bytecode
           │
           ↓
      java Hello
           │
           ↓
          JVM
           │
           ↓
        main()
           │
           ↓
        Output

This is the mental model I want to carry forward.

🧩 JDK vs JRE vs JVM — Simple Comparison

Component	Main Purpose	Think
JDK	Java development	Build
JRE	Java runtime environment	Run
JVM	Executes bytecode	Execute

The conceptual relationship from the lesson is:

JDK
 ↓
JRE
 ↓
JVM

And the execution flow is:

.java
 ↓
javac
 ↓
.class
 ↓
JVM
 ↓
Output

⚠️ Common Beginner Mistakes

Confusing `java` and `javac`

Remember:

javac → compile
java  → run

Running the source filename with `java`

Traditional compile-then-run workflow:

javac Hello.java
java Hello

not:

java Hello.java

Running `.class` with the Java launcher

Use:

java Hello

not:

java Hello.class

Thinking the JVM is platform independent

The bytecode is designed to be portable.

The JVM implementation is platform-specific.

Thinking JDK and JVM are the same thing

They are not.

JDK → Development tools
JRE → Runtime environment
JVM → Executes bytecode

Forgetting the `main()` method

A standard standalone Java application needs an appropriate entry point for the Java launcher to start execution.

For the traditional form:

public static void main(String[] args)

Assuming WORA means zero configuration

Java provides strong portability, but applications can still have platform-specific dependencies.

🧠 One-Minute Revision Sheet

If I have only one minute to revise this lesson, I want to remember:

.java
↓
Java source code

javac
↓
Java compiler

.class
↓
Bytecode

JVM
↓
Executes bytecode

main()
↓
Standard application entry point

JDK
↓
Development

JRE
↓
Runtime

JVM
↓
Execution

WORA
↓
Write Once, Run Anywhere

And the complete workflow:

Write
 ↓
Compile
 ↓
Bytecode
 ↓
JVM
 ↓
main()
 ↓
Execute
 ↓
Output

🎯 8 Interview Questions — Super Short Answers

What is bytecode?

Bytecode is the intermediate code produced by the Java compiler and stored in .class files. The JVM executes it.

What does `javac` do?

javac compiles Java source code into bytecode.

Why is Java platform independent?

Java source code is compiled into portable bytecode that can run on different platforms through compatible JVM implementations.

Why is the JVM platform dependent?

The JVM must interact with the specific operating system and hardware platform, so JVM implementations are platform-specific.

What is the purpose of `main()`?

main() is the standard entry point used to start a standalone Java application.

What is the difference between `java Hello` and `javac Hello.java`?

javac Hello.java compiles the source code, while java Hello launches the compiled class.

What are JDK, JRE and JVM?

JDK provides development tools, JRE provides the runtime environment, and JVM executes Java bytecode.

What does WORA mean?

WORA means Write Once, Run Anywhere and refers to Java's portable bytecode execution model across supported platforms.

What I Learned From This Lesson

This lesson connected almost everything I had learned in the previous three lessons.

At first, I was looking at these as separate terms:

Java
javac
.class
JVM
JRE
JDK
main()
WORA

Now I can connect them.

Java Source Code
      ↓
    .java
      ↓
    javac
      ↓
  Bytecode
      ↓
    .class
      ↓
    JVM
      ↓
   main()
      ↓
  Execution
      ↓
   Output

And around that execution process:

JDK
 ↓
Development tools

JRE
 ↓
Runtime environment

JVM
 ↓
Executes bytecode

The biggest thing I understood is that Java's platform independence doesn't mean the JVM is the same everywhere.

Instead:

The bytecode is portable, while each platform provides an appropriate JVM implementation to execute it.

That one idea made WORA much easier for me to understand.

A Note for Other Beginners

If you are confused by JVM, JRE, JDK and bytecode, don't try to memorize four definitions separately.

Start with one simple journey:

Write Java
    ↓
.java
    ↓
javac
    ↓
.class
    ↓
Bytecode
    ↓
JVM
    ↓
main()
    ↓
Output

Then remember the roles:

JDK → develop

JRE → runtime

JVM → execute

Once this mental model becomes clear, many later Java concepts become much easier to understand.

📚 Related Java Learning Resources

This article is part of my Java Learning Notes — Telusko Core Java series.

If you are following the series from the beginning:

👉 Video 01 — Java Introduction: 8 Questions I Had as a Beginner and Their Easy Answers

👉 Video 02 — Setting Up Java: 6 Questions I Had About JDK, VS Code, LTS and PATH

👉 Video 03 — Writing Your First Java Code: 5 Questions I Had as a Beginner

I also wrote a separate article while researching the history behind Java:

👉 Java Introduction: What Is Java, Who Created It, and How Sun Microsystems Became Oracle?

🔗 My Java Learning Notes

I am maintaining the complete structured notes and resources in my GitHub repository.

👉 Java Learning Notes — Telusko Core Java

The GitHub repository contains my concise learning notes and resources, while these DEV.to articles go deeper into the questions and concepts that I found confusing during my learning.

Final Takeaway

For me, Video 04 was the lesson where the Java execution model finally started making sense.

I can now look at:

Hello.java

and understand what happens next:

Hello.java
    ↓
javac
    ↓
Hello.class
    ↓
Bytecode
    ↓
JVM
    ↓
main()
    ↓
Output

And I can remember the three terms that initially confused me:

JDK → Development
JRE → Runtime
JVM → Execution

The next step is to stop just understanding how Java runs and start understanding the actual Java language itself — variables, data types, and how we store information in a program.

Writing Your First Java Code: 5 Questions I Had as a Beginner

Poushmita Paul — Mon, 17 Aug 2026 17:13:10 +0000

Java Learning Notes — Telusko Core Java | Video 03

After installing the JDK and setting up VS Code, I finally reached the part I was waiting for:

Writing my first Java code.

At this point, I thought the process would be very simple:

Open VS Code → write System.out.println() → run it.

But while going through the lesson, I realized that there are a few things I need to understand before a Java program actually runs.

For example:

What exactly is a .java file?
What is javac?
What is the difference between java and javac?
What is JShell?
Why can I write something directly in JShell but need more structure in a Java source file?
What exactly happens between writing the code and seeing the output?

These questions became much clearer once I understood the basic write → compile → run workflow.

This article contains what I learned from the lesson, along with additional explanations and examples that helped me understand the concepts better.

What This Article Covers

In this article, I will answer five questions from Video 03:

What does .java mean?
What is javac?
What is JShell used for?
Why are double quotes needed around text?
What is the basic Java write → compile → run workflow?

I will also explain:

The basic VS Code workspace
The difference between java and javac
JShell vs Java source files
How Java source code becomes executable
Common beginner mistakes

1. What does `.java` mean?

What I understood first

When I created my first Java file, I noticed that the file name ended with:

.java

For example:

Hello.java

I initially thought the extension was simply a naming convention.

But it actually tells us something important:

The .java extension identifies a Java source-code file.

A Java source file contains the Java code that I write as a developer.

What is a source file?

The code I write is called source code.

For example:

System.out.println("Hello World");

This is Java source code.

When I save it in a file such as:

Hello.java

I have created a Java source file.

Later, the Java compiler can process this source file.

The simplified flow is:

Hello.java
    ↓
Java source code
    ↓
javac
    ↓
Bytecode

Why does the extension matter?

The extension helps tools and development environments understand what type of file they are dealing with.

For example:

Language	Common source-file extension
C	`.c`
C++	`.cpp`
JavaScript	`.js`
Java	`.java`

So:

Hello.java

tells me:

This is a Java source file.

`.java` vs `.class`

This distinction is also useful.

Before compilation:

Hello.java

contains Java source code.

After compilation, the compiler can produce:

Hello.class

which contains Java bytecode.

So:

.java
↓
Source code

.class
↓
Compiled bytecode

This distinction helped me understand why Java has a compilation step before execution.

🧠 Easy to Remember

.java = Java source-code file

And:

.class = compiled Java bytecode

🎯 Short Interview Answer

The .java extension is used for Java source files containing Java source code. These files can be compiled by the Java compiler into bytecode, typically stored in .class files.

2. What is `javac`?

What I understood first

This was one of the commands I had already seen during Java setup:

javac --version

But knowing that javac exists is different from understanding what it actually does.

javac is the Java compiler.

The name comes from:

Java Compiler

What does a compiler do?

A compiler translates source code into another form that can be executed by a runtime environment or machine.

For Java, the simplified process is:

Java Source Code
       ↓
     javac
       ↓
    Bytecode
       ↓
     JVM
       ↓
   Execution

For example, suppose I have:

Hello.java

I can compile it using:

javac Hello.java

If the compilation succeeds, a .class file can be generated:

Hello.class

That .class file contains Java bytecode.

What happens if there is an error?

Suppose I accidentally write:

System.out.println("Hello World"

and forget something required by the syntax.

When I run:

javac Hello.java

the compiler checks the source code and can report compilation errors.

So javac doesn't just "run" my Java program.

It compiles the source code.

`java` vs `javac`

This distinction is extremely important.

I like to remember it this way:

javac
  ↓
compile

java
  ↓
run

For example:

javac Hello.java

means:

Compile the Java source file.

Then:

java Hello

means:

Run the compiled Java class named Hello.

Notice that we normally don't write:

java Hello.java

when following the traditional compile-then-run workflow being introduced here.

🧠 Easy to Remember

javac → compile

java → run

This is probably one of the most important command-line distinctions from this lesson.

🎯 Short Interview Answer

javac is the Java compiler. It compiles Java source files into bytecode, which can then be executed by the JVM.

3. What is JShell used for?

What I understood first

JShell was a new concept for me when I came across it.

JShell stands for:

Java Shell

It is an interactive environment for experimenting with Java code.

Instead of creating a complete Java source file, writing the required structure, compiling it, and then running it, I can use JShell to try small pieces of Java code interactively.

A simple example

I can start JShell from the terminal:

jshell

Then I can type:

2 + 3

and get:

I can also try:

System.out.println("Hello World");

and immediately see:

Hello World

This makes JShell useful for quick experimentation.

Why is JShell useful for beginners?

Suppose I am learning an expression or trying to understand how something works.

I may not want to create a complete Java application just to test one small idea.

Instead:

Open JShell
     ↓
Try something
     ↓
See the result
     ↓
Modify it
     ↓
Try again

This gives me a quick feedback loop.

Is JShell used to build normal applications?

Not usually.

JShell is mainly useful for:

Quick experiments
Learning
Testing expressions
Trying APIs
Exploring Java behavior

For a proper application, I would normally create Java source files and organize the code into a structured project.

So I think of JShell as:

A playground for Java.

JShell vs Java source file

Aspect	JShell	Java source file
Main purpose	Quick experiments	Structured programs
Interaction	Interactive	File-based
Structure	Minimal	More structured
Compile/run workflow	Mostly hidden from me	Explicit workflow
Best for	Learning and testing ideas	Applications and projects

This distinction made JShell much easier for me to understand.

🧠 Easy to Remember

JShell = Java playground

Use it when I want to quickly:

Try → Test → Learn

🎯 Short Interview Answer

JShell is an interactive Java shell that allows developers to quickly experiment with Java expressions, statements, and APIs without creating a complete Java source file.

4. Why are double quotes needed around text?

What I understood first

When I saw:

System.out.println("Hello World");

I noticed that "Hello World" is surrounded by double quotes.

I initially thought:

"Are the quotes just there because that's how Java writes text?"

There is actually a reason.

The double quotes tell Java that:

This is a string literal.

What is a string?

A String represents a sequence of characters.

For example:

"Hello"

is a string.

So are:

"Hello World"

and:

"Java is fun"

The quotation marks tell Java where the text begins and ends.

For example:

System.out.println("Hello World");

Here:

"Hello World"

is the string that we want to print.

What happens if I remove the quotes?

Suppose I write:

System.out.println(Hello World);

Java cannot interpret Hello World as a string literal.

It will produce a compilation error.

The correct version is:

System.out.println("Hello World");

What about numbers?

Numbers can be written without quotes when we want them treated as numeric values.

For example:

System.out.println(10);

Here 10 is a number.

But:

System.out.println("10");

contains the text "10" as a string.

They may look similar when printed, but Java treats them differently.

This becomes important later when learning:

Data types
Variables
Strings
Arithmetic
Type conversion

What about single quotes?

Java uses double quotes for strings:

"Hello"

Single quotes are generally used for a character literal:

'A'

So:

"Hello"
↓
String

'A'
↓
char

I don't need to go deeply into String vs char at this stage, but remembering this distinction is useful.

🧠 Easy to Remember

Double quotes " " → String/text

Single quotes ' ' → Character

🎯 Short Interview Answer

Double quotes are used to represent string literals in Java. They tell the compiler that the enclosed characters should be treated as text rather than as identifiers or other expressions.

5. What is the basic Java write → compile → run workflow?

What I understood first

This is probably the biggest concept I took away from this lesson.

Before this, I was thinking:

Write code → press Run → get output.

But Java has an important process behind that.

The traditional workflow introduced in this lesson is:

Write
  ↓
Compile
  ↓
Run

Let's understand each step.

Step 1: Write the Java source code

I create a file such as:

Hello.java

and write Java code inside it.

For example:

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

At this point, I have source code.

Step 2: Compile the source code

I use:

javac Hello.java

The Java compiler processes the source code.

If the code is valid, it can produce:

Hello.class

which contains Java bytecode.

So:

Hello.java
    ↓
  javac
    ↓
Hello.class

Step 3: Run the compiled program

Now I can run the class:

java Hello

The JVM loads the compiled class and executes the bytecode.

The result is:

Hello World

So the complete picture is:

        Hello.java
             ↓
          javac
             ↓
        Hello.class
             ↓
            JVM
             ↓
       Hello World

Why don't I write `.class` with the `java` command?

This is another small detail that confused me initially.

When I compile:

javac Hello.java

the source file has the .java extension.

When I run:

java Hello

I normally provide the class name, not:

java Hello.class

The Java launcher uses the class name to locate and load the class.

So the traditional workflow is:

javac Hello.java
java Hello

Where does VS Code fit into this?

VS Code gives me a convenient environment to perform these activities.

I can:

Create the file
Write the code
Open the terminal
Run javac
Run java
View the output

The terminal inside VS Code is especially useful because I don't have to leave the editor to execute the commands.

Conceptually:

VS Code
│
├── Explorer → Manage files
├── Editor → Write code
├── Extensions → Java support
└── Terminal → Compile and run

🧠 Easy to Remember

The most important sequence from this lesson is:

Write
 ↓
Compile
 ↓
Run

Or:

.java
 ↓
javac
 ↓
.class
 ↓
java
 ↓
Output

🎯 Short Interview Answer

The basic Java workflow is to write source code in a .java file, compile it using javac to produce bytecode, and then run the compiled class using the java command, which uses the JVM to execute it.

🖥️ Understanding the VS Code Workspace

Before writing the program, I also needed to become familiar with the basic VS Code workspace.

Some useful areas are:

Area	Purpose
Explorer	View folders and source files
Search	Find text and files
Extensions	Add language support and tools
Run & Debug	Run and debug programs
Terminal	Execute commands inside VS Code

I don't need to memorize every VS Code feature immediately.

For Java, the important ones at this stage are:

Explorer → create/find files

Editor → write code

Terminal → compile and run

📁 Creating a Simple Java Workspace

For a first Java program, I can create a folder such as:

JavaPractice

Then open that folder in VS Code.

Inside it, I can create:

JavaPractice
└── Hello.java

This keeps the source file organized and gives me a working directory from which I can run the Java commands.

🔍 Checking Java Before Writing Code

Before starting, I can quickly check:

java --version
javac --version

If both commands work, I know that the Java runtime command and compiler are available.

This connects directly to what I learned in Video 02.

⚠️ Common Beginner Mistakes

Forgetting `.java`

Incorrect:

Hello

Correct:

Hello.java

Confusing `java` and `javac`

Remember:

javac → compile
java  → run

Forgetting the semicolon

For example:

System.out.println("Hello World")

needs:

System.out.println("Hello World");

Forgetting double quotes

Incorrect:

System.out.println(Hello World);

Correct:

System.out.println("Hello World");

Running commands from the wrong directory

If my terminal is not currently inside the directory containing Hello.java, this may fail:

javac Hello.java

So I need to make sure I am working in the correct folder.

Expecting JShell and Java source files to behave identically

JShell is designed for interactive experimentation.

A regular Java application uses source files and a more structured program.

So:

JShell
→ quick experiments

.java file
→ structured Java program

🧠 One-Minute Revision Sheet

If I need to revise this lesson quickly, I want to remember:

.java
↓
Java source file

javac
↓
Java compiler

java
↓
Runs compiled Java class

JShell
↓
Interactive Java experimentation

"Hello"
↓
String literal

;
↓
Statement terminator

Basic workflow
↓
Write → Compile → Run

Example:
javac Hello.java
java Hello

🎯 5 Interview Questions — Super Short Answers

What does `.java` mean?

.java is the file extension used for Java source-code files.

What is `javac`?

javac is the Java compiler that converts Java source code into bytecode.

What is JShell used for?

JShell is an interactive Java environment used for quickly experimenting with Java code.

Why are double quotes needed around text?

Double quotes identify a string literal in Java.

What is the basic Java write → compile → run workflow?

Write code in a .java file, compile it using javac, and run the resulting class using java.

What I Learned From This Lesson

This lesson was where Java started feeling more practical to me.

In the previous lesson, I was mainly preparing the environment:

JDK
VS Code
PATH

Now I could finally start interacting with Java itself.

The most important mental model I got from this lesson is:

Java Source Code
      ↓
   .java file
      ↓
     javac
      ↓
   Bytecode
      ↓
      JVM
      ↓
    Output

And when I want to experiment quickly:

JShell
   ↓
Try something
   ↓
See the result

That distinction helped me understand why JShell is useful for learning while .java files are used for building structured applications.

A Note for Other Beginners

If you're writing your first Java program, don't worry if the process initially seems like too many steps.

Just remember these three commands/concepts:

java --version
javac --version

and:

Write → Compile → Run

Then remember:

javac compiles.

java runs.

JShell lets me experiment quickly.

Once these become familiar, the next lessons become much easier because I can focus on the actual Java language instead of wondering how the program is being executed.

📚 Related Java Learning Resources

This article is part of my Java Learning Notes — Telusko Core Java series.

If you are following the series from the beginning:

👉 Video 01 — Java Introduction: 8 Questions I Had as a Beginner and Their Easy Answers

👉 Video 02 — Setting Up Java: 6 Questions I Had About JDK, VS Code, LTS and PATH

I also wrote a separate article while researching the history behind Java:

👉 Java Introduction: What Is Java, Who Created It, and How Sun Microsystems Became Oracle?

🔗 My Java Learning Notes

I am maintaining the complete structured notes and resources in my GitHub repository.

👉 Java Learning Notes — Telusko Core Java

The GitHub repository contains my concise learning notes and resources, while these DEV.to articles go deeper into the questions and concepts that I found confusing during my learning.

Final Takeaway

For me, this lesson connected the setup from Video 02 with actual Java programming.

The basic idea I want to carry forward is:

Create .java file
       ↓
Write Java code
       ↓
Compile using javac
       ↓
Generate bytecode
       ↓
Run using java
       ↓
JVM executes it
       ↓
See the output

And when I simply want to test a small idea:

JShell
  ↓
Experiment
  ↓
Learn

Now that I understand the basic workflow, I'm ready to learn the part that initially looked mysterious:

What actually needs to be inside a Java application for the code to run?

That's what the next lesson starts exploring.

Setting Up Java: 6 Questions I Had About JDK, VS Code, LTS and PATH

Poushmita Paul — Mon, 17 Aug 2026 17:07:47 +0000

Java Learning Notes — Telusko Core Java | Video 02

After understanding the basic introduction and history of Java in the first lesson, the next question for me was:

How do I actually set up Java on my computer and start writing programs?

This lesson focuses on the development environment required before writing Java code.

At first, I thought the setup would simply be:

Download Java → Install it → Start coding.

But while going through the lesson, I came across several terms that I needed to understand properly:

Editor
IDE
VS Code
JDK
Java versions
LTS
PATH
java
javac

Some of these terms are easy to confuse when you're just starting.

So, just like I did for the previous lesson, I researched the concepts that were unclear to me and wrote down the explanations in a way that I would have liked to find as a beginner.

This article is based on my learning from the lesson along with additional resources I used to understand these concepts better.

What This Article Covers

In this article, I will answer six questions from Video 02:

What does IDE stand for?
What is the difference between an editor and an IDE?
What does JDK stand for?
What does LTS mean?
Why might javac fail even after Java installation?
Which two commands verify Java and the compiler?

For each question, I have included:

A beginner-friendly explanation
Examples where useful
🧠 An easy way to remember it
🎯 A short interview-ready answer

1. What does IDE stand for?

What I understood first

IDE stands for:

Integrated Development Environment

The name initially sounded more complicated than the concept itself.

An IDE is essentially a software environment that brings several tools needed for software development together in one place.

Instead of separately using a text editor, terminal, debugger, compiler, and other development tools, an IDE can provide many of these features together.

What can an IDE provide?

Depending on the IDE and programming language, it can provide features such as:

Code editing
Syntax highlighting
Code completion
Error detection
Compilation
Running programs
Debugging
Project management
Testing
Version-control integration
Build-tool integration

So instead of constantly switching between different applications, many development activities can happen inside one environment.

Examples of Java development environments

Some commonly used tools in Java development include:

IntelliJ IDEA
Eclipse
Apache NetBeans
Visual Studio Code with Java extensions

There is an important distinction here, though.

VS Code is primarily a source-code editor, but its extensions allow it to provide many IDE-like features.

🧠 Easy to Remember

IDE = Integrated Development Environment

Think of it as:

One environment → multiple development tools

🎯 Short Interview Answer

IDE stands for Integrated Development Environment. It is a software environment that combines code editing with development features such as building, running, debugging, testing, and project management.

2. What is the difference between an editor and an IDE?

What I understood first

This was something I wanted to clarify because, as a beginner, many tools can look similar.

For example, I can write Java code in a simple text editor, VS Code, Eclipse, or IntelliJ IDEA.

So I wondered:

If all of them let me write code, what makes an IDE different from an editor?

The main difference is the amount of development functionality integrated into the tool.

What is a code editor?

A code editor mainly focuses on:

Writing and editing source code.

A basic editor can provide features such as:

Text editing
Syntax highlighting
Search and replace
Basic code completion

Its primary purpose is to help me create and modify source files.

What is an IDE?

An IDE goes beyond editing.

It tries to provide a more complete development workflow.

A simplified view is:

Code Editor
     +
Build / Compile Tools
     +
Debugger
     +
Project Management
     +
Testing
     +
Code Analysis

So an IDE can help me write, build, run, debug, and test my application from one environment.

Where does VS Code fit?

This was particularly useful for me to understand.

VS Code is designed primarily as a code editor.

However, it has a large extension ecosystem.

With the appropriate Java extensions, VS Code can provide features such as:

Java code completion
Debugging
Java project support
Testing
Maven and Gradle integration
Java language support

So a modern code editor can become much more capable than a basic text editor.

That's why I wouldn't simply think:

Editor = basic

IDE = powerful

A better way to think about it is:

An editor primarily focuses on writing code, while an IDE provides a more integrated development workflow. Modern editors can gain many IDE-like capabilities through extensions.

🧠 Easy to Remember

Editor → mainly write and edit code

IDE → write + build + run + debug + manage

🎯 Short Interview Answer

A code editor mainly focuses on writing and editing source code, while an IDE integrates coding with features such as building, debugging, testing, project management, and code analysis.

3. What does JDK stand for?

What I understood first

JDK stands for:

Java Development Kit

The word Development is the important part for me to remember.

The JDK provides the tools and components needed to develop Java applications.

Since I want to write and compile Java programs, installing a JDK is one of the most important setup steps.

What does the JDK provide?

The JDK provides development tools for tasks such as:

Compiling Java code
Running Java programs
Debugging
Packaging applications
Other development activities

One of the first tools I will use is:

javac

javac is the Java compiler.

For example:

javac Hello.java

The compiler takes Java source code and produces Java bytecode.

Conceptually:

Hello.java
    ↓
  javac
    ↓
Hello.class

The .class file contains Java bytecode that can be executed by the JVM.

JDK and JVM are not the same thing

This distinction is important.

The JVM is responsible for executing Java bytecode.

The JDK provides the tools required for Java development, including the compiler.

A simple mental model is:

JDK
 │
 ├── Development Tools
 │
 ├── javac
 │
 └── Runtime Components
        │
        ↓
       JVM

This is a simplified beginner-level model, but it helps me keep the terms separate.

Why do I need the JDK?

If I only wanted to run an already compiled Java application, I wouldn't necessarily need the full development toolkit.

But if I want to:

Write Java code
Compile Java code
Build applications
Learn Core Java

then I need a JDK.

🧠 Easy to Remember

JDK = Java Development Kit = tools for developing Java applications

Also remember:

javac = Java compiler

🎯 Short Interview Answer

JDK stands for Java Development Kit. It provides the tools and components required to develop Java applications, including the Java compiler.

4. What does LTS mean?

What I understood first

When I started looking at Java downloads and versions, I noticed that there were many different versions of Java.

Then I saw another term:

LTS

LTS stands for:

Long-Term Support

This means that a particular Java release is intended to receive a longer support period compared with regular feature releases, depending on the JDK vendor and support arrangement.

Why are LTS releases important?

Imagine that a company is running a large banking application.

The company probably doesn't want to change its Java version every few months just because a new feature release is available.

It may prefer a version that provides a longer support period and a more stable foundation.

That's where LTS releases become particularly useful.

A simplified view is:

Regular Feature Release
        ↓
New features and improvements
        ↓
Frequent upgrades

LTS Release
        ↓
Longer support horizon
        ↓
Useful for long-term projects

This does not mean regular releases are bad.

They simply serve different purposes.

Some well-known Java LTS releases

Examples include:

Java 8
Java 11
Java 17
Java 21
Java 25

However, the exact support duration depends on the JDK vendor.

So when choosing Java for a real project, I should consider:

Project requirements
Framework compatibility
JDK vendor
Support policy
Security updates
Organization requirements

What about Java 17 in this lesson?

The original lesson uses Java 17, which was an LTS release at the time of the recording.

That does not mean Java 17 is automatically the correct version for every new project today.

Java continues to evolve, so for a current project I should check the project's requirements and the currently supported JDK releases.

This is an important distinction between:

What the original lesson used

and:

What I should choose for a new project today.

🧠 Easy to Remember

LTS = Long-Term Support

Think:

LTS → longer support + long-term stability

🎯 Short Interview Answer

LTS stands for Long-Term Support. LTS Java releases are intended for users and organizations that prefer a longer support period instead of upgrading to every regular feature release.

5. Why might `javac` fail even after Java installation?

What I understood first

This is one of the most practical problems I can face while setting up Java.

Suppose I install the JDK successfully.

Then I open Command Prompt and run:

javac --version

But Windows says something like:

'javac' is not recognized as an internal or external command

My first thought might be:

"Java wasn't installed."

But that's not necessarily the problem.

The JDK may actually be installed correctly.

The problem may be that the operating system cannot find the javac executable.

What is PATH?

PATH is an environment variable that tells the operating system where to look for executable programs when I type a command.

For example, when I type:

javac

Windows needs to find:

javac.exe

The JDK normally contains Java development executables inside its bin directory.

Conceptually:

JDK Installation
      ↓
     bin
      ↓
 ┌──────────┐
 │ java.exe │
 │ javac.exe│
 └──────────┘

If the JDK's bin directory is included in PATH, I can run java and javac from the terminal without typing the complete file location.

What happens if PATH is not configured?

Suppose the JDK is installed here:

C:\Program Files\Java\jdk-XX

Its executables may be inside:

C:\Program Files\Java\jdk-XX\bin

If that bin directory isn't available through PATH, Windows may not know where to find javac.

So:

Terminal
   ↓
javac
   ↓
Search PATH
   ↓
JDK\bin
   ↓
javac.exe

If the JDK bin directory isn't found in PATH, the command can fail.

Why should I restart the terminal after changing PATH?

This is another small thing that can save a lot of confusion.

If I modify PATH while a Command Prompt or terminal is already open, that existing terminal may still have the old environment variables.

So after changing PATH, I should generally:

Close the old terminal and open a new one.

Then I can try again:

java --version

and:

javac --version

Other possible causes

If javac still doesn't work, I should also check:

Whether the JDK was actually installed
Whether the JDK's bin directory exists
Whether the correct directory was added to PATH
Whether I opened a new terminal
Whether I installed the correct operating-system/architecture package
Whether I accidentally installed something that doesn't contain the development tools

🧠 Easy to Remember

If:

java --version

works but:

javac --version

doesn't, I should check:

JDK + PATH

And remember:

javac comes with the JDK.

🎯 Short Interview Answer

javac may fail even after Java installation if the JDK's bin directory is not available through PATH, the terminal has not been restarted after changing PATH, or the JDK installation is incorrect.

6. Which two commands verify Java and the compiler?

What I understood first

After installing Java, I need a simple way to check whether everything is working.

Fortunately, there are two commands I can remember.

Check the Java runtime

Run:

java --version

This displays the version associated with the java command.

For example, the output may look similar to:

java 25 ...

The exact output depends on the installed JDK distribution and version.

Check the Java compiler

Run:

javac --version

This checks whether the Java compiler is available.

For example:

javac 25

Again, the exact version depends on what I have installed.

Why should I check both?

Because they verify different commands:

java --version
        ↓
Java runtime command

javac --version
        ↓
Java compiler command

If both commands return a version, that's a strong indication that the JDK installation and PATH configuration are working correctly.

🧠 Easy to Remember

Just remember:

java --version
javac --version

And:

java → run

javac → compile

🎯 Short Interview Answer

java --version checks the Java runtime command, while javac --version checks the Java compiler.

🛠️ My Beginner Java Setup Flow

After going through this lesson, I would think about the setup in this order:

Choose a suitable JDK
        ↓
Install the JDK
        ↓
Install VS Code
        ↓
Install Java extensions
        ↓
Configure PATH if required
        ↓
Open a new terminal
        ↓
java --version
        ↓
javac --version
        ↓
Start writing Java

This makes the setup process feel much less confusing.

Instead of thinking:

"Java isn't working."

I can break the problem into smaller questions:

Is the JDK installed?

Can the terminal find java?

Can the terminal find javac?

Is PATH configured correctly?

Is VS Code configured to use the correct JDK?

That makes troubleshooting much easier.

⚠️ Common Beginner Problems I Want to Remember

JDK installed but `javac` is not recognized

Check whether the JDK's bin directory is available through PATH.

PATH was changed but the command still fails

Close the old terminal and open a new one.

Wrong JDK package was downloaded

Check the operating system and CPU architecture before downloading.

Confusing VS Code with the JDK

Remember:

VS Code → environment/editor for working with code

JDK → Java development tools

Installing VS Code alone does not install the JDK.

Confusing JDK and JVM

Remember:

JDK → development

JVM → execution

🧠 One-Minute Revision Sheet

If I need to revise this lesson quickly, this is what I want to remember:

IDE
↓
Integrated Development Environment

Editor
↓
Mainly for writing/editing code

IDE
↓
Editing + building + running + debugging + testing

JDK
↓
Java Development Kit
↓
Java development tools
↓
Includes javac

LTS
↓
Long-Term Support

PATH
↓
Helps the operating system find executables

java --version
↓
Check Java runtime command

javac --version
↓
Check Java compiler

🎯 6 Interview Questions — Super Short Answers

What does IDE stand for?

Integrated Development Environment.

What is the difference between an editor and an IDE?

An editor mainly focuses on writing and editing code, while an IDE integrates coding with features such as building, debugging, testing, and project management.

What does JDK stand for?

Java Development Kit. It provides the tools required to develop Java applications.

What does LTS mean?

LTS means Long-Term Support and refers to releases intended to receive longer-term support.

Why might `javac` fail after Java installation?

The JDK may not be installed correctly, or its bin directory may not be available through the system PATH.

Which commands verify Java and the compiler?

java --version
javac --version

What I Learned From This Lesson

The biggest thing I took away from this lesson is that setting up Java is not simply about downloading Java and clicking Install.

There are several pieces involved:

             Java Development Setup
                       │
        ┌──────────────┼──────────────┐
        ↓              ↓              ↓
       JDK           VS Code          PATH
        │              │              │
        ↓              ↓              ↓
 Development        Write Code      Find Java
   Tools            & Debug         Commands

The JDK provides the tools I need to develop Java programs.

VS Code gives me a convenient environment for writing and working with my code.

PATH helps the operating system find commands such as java and javac.

Once these pieces work together, I am ready to move from setup to actual Java programming.

A Note for Other Beginners

If your Java setup doesn't work perfectly on the first attempt, don't panic.

A setup problem doesn't necessarily mean Java itself is broken.

Start with:

java --version
javac --version

Then check:

Is the JDK installed?

Is the JDK's bin directory available through PATH?

Did I open a new terminal after changing PATH?

Did I install the correct package for my operating system and architecture?

Breaking the problem into smaller questions makes troubleshooting much easier.

📚 Related Java Learning Resources

This article is part of my Java Learning Notes — Telusko Core Java series.

If you are following the series from the beginning, you can start with the previous article:

👉 Java Introduction: 8 Questions I Had as a Beginner and Their Easy Answers

I also wrote a separate article while researching the history behind Java:

👉 Java Introduction: What Is Java, Who Created It, and How Sun Microsystems Became Oracle?

🔗 My Java Learning Notes

I am maintaining the complete structured notes and resources in my GitHub repository.

👉 Java Learning Notes — Telusko Core Java

The GitHub repository contains my concise learning notes and resources, while these DEV.to articles go deeper into the questions and concepts that I found confusing during my learning.

Final Takeaway

For me, the second lesson became much clearer once I separated the roles of the different tools:

JDK → gives me the tools to develop Java

VS Code → gives me a place to write and work with my code

PATH → helps my operating system find Java commands

And the two commands I never want to forget are:

java --version
javac --version

If both commands work, I have a good starting point for writing my first Java program.

Now that the environment is ready, the next step is finally the fun part:

Writing my first Java code.

Java Introduction: 8 Questions I Had as a Beginner and Their Easy Answers

Poushmita Paul — Mon, 17 Aug 2026 16:55:48 +0000

Java Learning Notes — Telusko Core Java | Video 01

When I started learning Core Java, the first lesson looked simple.

It talked about Java, the JVM, enterprise applications, WORA, James Gosling, Sun Microsystems, and Java releases.

But while going through the lesson, I realized something:

Knowing the words is not the same as understanding them.

For example, I understood the sentence:

"Java was created at Sun Microsystems."

But then I immediately had another question:

"What is Sun Microsystems?"

And when I learned that Oracle acquired Sun Microsystems, I had another:

"So did Oracle create Java?"

This article is my attempt to answer these kinds of beginner questions in simple language.

I am writing these explanations based on what I learned from the lesson, my own understanding, and additional resources I used while trying to clear up the concepts.

The goal is not just to give an answer to memorize, but to explain why the answer makes sense.

What This Article Covers

These are the questions I am going to answer:

Why is Java widely used in enterprise software?
What is the JVM?
Which other languages can run on the JVM?
Why can Java feel difficult at first?
What does WORA mean?
Who led the original Java development team?
When was Java introduced?
What is the general modern Java release cadence?

At the end, I have also added a quick revision section and short interview-ready answers.

1. Why is Java widely used in enterprise software?

What I understood first

One thing that stood out to me while learning Java is how often it appears in the enterprise world.

You will see Java being used in areas such as:

Banking
Insurance
E-commerce
Healthcare
Telecommunications
Government systems
Large backend applications

But initially, I wondered:

"Why Java? There are so many programming languages today."

The answer is not just one feature.

Java became popular because it combines several characteristics that are useful when building and maintaining large software systems.

1. Platform independence

One of Java's biggest ideas is that Java source code is compiled into bytecode, which can be executed by a compatible JVM.

So instead of thinking:

Java Program → Windows only

we can think:

Java Source Code
       ↓
    Compiler
       ↓
    Bytecode
       ↓
      JVM
   ↙    ↓    ↘
Windows Linux macOS

This portability was one of Java's major strengths.

2. A large ecosystem

Java has been around for decades, so a huge ecosystem has grown around it.

There are:

Libraries
Frameworks
Build tools
Testing tools
Monitoring tools
Development tools
Community resources

For example, when I later started looking at backend development, I encountered technologies such as Spring and Spring Boot, which are part of the broader Java ecosystem.

So learning Java doesn't mean learning only the language syntax.

You are also entering a much larger ecosystem.

3. Maintainability

This was another point that made more sense to me after learning more about Java.

Java can feel verbose.

You may have to write more code than you would in some other languages.

But that explicit structure can also make large codebases easier to understand.

Imagine a project with:

10 files

versus:

10,000+ files

The second situation is very different.

When hundreds of developers work on a large application, readability, structure, typing, testing, and maintainability become extremely important.

That is one reason Java's style has remained useful in large systems.

4. Performance and the JVM

Java also benefits from the JVM's runtime optimizations.

Modern JVMs can use techniques such as Just-In-Time (JIT) compilation to optimize code while programs are running.

So Java isn't simply:

"A language that runs slowly because it uses a virtual machine."

The JVM is a sophisticated runtime platform.

What I remember from this

When I think about Java's popularity in enterprise software, I don't try to memorize ten different reasons.

I remember:

Java = Portability + Mature Ecosystem + Maintainability + Performance

Easy to Remember

Why is Java popular in enterprise software?

Because Java provides portability, a mature ecosystem, maintainability, and strong runtime performance.

Short Interview Answer

Java is widely used in enterprise software because of its platform-independent execution model, mature ecosystem, maintainability, performance, and long-term adoption.

2. What is the JVM?

This was one of the first concepts that confused me.

I kept seeing:

JVM
JDK
JRE
Java

and initially they all seemed connected but unclear.

For this lesson, let's focus only on JVM.

JVM = Java Virtual Machine

JVM stands for:

Java Virtual Machine

The easiest way I understand it is:

The JVM is the environment that executes Java bytecode.

Let's see what that means.

Suppose I write:

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

This is Java source code.

The Java compiler converts it into bytecode.

Conceptually:

Java Source Code
       ↓
     javac
       ↓
   Bytecode
       ↓
      JVM
       ↓
   Execution

The bytecode is stored in a .class file.

The JVM then loads and executes that bytecode.

But why do we need a JVM?

This is where the idea of Java's portability becomes interesting.

Different operating systems have different environments.

A Windows JVM is designed to work with Windows.

A Linux JVM is designed to work with Linux.

A macOS JVM is designed to work with macOS.

So we can imagine:

              Java Bytecode
                    │
        ┌───────────┼───────────┐
        ↓           ↓           ↓
    Windows JVM  Linux JVM  macOS JVM
        ↓           ↓           ↓
     Windows      Linux       macOS

The Java bytecode can remain the same while the JVM handles the platform-specific execution.

This is one of the foundations behind Java's famous:

Write Once, Run Anywhere

idea.

One important clarification

The JVM is not Java itself.

I found this distinction important because beginners can easily mix these terms.

Think of it this way:

Java
  ↓
Programming Language

JVM
  ↓
Runtime environment that executes bytecode

🧠 Easy to Remember

JVM = Java Virtual Machine = executes Java bytecode

If you remember only one thing from this section, remember that.

🎯 Short Interview Answer

JVM stands for Java Virtual Machine. It is the runtime environment responsible for executing Java bytecode and is a key part of Java's platform-independent execution model.

3. Which other languages can run on the JVM?

This was another interesting thing I learned from the first lesson.

I initially thought:

JVM = Java

But that's not completely true.

The JVM can support multiple programming languages.

Some examples are:

Java
Kotlin
Scala
Groovy

Why can this happen?

The JVM works with bytecode.

A language that can compile its code to JVM-compatible bytecode can use the JVM as its runtime environment.

So we can think of it like:

Java ────────┐
Kotlin ──────┤
Scala ───────┤──→ JVM
Groovy ──────┘

This is why the JVM is better thought of as a runtime platform, rather than simply "the thing that runs Java."

Why is this useful for me as a learner?

This changed the way I thought about learning Core Java.

Suppose I later work with Kotlin.

Understanding concepts such as:

Bytecode
JVM
Classes
Objects
Memory
Exceptions
Collections

can still be useful because Kotlin is part of the JVM ecosystem.

So learning Core Java can give you knowledge that goes beyond Java syntax itself.

Easy to Remember

JVM is not only for Java.

Remember:

Java + Kotlin + Scala + Groovy → JVM ecosystem

Short Interview Answer

Languages such as Kotlin, Scala, and Groovy can run on the JVM by targeting JVM-compatible bytecode.

4. Why can Java feel difficult at first?

This is probably the question I relate to the most as a learner.

When I compare a very simple Java program with something like Python, Java can look unnecessarily complicated.

For example:

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

While Python can simply use:

print("Hello")

So naturally, a beginner may think:

"Why does Java require so much code?"

Java can be verbose

Java requires beginners to understand concepts such as:

Classes
Methods
Access modifiers
Data types
The main() method
Objects
Packages

That's a lot to process when you are writing your first few programs.

But there is another side to it.

Structure becomes useful as applications grow

Imagine writing a tiny program.

You may prefer:

Less code → faster to write

But imagine working on a huge application with thousands of classes and many developers.

Now you care much more about:

Structure → readability → maintainability

Java's explicit structure can help developers understand what different parts of a large codebase are supposed to do.

So I think the better way to look at it is:

Beginning
   ↓
Java feels verbose
   ↓
Learn the structure
   ↓
Understand classes, methods, types, etc.
   ↓
Large code becomes easier to reason about

What I would tell another beginner

Don't decide that Java is "bad" simply because the first few programs look long.

At the beginning, you are learning both the language and the structure used by the language.

Once those patterns become familiar, they stop feeling as complicated.

🧠 Easy to Remember

Java can be verbose to write, but its structure can help with readability and maintainability in large applications.

🎯 Short Interview Answer

Java can feel difficult initially because it is relatively verbose and requires beginners to learn several concepts such as classes, methods, data types, and object-oriented programming. However, its structured nature can support readability and maintainability in large applications.

5. What does WORA mean?

This was one of the first Java terms I wanted to properly understand.

WORA means:

Write Once, Run Anywhere

At first, this sounds almost too good to be true.

Does it mean I write Java code once and it magically runs everywhere?

Not exactly.

The JVM is the important part.

How WORA works

The simplified process is:

Java Source Code
       ↓
    Compiler
       ↓
    Bytecode
       ↓
      JVM
       ↓
Operating System

The Java compiler doesn't simply create code that is directly tied to one operating system.

Instead, it produces bytecode.

The JVM on the target platform then executes that bytecode.

For example:

             Same Bytecode
                  │
       ┌──────────┼──────────┐
       ↓          ↓          ↓
    Windows      Linux      macOS
      JVM         JVM        JVM

That's the core idea behind WORA.

Is WORA literally 100% true?

This is something I think is important to clarify for beginners.

WORA is a design principle, not a guarantee that every Java application will work everywhere without any configuration or changes.

A Java application can still depend on:

Operating-system-specific behavior
Native libraries
External services
Environment variables
File-system assumptions
Hardware-specific integrations

So I would understand WORA as:

Java's bytecode-based execution model provides strong platform portability through the JVM.

Easy to Remember

WORA = Write Once, Run Anywhere

And remember the mechanism:

Java → Bytecode → JVM → Platform

Short Interview Answer

WORA stands for Write Once, Run Anywhere. It refers to Java's ability to compile source code into bytecode that can be executed on different platforms through compatible JVM implementations.

6. Who led the original Java development team?

This question took me to the history of Java.

Java was developed at:

Sun Microsystems

The original development effort was led by:

James Gosling

He is widely known as the father of Java.

However, one thing I want to be careful about is saying:

"James Gosling created Java completely by himself."

That would oversimplify the history.

Java was developed by a team of engineers at Sun Microsystems, with James Gosling leading the original effort.

The early project was connected to Sun's Green Project.

The language was initially called:

Oak

and was later renamed Java.

The history in one picture

Sun Microsystems
       ↓
Green Project
       ↓
      Oak
       ↓
     Java
       ↓
Publicly introduced in 1995

This is also why I created a separate article about Sun Microsystems, James Gosling, Oak, and Oracle while working through this lesson.

If you are confused by the sentence:

"Java was created at Sun Microsystems"

you can read my detailed explanation here:

👉 Java Introduction: What Is Java, Who Created It, and How Sun Microsystems Became Oracle?

Easy to Remember

James Gosling → Java

and:

Sun Microsystems → Company where Java was developed

Short Interview Answer

Java was developed by James Gosling and a team of engineers at Sun Microsystems. Gosling led the original development effort and is widely known as the father of Java.

7. When was Java introduced?

The answer I need to remember is:

1995

But there is a little more history behind that number.

Java didn't suddenly appear in 1995.

The development began earlier.

Sun's Green Project began in the early 1990s, and the language was initially known as Oak.

Java was publicly introduced in 1995. Oracle's historical documentation describes the early Green Project and Oak work and identifies 1995 as the public introduction of Java.

So I remember the timeline like this:

Early 1990s
     ↓
Green Project
     ↓
Oak
     ↓
1995
     ↓
Java publicly introduced

1991 vs 1995 — don't mix them up

This is a small detail that can easily cause confusion.

You may find different sources saying:

Java started in 1991.

and others saying:

Java was introduced in 1995.

Both statements can appear because they refer to different events.

A simple way to remember it:

1991 → early project/development

1995 → Java publicly introduced

What happened to Sun Microsystems?

This was another question I had after hearing about Java's history.

If Sun Microsystems developed Java, why do I see Oracle everywhere today?

Because Oracle acquired Sun Microsystems.

That is a separate part of the story, and I have explained it in detail in my companion article:

👉 What Was Sun Microsystems and How Did Java Become Associated With Oracle?

🧠 Easy to Remember

1991 → Early Java project

1995 → Java publicly introduced

🎯 Short Interview Answer

Java was publicly introduced in 1995. Its development began earlier in the 1990s as part of Sun Microsystems' Green Project, where the language was initially called Oak.

8. What is the general modern Java release cadence?

This was a concept I initially didn't pay much attention to.

But after learning more about modern Java, I realized that Java doesn't follow the old model of:

"Wait several years → release a huge new version."

Modern Java uses a time-based release model.

What does six-month release cadence mean?

Modern Java has feature releases approximately every six months.

For example:

March 2024
   ↓
Java 22

September 2024
   ↓
Java 23

March 2025
   ↓
Java 24

September 2025
   ↓
Java 25

March 2026
   ↓
Java 26

Oracle's documentation confirms that Java uses a time-based model in which the feature version increments every six months.

This regular schedule means Java can continue evolving without waiting years for another major release.

Does every release completely change Java?

No.

This is another thing I found useful to understand.

Java continues to evolve, but the core language doesn't get completely replaced every six months.

New releases can introduce:

Language improvements
JVM improvements
Library improvements
Performance improvements
Security fixes
Developer-experience improvements

For example, Java's recent releases have introduced or finalized features such as record patterns, pattern matching, module import declarations, and other language improvements.

So I think of Java's evolution as:

Stable foundation
       +
Continuous improvements
       ↓
New Java releases

What about LTS releases?

This is another term you will hear frequently:

LTS = Long-Term Support

Not every Java feature release is treated the same way by organizations.

Some Java releases are designated as LTS releases and are particularly important for teams that want longer-term support.

For example:

Java 8
Java 11
Java 17
Java 21
Java 25

are commonly recognized LTS releases.

The important thing for me as a beginner is simply:

Feature releases bring new improvements regularly, while LTS releases are especially important when organizations want a longer support horizon.

Easy to Remember

Modern Java → roughly one feature release every 6 months

And:

LTS → Long-Term Support

Short Interview Answer

Modern Java follows a time-based release model with feature releases approximately every six months. Some releases are designated as Long-Term Support releases for users and organizations that need longer support periods.

🧠 My One-Minute Revision Sheet

After going through all these questions, this is what I personally want to remember before moving to the next lesson:

Java
│
├── Enterprise
│   └── Large-scale applications
│
├── JVM
│   └── Executes Java bytecode
│
├── JVM Languages
│   ├── Java
│   ├── Kotlin
│   ├── Scala
│   └── Groovy
│
├── WORA
│   └── Write Once, Run Anywhere
│
├── Java History
│   ├── Sun Microsystems
│   ├── James Gosling
│   ├── Oak
│   └── Java → 1995
│
└── Modern Java
    └── Feature release ≈ every 6 months

🎯 8 Interview Questions — Super Short Answers

If I only have a few minutes before an interview, these are the answers I would revise.

1. Why is Java widely used in enterprise software?

Java offers portability, a mature ecosystem, maintainability, and strong runtime performance, making it suitable for large-scale applications.

2. What is JVM?

JVM stands for Java Virtual Machine and is responsible for executing Java bytecode.

3. Which other languages run on the JVM?

Kotlin, Scala, Groovy, and several other languages can target the JVM.

4. Why can Java feel difficult initially?

Java can be verbose and requires beginners to understand concepts such as classes, methods, data types, and OOP, but its structure can help maintain large applications.

5. What is WORA?

WORA means Write Once, Run Anywhere. Java bytecode can run on different platforms through compatible JVMs.

6. Who led the original Java development?

James Gosling led the original Java development effort at Sun Microsystems along with a team of engineers.

7. When was Java introduced?

Java was publicly introduced in 1995.

8. What is Java's modern release cadence?

Java has a time-based release model with feature releases approximately every six months.

What I Learned From This First Lesson

The biggest thing I took away from this lesson is that learning Java is not only about learning Java syntax.

There is a whole ecosystem behind it.

At first, I only knew:

Java is a programming language.

Now I have a better mental picture:

                 Java
                  │
       ┌──────────┼──────────┐
       ↓          ↓          ↓
    Language     JVM      Ecosystem
       │          │          │
       ↓          ↓          ↓
      Code     Bytecode   Frameworks
                            Libraries
                            Tools

And then there is the history:

Sun Microsystems
       ↓
Green Project
       ↓
Oak
       ↓
Java
       ↓
1995
       ↓
Java evolves continuously
       ↓
Oracle becomes its steward after
acquiring Sun Microsystems

Understanding this background makes the later concepts feel less disconnected.

A Note for Other Beginners

If you're also starting Java, don't worry if terms like JVM, JDK, JRE, bytecode, WORA, Sun Microsystems, or Oracle seem confusing in the beginning.

I had the same problem.

Instead of trying to memorize everything immediately, I found it more useful to stop whenever I encountered an unfamiliar term and ask:

"What exactly is this?"

Then understand that one concept before moving forward.

That's the approach I'm trying to follow throughout this Java learning series.

📚 Related Article

While writing these notes, I had a separate question:

"What exactly was Sun Microsystems, and why is Oracle associated with Java today?"

So I researched that topic separately and wrote a detailed beginner-friendly explanation:

👉 Java Introduction: What Is Java, Who Created It, and How Sun Microsystems Became Oracle?

That article goes deeper into:

Sun Microsystems
James Gosling
The Green Project
Oak
Java's history
Oracle's acquisition of Sun Microsystems

🔗 My Java Learning Notes

I am also maintaining the complete learning notes and resources in my GitHub repository.

👉 Java Learning Notes — Telusko Core Java

The GitHub repository contains the structured notes, while these DEV.to articles are where I am going deeper into the concepts and questions that I find confusing during my learning.

Final Takeaway

For me, the first Java lesson became much easier once I stopped looking at it as a list of facts.

Instead, I connected the ideas:

Java → JVM → Bytecode → WORA → Enterprise

and:

Sun Microsystems → James Gosling → Oak → Java → 1995 → Oracle

Now I'm ready to move from understanding the background of Java to actually setting up Java and writing my first programs.

Java Introduction: What Is Java, Who Created It, and How Sun Microsystems Became Oracle?

Poushmita Paul — Mon, 17 Aug 2026 16:30:32 +0000

Part of my Java Learning Series — Telusko Core Java

If you are starting to learn Java, you will probably hear names such as James Gosling, Sun Microsystems, Oak, Oracle, JVM, and Java very frequently.

At first, these names can feel confusing.

I personally found it easier to understand Java after learning not only the syntax, but also where Java came from, why it was created, and what happened to the company that originally developed it.

This article explains those basics in simple language.

1. What Is Java?

Java is a high-level, general-purpose programming language designed to be portable across different platforms.

One of the most famous ideas associated with Java is:

Write Once, Run Anywhere.

The basic idea is that a Java program is compiled into bytecode, which can then run on a compatible Java Virtual Machine (JVM) rather than being compiled separately for every operating system.

For example, the same Java program can potentially run on:

Windows
Linux
macOS

provided that an appropriate Java runtime/JVM is available.

This platform-independent design became one of the most important characteristics of Java.

2. Who Created Java?

Java was primarily developed by James Gosling and a team of engineers while working at Sun Microsystems.

Java's development began in the early 1990s as part of a project that was initially focused on consumer electronic devices.

The language was originally called Oak.

According to Oracle's Java documentation, Oak was designed by James Gosling for embedded consumer-electronic applications before the project was redirected toward the Internet and the language was renamed and substantially revised.

So when you see:

Java was created at Sun Microsystems.

it means that the Java language was developed by engineers working at Sun Microsystems, with James Gosling being the key figure associated with its creation.

3. What Was Sun Microsystems?

This is where many beginners, including me when I first encountered the term, may wonder:

"What exactly is Sun Microsystems?"

Sun Microsystems was an American technology company.

It was not a programming language, framework, or operating system.

It was a technology company that developed and sold computer hardware, software, and related technologies.

Sun became particularly well known for technologies such as:

Java
Solaris
SPARC processors
Computer servers
Workstations
Storage and networking technologies

One of Sun's famous ideas was:

"The Network is the Computer."

Sun played an important role in the development of enterprise computing and networking.

Most importantly for us as Java learners, Java was developed at Sun Microsystems.

4. Why Did Sun Microsystems Create Java?

Java did not originally start as a project simply to create another programming language.

In the early 1990s, Sun had a project known as the Green Project.

The goal was to explore software for emerging consumer electronic devices.

The team was interested in creating software that could work across different types of devices.

This created an important challenge:

Different devices have different hardware.

A program written specifically for one machine may not work on another machine.

The team therefore wanted a language and platform that could provide a greater degree of portability.

The language that emerged from this work was initially called Oak.

Later, the project shifted toward the Internet, and Oak was renamed Java.

5. Why Was It Called Oak?

Before Java was called Java, the language was known as Oak.

Oak was the original name of the programming language developed by James Gosling and the team.

The language was initially intended for embedded consumer electronics.

Later, the project was redirected toward Internet applications, substantially revised, and renamed Java.

So the basic history is:

Green Project
      ↓
     Oak
      ↓
  Internet focus
      ↓
    Java

This is why you may sometimes see references to Oak when reading about Java's history.

6. When Was Java Released?

Java was publicly introduced in 1995.

This was an important moment because the Internet was rapidly becoming popular.

Java's portability and its ability to support network-oriented applications helped it gain attention.

Oracle's historical Java material records 1995 as the year Java made its public debut and notes that Sun announced it during the SunWorld conference.

So:

Year	Event
1991	Green Project and Oak development began
1995	Java was publicly introduced
1996	JDK 1.0 was released
1998	Java 1.2 was released
2004	Java 5 introduced major language improvements
2010	Oracle completed its acquisition of Sun Microsystems

7. What Made Java Special?

One of Java's biggest goals was platform independence.

Traditional programs often depended heavily on the operating system and hardware for which they were compiled.

Java introduced a different approach.

The simplified process looks like this:

Java Source Code
       ↓
     javac
       ↓
   Bytecode
       ↓
      JVM
       ↓
Operating System

The Java compiler converts the source code into bytecode.

The JVM then executes that bytecode.

Because different operating systems can have their own JVM implementations, the same Java bytecode can be executed on different platforms.

This is the foundation behind the famous idea:

Write Once, Run Anywhere

It does not mean that every Java program is automatically portable without consideration. It means Java was deliberately designed around a platform-independent execution model.

8. So What Is Oracle?

If Java was created by Sun Microsystems, another obvious question is:

"Why do I see Oracle everywhere when I learn Java today?"

The answer is simple:

Oracle acquired Sun Microsystems.

Oracle announced an agreement to acquire Sun Microsystems in April 2009.

The acquisition was completed in January 2010.

As a result, Oracle acquired important Sun technologies, including Java and Solaris.

So the history looks like this:

James Gosling + Java Team
          ↓
   Sun Microsystems
          ↓
       Java
          ↓
Oracle acquires Sun
          ↓
        Oracle
          ↓
Oracle becomes the steward of Java

Oracle itself described Java as one of the key software assets it acquired through the Sun transaction.

9. What Happened to Sun Microsystems?

This is an important distinction:

Sun Microsystems did not create Oracle.

Rather:

Oracle acquired Sun Microsystems.

The acquisition was announced in 2009 and finalized in 2010.

After the acquisition, Sun's technologies became part of Oracle's technology portfolio.

That included:

Java
Solaris
SPARC
MySQL
Other Sun hardware and software technologies

Oracle has continued to develop and steward Java.

10. Did Oracle Create Java?

No.

This is a common misunderstanding.

The historical answer is:

Sun Microsystems developed Java.

James Gosling and his team developed the language while working at Sun.

The modern answer is:

Oracle is the company that acquired Sun Microsystems and became the steward of Java.

Therefore, these statements are different:

❌ Oracle created Java.

✅ Java was developed at Sun Microsystems and later became part of Oracle after Oracle acquired Sun Microsystems.

11. Who Is James Gosling?

James Gosling is one of the most important people in Java's history.

He is widely known as the father of Java because he led the development of the language at Sun Microsystems.

He and the original team worked on the technology that eventually became Java.

When learning Java, it is useful to remember:

James Gosling
      ↓
Java development
      ↓
Sun Microsystems
      ↓
Java

Of course, Java was a team effort, and several engineers contributed to the language and its development.

12. What Is the Green Project?

The Green Project was an early Sun Microsystems project that explored software for consumer electronics.

The team was investigating how software could work across different kinds of devices.

This project eventually led to the development of Oak, which later became Java.

One interesting part of this history is Duke, the Java mascot.

Sun's Green Project team created an early working demonstration involving an interactive handheld home-entertainment controller called Star7, and Duke was created as the animated character for its interface.

So even Java's famous mascot has roots in the early history of the language.

13. Why Should a Java Beginner Know This History?

You may wonder:

"I'm learning Java programming. Why do I need to know about a company from decades ago?"

You don't need to memorize every historical detail.

But understanding the history helps you connect several concepts.

For example:

Sun Microsystems
        ↓
Green Project
        ↓
Oak
        ↓
Java
        ↓
Platform Independence
        ↓
JVM
        ↓
Oracle

Now when you hear:

"Java was created at Sun Microsystems."

you know what that sentence actually means.

You understand:

Sun Microsystems was a technology company.
James Gosling was a key person behind Java.
Oak was the original name.
Java was introduced publicly in 1995.
Oracle later acquired Sun Microsystems.
Oracle therefore became the company responsible for stewarding Java.

14. A Simple Java History Timeline

Here is the entire story in one place:

1991
 │
 ├── Sun Microsystems' Green Project
 │
 ↓
Oak
 │
 ├── Designed initially for consumer electronics
 │
 ↓
Internet becomes an important target
 │
 ↓
Oak is renamed and revised
 │
 ↓
1995
Java is publicly introduced
 │
 ↓
Java grows rapidly
 │
 ↓
1996
JDK 1.0
 │
 ↓
Java continues evolving
 │
 ↓
2009
Oracle announces agreement to acquire Sun
 │
 ↓
2010
Oracle completes acquisition of Sun
 │
 ↓
Today
Oracle continues stewardship and development
of Java alongside the broader Java community

15. The Most Important Things to Remember

If you are preparing for interviews or revising your Core Java notes, remember these points:

Java

A high-level, general-purpose programming language designed with portability in mind.

James Gosling

A key creator and leader of the original Java development effort.

Sun Microsystems

The technology company where Java was developed.

Oak

The original name of the Java programming language.

1995

The year Java was publicly introduced.

JVM

The virtual machine that executes Java bytecode.

Oracle

The company that acquired Sun Microsystems in 2010 and became the steward of Java.

16. One-Line Interview Answer

If an interviewer asks:

"Who created Java?"

A good answer is:

Java was developed by James Gosling and his team at Sun Microsystems and was publicly introduced in 1995. Sun Microsystems was later acquired by Oracle in 2010.

This is short, accurate, and gives the interviewer the important historical context.

17. References

For further reading, I recommend checking official Java and Oracle resources rather than relying only on random articles.

Oracle — A Brief History of Java
Oracle — Java Language Environment
Oracle — Oracle Buys Sun
Oracle Java Documentation — Java Language Specification
Dev.java — History and Java community resources

Final Thought

Learning programming is not only about memorizing syntax.

Sometimes a small sentence in a lecture — such as:

"Java was created at Sun Microsystems."

can lead to a much bigger question:

"What is Sun Microsystems?"

And that question leads to another:

"Then why is Oracle associated with Java today?"

Understanding these connections makes the technology easier to remember.

Java started as an ambitious project at Sun Microsystems, evolved from Oak, became one of the world's most influential programming platforms, and eventually became part of Oracle through the acquisition of Sun Microsystems.

That history is worth knowing before diving deeper into the language itself.

☁️ Day 2 of Learning Cloud Computing: Cloud Deployment Models - Public, Private, Hybrid & Cross Cloud

Poushmita Paul — Sun, 16 Aug 2026 17:22:42 +0000

In my previous article, I explained what cloud computing is, along with concepts such as AWS, virtual machines, containers, IaaS, PaaS, and SaaS.

When I started learning cloud computing, I understood what cloud computing meant, but one question was still confusing me:

Where does the cloud infrastructure actually live, and who manages it?

This is where Cloud Deployment Models come in.

While learning this topic, I came across four important models:

Public Cloud
Private Cloud
Hybrid Cloud
Multi-Cloud / Cross-Cloud

I found these concepts much easier to understand when I stopped trying to memorize their definitions and started thinking about where the infrastructure is located and who manages it.

So, in this article, I'm sharing my understanding of these deployment models in a simple way.

☁️What is a Cloud Deployment Model?

A cloud deployment model basically tells us:

Where is the IT infrastructure physically located, and who manages it?

For example, is the infrastructure:

Inside a cloud provider's data center?
Inside the company's own data center?
Or a combination of both?

Let's understand each model one by one.

1️⃣ Public Cloud

Let's start with the one we usually hear about first: Public Cloud.

What is it?

In a public cloud, the infrastructure such as servers, databases and networking is provided through the cloud service provider's infrastructure.

Some examples of cloud service providers are:

AWS
Microsoft Azure
Google Cloud

The important point is that the cloud provider owns and manages the underlying infrastructure.

Who manages it?

The Cloud Service Provider (CSP) manages the underlying infrastructure.

For example:

AWS manages the physical infrastructure behind AWS services.

As a customer, we use the cloud resources according to our requirements.

🏠 The easiest analogy I used to understand Public Cloud

Imagine you want to live in an apartment.

You don't build the apartment yourself.

The landlord takes care of the building and its maintenance.

You simply rent the apartment and use it.

I think of public cloud in a similar way:

The cloud provider owns the infrastructure, and we use/rent the resources we need.

This is one reason public cloud is very useful for startups and businesses that don't want to purchase and maintain their own physical servers.

2️⃣ Private Cloud

Now let's move to the opposite side.

What is a Private Cloud?

A private cloud is a cloud environment dedicated to one organization.

Here, the infrastructure is not being used as a general public-cloud environment by many different customers.

The organization has much more control over its environment.

Who manages it?

The organization's own IT team can manage the infrastructure, although management can also be handled by a provider depending on the setup.

🏠 The easiest analogy: Your Own House

Think about owning your own house.

You have much more control.

You decide:

How things are arranged
Who can enter
What changes should be made
How the house should be maintained

But there is also a disadvantage.

You have to pay for everything yourself:

Electricity
Plumbing
Repairs
Maintenance

That's how I remember the basic idea of a private cloud:

More control, but also more responsibility.

One technology that can be used to build private-cloud environments is OpenStack.

3️⃣ Hybrid Cloud

This one became much easier for me once I understood the first two.

Hybrid Cloud = Private Cloud + Public Cloud

So instead of choosing only one environment, an organization uses both.

For example:

Private Cloud + Public Cloud

But why would a company want to do this?

Imagine a company has some sensitive data that it wants to keep in its private environment.

At the same time, it may need extra computing power when there is heavy processing or a sudden increase in traffic.

Instead of buying a lot of extra hardware, the company can use the public cloud for those additional workloads.

🔗 How do Private and Public Clouds communicate?

This is an important part of hybrid cloud.

The two environments need to be connected.

They can communicate using something like:

VPN (Virtual Private Network)
A dedicated private connection, such as AWS Direct Connect

The idea is:

Private Cloud
      ↕
 Secure Connection
      ↕
Public Cloud

So the two environments can work together as one connected system.

🚗 The analogy that helped me understand Hybrid Cloud

Imagine you have some original and sensitive documents stored safely at your home.

Your home represents the private cloud.

Now suppose your office needs copies of those documents, and you need to send them securely.

You use a secure, protected vehicle to transport the copies.

The office represents the public cloud, and the secure vehicle represents the VPN/private connection.

The idea is:

Keep the sensitive information in your private environment, but use the public environment when you need additional resources.

That's the basic idea behind hybrid cloud.

4️⃣ Multi-Cloud / Cross-Cloud

Now there is another concept that initially sounded very similar to hybrid cloud.

It's Multi-Cloud.

What is Multi-Cloud?

Multi-cloud means using two or more different public cloud providers.

For example:

AWS + Azure + Google Cloud

A company doesn't necessarily have to use only one cloud provider.

It can use different providers for different requirements.

🤔 Why would a company use multiple cloud providers?

There are a few reasons.

1. Avoid vendor lock-in

If a company uses only one cloud provider for everything, it may become heavily dependent on that provider.

Using multiple providers can reduce this dependence.

2. Use the best tool for each job

Different cloud providers offer different services and capabilities.

A company might decide:

"I'll use this provider for one workload and another provider for a different workload."

The idea is to choose the tool that works best for a particular requirement.

3. Cost

Companies can also compare different providers and choose an appropriate option for different workloads.

So multi-cloud can sometimes help with cost optimization.

The notes describe these three ideas as avoiding lock-in, using the best tools, and choosing cost-effective options.

⚠️ Hybrid Cloud vs Multi-Cloud

This is probably the most important difference to remember from today's topic.

I used to think these two were basically the same, but they are not.

Hybrid Cloud

Uses:

Private Cloud + Public Cloud

Example:

Private Cloud + AWS

Multi-Cloud

Uses:

Multiple Public Cloud Providers

Example:

AWS + Azure + Google Cloud

**So the easiest way I remember it is:

🔄 Hybrid = Private + Public

🌍 Multi-Cloud = Public + Public + Public

📊 Quick Comparison**

Here's the comparison I made while learning this topic:

Feature	Public Cloud	Private Cloud	Hybrid Cloud
Location	Cloud provider's data center	Company's/dedicated data center	Both
Ownership	CSP owns infrastructure	Organization/dedicated ownership	Split
Cost	Lower upfront / pay-as-you-go	Higher	Medium to high
Scalability	Very high	More limited	High
Connection	Internet	Internal network	VPN / private connection

The important thing isn't to memorize this table word by word.

Try to understand the basic difference.

🧠 A Simple Way to Remember All Four

If you are preparing for an exam, interview, or just trying to understand the concept, remember these four lines:

☁️ Public Cloud

Someone else owns the infrastructure and I use it.

🔐 Private Cloud

My organization has a dedicated cloud environment and more control over it.

🔄 Hybrid Cloud

I use both private and public cloud environments.

🌍 Multi-Cloud

I use multiple public cloud providers.

That's honestly enough to build a strong basic understanding.

🤔 Which One Should a Company Choose?

There isn't one deployment model that is perfect for everyone.

It depends on the company's requirements.

For example:

A startup

May prefer Public Cloud because it can start using infrastructure without purchasing physical servers.

An organization needing a dedicated environment

May consider a Private Cloud because it provides greater control.

A company with sensitive data + changing workloads

May choose Hybrid Cloud so it can keep certain workloads private while using public-cloud resources when required.

A company wanting to use different cloud providers

May choose a Multi-Cloud strategy to reduce vendor dependence or use different providers for different workloads.

🔥 The One Thing I Learned Today

The biggest thing I understood from this topic is that cloud doesn't always mean the same thing.

When someone says:

"Our company uses cloud."

That doesn't immediately tell us:

Where the infrastructure is located
Who owns it
Who manages it
Whether they use one provider or multiple providers

That's exactly why deployment models are important.

They help us understand how the cloud environment is actually set up.

🎯 Final Summary

My simple way of remembering today's topic is:

PUBLIC
↓
Cloud provider's infrastructure

PRIVATE
↓
Dedicated to one organization

HYBRID
↓
Private + Public

MULTI-CLOUD
↓
Multiple Public Cloud Providers

If you're also learning cloud computing, don't try to memorize complicated definitions at first.

Just ask yourself three questions:

Where is the infrastructure?

Who manages it?

How many environments/providers are being used?

Once you answer those three questions, these deployment models become much easier to understand.

🚀 Day 2 Complete!

This was Day 2 of my cloud computing learning journey.

I'm trying to learn these concepts step by step and, at the same time, explain them in a way that another beginner can understand without getting overwhelmed by complicated terminology.

If you're also learning cloud computing, which deployment model makes the most sense to you — Public, Private, Hybrid, or Multi-Cloud?

Let me know in the comments! 👇

See you in Day 3! ☁️

☁️ Cloud Computing Explained: A Beginner-Friendly Guide to AWS, IaaS, PaaS & SaaS

Poushmita Paul — Thu, 13 Aug 2026 19:49:45 +0000

If you are a beginner in cloud computing, you have probably heard terms like AWS, Azure, EC2, S3, Virtual Machines, Containers, IaaS, PaaS, and SaaS.

At first, all of these terms can feel confusing.

So, in this article, I’m going to explain cloud computing from the very beginning, using simple examples and analogies.

By the end, you should have a clear idea of:

What cloud computing actually means
On-premises vs cloud computing
How computing evolved from physical servers to containers and serverless
What AWS is
What a Cloud Service Provider (CSP) does
The major cloud service categories
IaaS, PaaS, and SaaS
Some important AWS services such as EC2, S3, RDS and VPC

☁️ 1. What is Cloud Computing?

Let's start with a simple question:

What if you want to run a website?

You need computing resources such as:

A server
Storage
A database
Networking
Operating system
Security
And other infrastructure

Traditionally, you would have to buy and maintain your own physical servers.

But cloud computing changes this.

Simple Definition

Cloud computing is the practice of using computing resources such as servers, storage, databases, networking and software over the internet instead of managing all the physical infrastructure yourself.

Think about electricity.

You don't build your own power plant every time you need electricity.

You simply use electricity and pay for what you consume.

Cloud computing follows a similar idea.

Instead of buying and maintaining expensive servers, you can rent computing resources from a cloud provider whenever you need them.

🏢 2. On-Premises vs Cloud

Before understanding the cloud, let's understand the traditional approach.

🏠 On-Premises

Suppose you own a company and want to run an application.

With an on-premises setup:

You buy the physical servers.
You provide the space for those servers.
You hire people to manage them.
You pay for electricity and maintenance.
You are responsible for hardware failures.
You have to plan your capacity in advance.

In simple terms:

You own and manage everything.

Example

Imagine you open a restaurant.

You need to buy:

The building
Kitchen equipment
Tables
Refrigerators
Electricity infrastructure

You are responsible for maintaining everything.

That's similar to an on-premises infrastructure.

☁️ Cloud Computing

Now imagine that instead of buying all the infrastructure, you rent a fully equipped kitchen whenever you need it.

Someone else takes care of:

The building
Electricity
Maintenance
Equipment
Infrastructure

You simply use what you need and pay according to your usage.

That's the basic idea behind cloud computing.

On-Premises

You manage the infrastructure.

Cloud

The cloud provider manages the underlying infrastructure, while you use the resources you need.

🚀 3. The Evolution of Computing

Cloud computing didn't appear overnight.

Computing infrastructure evolved through several stages.

A simplified journey looks like this:

Dedicated Servers → Virtual Machines → Containers → Serverless

Let's understand each one.

🖥️ 4. Dedicated Servers

A dedicated server is a physical server used by a single customer or organization.

For example:

Your Application
       ↓
Physical Server
       ↓
Hardware

The entire physical machine belongs to your workload.

Advantages

High level of control
Good performance
Strong isolation
You control the underlying machine

Problems

However, dedicated servers can be expensive.

Imagine you have a server with 64 GB RAM, but your application only uses 10 GB.

The remaining resources may sit unused.

That means:

You are paying for resources that you aren't fully using.

Scaling can also be difficult because increasing capacity may require purchasing additional hardware.

🖥️ 5. Virtual Machines (VMs)

Virtualization made infrastructure much more efficient.

Instead of running one application on an entire physical server, we can divide the physical machine into multiple Virtual Machines.

A software layer called a hypervisor allows multiple VMs to run on the same physical machine.

Conceptually:

        Physical Server
              ↓
          Hypervisor
       ↙      ↓      ↘
      VM      VM      VM
      ↓       ↓       ↓
    App A   App B   App C

Each VM behaves like a separate computer.

It can have its own:

Operating system
Applications
CPU allocation
Memory
Storage

Why are VMs useful?

They allow us to utilize the physical server more efficiently.

Instead of:

Server → One application

we can have:

Server
 ├── VM 1
 ├── VM 2
 └── VM 3

This improves resource utilization and makes scaling easier.

But VMs have overhead

Each VM usually needs its own guest operating system.

So if you run 10 VMs, you may have 10 operating systems consuming resources.

This leads us to the next evolution.

📦 6. Containers

Containers take the idea of efficient resource utilization even further.

A container packages an application together with the dependencies it needs to run.

Unlike traditional VMs, containers can share the host operating system kernel.

A simplified structure looks like this:

        Physical Server
              ↓
        Host Operating System
              ↓
        Container Runtime
       ↙       ↓       ↘
 Container   Container   Container
    ↓           ↓           ↓
   App A       App B       App C

One popular container platform is Docker.

Why are containers useful?

Containers are:

Lightweight
Fast to start
Portable
Easy to deploy
Efficient in resource usage

For example, if you build an application on your laptop, you can package it into a container and run that same container in another environment.

This helps reduce the classic:

"It works on my machine!" 😅

problem.

⚡ 7. Serverless / Functions

The next step is to think:

What if I don't want to manage servers or even containers?

That's where serverless computing comes in.

With services such as AWS Lambda, you can upload code and let the cloud provider manage the underlying infrastructure.

You generally focus on:

Your Code
   ↓
Function
   ↓
Cloud Provider manages infrastructure

You don't have to manually manage the server operating system or physical hardware.

And importantly:

Serverless does not mean there are no servers.

Servers still exist.

It simply means that the cloud provider manages the servers for you.

🌎 8. What is AWS?

Now that we understand cloud computing, let's talk about one of the biggest cloud platforms.

AWS stands for Amazon Web Services.

AWS is a cloud computing platform provided by Amazon.

It offers a large collection of cloud services that organizations and developers can use to build, deploy and operate applications.

For example, AWS provides services for:

Computing
Storage
Databases
Networking
Security
Machine Learning
Analytics
Containers
Serverless computing
Monitoring
Developer tools

So AWS is much more than simply "renting a server."

It provides an entire ecosystem of cloud services.

☁️ 9. What is a Cloud Service Provider (CSP)?

A Cloud Service Provider (CSP) is a company that provides cloud computing resources and services over the internet.

Some major cloud providers include:

Amazon Web Services (AWS)
Microsoft Azure
Google Cloud Platform (GCP)

Other providers also exist, especially for specialized or smaller-scale workloads.

A CSP operates the underlying infrastructure, such as:

Data centers
Physical servers
Networking equipment
Storage systems
Security infrastructure

Customers can access these resources through web consoles, APIs, command-line tools and other interfaces.

🧩 10. How Cloud Services Work Together

One of the most important things to understand about cloud computing is that services don't usually work alone.

You can combine multiple services to create a complete application.

For example, imagine we are deploying a website.

We might have:

Users
   ↓
Load Balancer
   ↓
Web Server
   ↓
Application
   ↓
Database
   ↓
Storage

In AWS, this could involve services such as:

EC2 → computing
Elastic Load Balancing → distributing traffic
RDS → database
S3 → object storage
VPC → networking

So instead of thinking of AWS as "one service," think of it as a toolbox containing many different services.

🧱 11. The Four Basic Building Blocks of IaaS

When learning Infrastructure as a Service, four fundamental areas are especially useful to understand:

1️⃣ Compute

Compute gives you the processing power required to run applications.

Example:

AWS EC2

You can think of an EC2 instance as a virtual computer that you rent from AWS.

2️⃣ Storage

Storage is used to store files and data.

For example:

AWS S3

S3 can be used to store things such as:

Images
Videos
Documents
Backups
Application files

Think of S3 as a huge online storage system designed for applications.

3️⃣ Networking

Networking allows your cloud resources to communicate with each other and with users over networks.

AWS provides networking services such as:

Amazon VPC (Virtual Private Cloud)

A VPC allows you to create a logically isolated network environment for your AWS resources.

Think of it as creating your own private network inside AWS.

4️⃣ Databases

Applications often need databases to store structured information.

For example:

Amazon RDS

RDS is a managed relational database service.

Instead of manually installing and maintaining a database server, AWS handles many of the administrative tasks for you.

💡 12. IaaS, PaaS and SaaS

This is one of the most important concepts for beginners.

There are three common cloud service models:

IaaS

Infrastructure as a Service

PaaS

Platform as a Service

SaaS

Software as a Service

Let's understand them using a simple analogy.

🍳 Think About Ordering Food

Imagine you want to eat a meal.

There are three possibilities.

🛒 IaaS — Buy the Ingredients

You get:

Kitchen
Ingredients
Cooking equipment

But you do most of the work yourself.

In IaaS, the provider gives you infrastructure such as:

Virtual machines
Storage
Networking

You manage more of the software stack.

👨‍🍳 PaaS — Use a Ready Kitchen

The kitchen and basic infrastructure are already prepared.

You mainly focus on preparing your application.

With PaaS, the provider manages much of the underlying infrastructure and platform.

You focus primarily on:

Building and deploying your application.

🍽️ SaaS — Order the Finished Meal

You simply use the software.

You don't worry about:

Servers
Operating systems
Infrastructure
Application maintenance

The provider handles almost everything.

Examples include:

Gmail
Microsoft 365
Salesforce

You simply use the application through the internet.

🔍 13. IaaS vs PaaS vs SaaS

Model	You Mainly Manage	Example
IaaS	OS, applications, data and configuration	Amazon EC2
PaaS	Application and data	Heroku / similar PaaS platforms
SaaS	Mostly just your usage and data	Gmail, Microsoft 365

The key idea is:

More Control
    ↑
   IaaS
    ↓
   PaaS
    ↓
   SaaS
    ↓
Less Infrastructure Management

As you move from IaaS → PaaS → SaaS, the cloud provider takes responsibility for more of the underlying technology.

🔐 14. Who is Responsible for What?

This is where the concept of the shared responsibility model becomes important.

Cloud providers are responsible for the security of the cloud, such as:

Physical data centers
Physical servers
Underlying infrastructure

Customers are responsible for many things in the cloud, depending on the service they use.

For example, customers may need to manage:

Application security
Access permissions
Data
Configuration
Operating systems in some IaaS services

The exact responsibility depends on the service.

So using the cloud does not mean:

"The cloud provider handles security completely."

Instead:

Security is a shared responsibility.

🌍 15. Different Types of Cloud Deployments

Cloud environments can also be categorized based on how infrastructure is deployed.

Public Cloud

Cloud infrastructure is provided by a cloud provider and shared across customers using logical isolation.

Examples:

AWS
Azure
Google Cloud

Private Cloud

Cloud infrastructure is dedicated to a particular organization.

Organizations may use technologies such as:

OpenStack
VMware-based solutions
Other private-cloud platforms

Hybrid Cloud

A combination of:

Private infrastructure + Public Cloud

For example, an organization might keep some sensitive systems in its own environment while using AWS or Azure for other workloads.

🏢 16. Why Do Companies Use Cloud Computing?

Cloud computing provides several important advantages.

💰 1. Cost Efficiency

You don't necessarily need to purchase expensive hardware upfront.

You can use resources according to your requirements.

📈 2. Scalability

Suppose your website normally receives 1,000 users per day.

Suddenly, it becomes popular and receives 100,000 users.

Cloud infrastructure can provide mechanisms to scale resources to handle increased demand.

⚡ 3. Speed

Instead of waiting weeks to purchase and install physical servers, cloud resources can often be provisioned much faster.

🌍 4. Global Availability

Cloud providers operate infrastructure across multiple geographic regions.

This allows applications to be deployed closer to users and designed for higher availability.

🛠️ 5. Less Hardware Management

You don't have to physically maintain the underlying servers and data centers when using cloud services.

🗺️ 17. A Simple AWS Application Architecture

Let's put everything together.

Suppose we want to deploy an e-commerce website.

A simplified architecture could look like this:

                👤 Users
                   |
                   ↓
          Load Balancer
                   |
                   ↓
              EC2 Instances
                   |
          ┌────────┴────────┐
          ↓                 ↓
        RDS                S3
     Database          Images/Files
          |
          ↓
      Application Data

And these resources can be placed inside a:

VPC (Virtual Private Cloud)

This is how multiple cloud services can work together to create one complete application.

🧠 18. The Most Important AWS Services to Remember

As a beginner, don't try to memorize hundreds of AWS services.

Start with these:

AWS Service	Simple Meaning
EC2	Virtual server
S3	Object/file storage
RDS	Managed relational database
VPC	Virtual network
ELB	Distributes traffic across resources
Lambda	Run code without managing servers
CloudWatch	Monitoring and observability
IAM	Identity and access management

Once these concepts become clear, learning other AWS services becomes much easier.

🎯 19. What Should a Beginner Learn First?

If you are starting cloud computing from zero, don't try to learn everything at once.

A simple learning path is:

Cloud Computing Basics
        ↓
Networking Basics
        ↓
Linux Basics
        ↓
Virtual Machines
        ↓
AWS Fundamentals
        ↓
EC2 + S3 + IAM
        ↓
VPC + RDS
        ↓
Load Balancing
        ↓
Containers + Docker
        ↓
Serverless
        ↓
Cloud Projects
        ↓
DevOps / Cloud Engineering

The goal isn't to memorize AWS services.

The goal is to understand:

Why does this service exist, what problem does it solve, and how does it connect with other services?

🚀 Final Takeaway

Cloud computing is basically a shift from:

"I need to own and manage the infrastructure."

to:

"I need computing resources, so I'll use them from a cloud provider."

The evolution can be remembered as:

Physical Servers
       ↓
Virtual Machines
       ↓
Containers
       ↓
Serverless

And the common service models can be remembered as:

IaaS → Infrastructure
PaaS → Platform
SaaS → Software

If you're learning AWS, start with:

EC2 → Compute
S3  → Storage
RDS → Database
VPC → Networking
IAM → Access Control

Once these fundamentals are clear, the rest of cloud computing becomes much easier to understand.

💬 One Question for You

If you're also learning cloud computing, which topic confused you the most when you started?

Let me know in the comments. It might become the topic of my next beginner-friendly article! ☁️🚀

📚 Learning Notes

This article is based on my Day 1 learning journey into cloud computing. I’m documenting the concepts I learn and trying to explain them in the simplest way possible so that other beginners can learn along with me.

[Boost]

Poushmita Paul — Thu, 13 Aug 2026 19:25:08 +0000

DEV Community: Poushmita Paul

☁️ Day 3 — My First Steps in AWS: IAM, Regions, Billing, Free Tier & Security

🟢 1. Creating an AWS Account

🔐 2. What is IAM?

👑 3. Root User vs IAM User

👑 Root User

👥 4. IAM Groups & Permissions

🌍 5. What is an AWS Region?

AWS Regions

🤔 Why should I care about Regions?

🌎 6. Regional vs Global Services

💰 7. AWS Uses Metered Billing

💸 Billing

😨 8. The AWS Bill Can Surprise You!

📊 9. AWS Budgets — My First Cost Safety Net

🆓 10. What is the AWS Free Tier?

Conditions

📌 11. Free Tier Usage Alerts

🚨 12. Billing Alarms with CloudWatch

🔔 13. Where does SNS come into this?

🔐 14. MFA — One More Layer of Security

MFA — Multi-Factor Authentication

🧠 What I Learned From Day 3

💡 My Biggest Takeaway

☁️ Day 3 Complete!

🚀 See you in Day 4!

C++ Operator Overloading Explained from Zero — A Complete Beginner-Friendly Guide with a `Time` Class

👋 Why I Created This Guide

📚 What We Will Learn

🧱 Part 1 — Before Operator Overloading

1. What Is a Class?

What does class mean?

2. What Are hours and minutes?

What is int?

3. What Is an Object?

4. Class vs Object

🟦 Class

🟩 Object

5. Objects Can Also Use Functions

⚙️ Part 2 — Understanding Operators

6. What Is an Operand?

7. What Does the + Operator Already Know?

❓ Part 3 — The Problem We Need to Solve

⭐ Operator Overloading

8. What Is Operator Overloading?

9. Why Is Operator Overloading Useful?

🔢 Part 4 — Unary vs Binary Operators

Binary Operator

Unary Operator

🧠 Easy Rule

➕ Part 5 — operator+()

10. Understanding the Function Header

11. The First Time

12. What Does Time:: Mean?

13. What Does operator+ Mean?

14. Understanding (const Time &t)

15. What Does Time Mean Here?

16. What Does & Mean?

17. What Does const Mean?

⭐ 18. Where Did t1 Go?

🧮 19. Let's Actually Add Two Times

20. Adding the Minutes

🔄 21. What Is Normalization?

22. Why Do We Use / 60?

23. Why Do We Use % 60?

24. Why Do We Create temp?

25. What Does return temp Mean?

🔍 26. Complete operator+() Flow

➖ Part 6 — operator-()

27. Why Is - Binary?

28. Why Do We Need Borrowing?

29. The Borrowing Code

30. Complete Subtraction

🟰 Part 7 — Assignment Operator =

31. Why Is = Binary?

🧭 32. What Does this Mean?

33. What Does *this Mean?

34. Why Do We Check this != &t?

35. Why Does operator= Return Time&?

⬆️ Part 8 — Prefix ++

What does `class` mean?

2. What Are `hours` and `minutes`?

What is `int`?

7. What Does the `+` Operator Already Know?

➕ Part 5 — `operator+()`

11. The First `Time`

12. What Does `Time::` Mean?

13. What Does `operator+` Mean?

14. Understanding `(const Time &t)`

15. What Does `Time` Mean Here?

16. What Does `&` Mean?

17. What Does `const` Mean?

⭐ 18. Where Did `t1` Go?

22. Why Do We Use `/ 60`?

23. Why Do We Use `% 60`?

24. Why Do We Create `temp`?

25. What Does `return temp` Mean?

🔍 26. Complete `operator+()` Flow

➖ Part 6 — `operator-()`

27. Why Is `-` Binary?

🟰 Part 7 — Assignment Operator `=`

31. Why Is `=` Binary?

🧭 32. What Does `this` Mean?

33. What Does `*this` Mean?

34. Why Do We Check `this != &t`?

35. Why Does `operator=` Return `Time&`?

⬆️ Part 8 — Prefix `++`

36. Why Is `++` Unary?

37. What Does `minutes++` Mean?

⬆️ Part 9 — Postfix `++`

40. Why Does Postfix Have `int`?

41. Why Do We Need `temp` for Postfix?

⬇️ Part 10 — Prefix `--`

43. Why Do We Check `minutes < 0`?

⬇️ Part 11 — Postfix `--`

44. `++` and `--` Summary

🖨️ Part 12 — Output Operator `<<`

45. What Does `cout << t1` Mean?

47. What Is `ostream`?

48. Why Is `const Time &t` Used for Output?

49. Why Do We Return `out`?

⌨️ Part 13 — Input Operator `>>`

50. What Is `istream`?

51. Why Is `Time &t` Used for Input?

🔄 Part 14 — `<<` vs `>>`

❓ Why can't I simply use `t1 + t2`?

❓ Why is `+` binary?

❓ Why is `++` unary?

❓ Why does postfix `++` have `int`?

❓ What is `this`?

❓ What is `*this`?

❓ Why is `const` used?

❓ Why is `&` used?

❓ Why do we need `temp`?

❓ Why is output `const`?

❓ Why isn't input `const`?