DEV Community: Subash

Functions in Python

Subash — Fri, 30 Oct 2026 13:56:36 +0000

What is a Function?

A function is a block of code that performs a specific task. We can call it whenever we need to execute that code.

How to Create a Function in Python?

We use the def keyword to define a function in Python. The function body must follow proper indentation.

For example:

def add():  # Function definition
    print(10 + 15)

add()  # Function calling statement

Output:

We can define multiple functions in the same Python file.
We must define a function before calling it.
If multiple functions have the same name, the latest definition replaces the previous one.

Important: Calling a function before its definition has been executed will raise a NameError.

add()  # Calling before definition

def add():
    print(10 + 15)

Why Should We Learn Functions?

Code Reusability: Write once and use multiple times.
Easy Maintenance: Modify code in one place.
Improves Readability: Makes code easier to understand.
Modularity: Organizes code into smaller, manageable blocks.
Easy Testing and Debugging: Test and debug individual functions.

Functions with Parameters and Arguments

We can pass values to a function using parameters and arguments.

Parameters: Variables defined inside the function definition.
Arguments: Actual values passed while calling the function.

For example:

def add(no1, no2):  # Parameters
    print(no1 + no2)

add(100, 200)  # Arguments

Output:

Here, no1 and no2 are parameters, whereas 100 and 200 are arguments.

Function Overloading

Function overloading means defining multiple functions with the same name but different parameter lists.

For example, Java supports function overloading. However, Python does not support traditional function overloading.

If we define multiple functions with the same name, the latest definition replaces the previous one.

def add(no1, no2):
    print(no1 + no2)

def add(no1, no2, no3):
    print(no1 + no2 + no3)

add(100, 200)

Output:

TypeError: add() missing 1 required positional argument: 'no3'

Here, the second add() definition replaces the first one. Python expects three arguments but receives only two.

We can achieve similar functionality using default arguments or other techniques.

Pass Statement in Functions:

The pass statement acts as a placeholder when we don't want a function to perform any operation yet.

For example:

def log_add():
    pass

Here, the function is defined successfully but does nothing when called. We can add the actual implementation later.

Return Function:

The return statement is used to send a result from a function back to the place where the function was called.

If a function does not contain a return statement, Python returns None by default.

Example:

def add_numbers(x, y):
    return x + y

result = add_numbers(10, 20)
print(result)

Output:

Operators in Python

Subash — Fri, 30 Oct 2026 13:55:53 +0000

What are Operators?

Operators are special symbols or keywords used to perform operations on values and variables.

For example, we use operators to perform calculations, compare values, and check conditions.

Types of Operators in Python

Python has six main types of operators:

Arithmetic Operators
Relational (Comparison) Operators
Logical Operators
Bitwise Operators
Assignment Operators
Conditional (Ternary) Operator

1. Arithmetic Operators

Arithmetic operators are used to perform mathematical calculations.

Operator	Description
`+`	Addition
`-`	Subtraction
`*`	Multiplication
`/`	Division
`//`	Floor Division
`%`	Modulus (Remainder)
`**`	Exponentiation (Power)

Example:

a = 10
b = 3

print(a + b)
print(a / b)
print(a // b)
print(a % b)
print(a ** b)

Output:

13
3.3333333333333335
3
1
1000

Note: / performs normal division, // returns the floor value, % gives the remainder, and ** calculates power.

2. Relational (Comparison) Operators

These operators compare two values and return either True or False.

Operator	Meaning
`>`	Greater than
`<`	Less than
`>=`	Greater than or equal to
`<=`	Less than or equal to
`==`	Equal to
`!=`	Not equal to

Example:

a = 10
b = 20

print(a > b)
print(a < b)
print(a == b)
print(a != b)

Output:

False
True
False
True

3. Logical Operators

Logical operators are used to combine conditions.

Python provides three logical operators:

and – True when both conditions are True.
or – True when at least one condition is True.
not – Reverses the result.

Example:

age = 22
has_id = True

print(age >= 18 and has_id)
print(age >= 18 or has_id)
print(not has_id)

Output:

True
True
False

4. Bitwise Operators

Bitwise operators perform operations on the binary representation of numbers (0s and 1s).

Operator	Description
`&`	Bitwise AND
`\	`
`^`	Bitwise XOR
`~`	Bitwise NOT
`<<`	Left Shift
`>>`	Right Shift

Example:

a = 5
b = 3

print(a & b)
print(a | b)
print(a ^ b)
print(~a)
print(a << 1)
print(a >> 1)

Output:

5. Assignment Operators

Assignment operators are used to assign or update values in variables.

Operator	Example	Equivalent
`=`	`a = 10`	Assign value
`+=`	`a += 5`	`a = a + 5`
`-=`	`a -= 5`	`a = a - 5`
`*=`	`a *= 5`	`a = a * 5`
`/=`	`a /= 5`	`a = a / 5`
`%=`	`a %= 5`	`a = a % 5`

Example:

a = 10

a += 5
print(a)

a *= 2
print(a)

Output:

15
30

These shorthand operators make updating variable values easier.

6. Conditional (Ternary) Operator

The ternary operator allows us to write a simple if-else condition in a single line.

Syntax:

value_if_true if condition else value_if_false

Example:

age = 20

result = "Eligible" if age >= 18 else "Not Eligible"

print(result)

Output:

Eligible

If the condition is True, the first value is returned; otherwise, the second value is returned.

Data Types in Java

Subash — Fri, 30 Oct 2026 13:55:41 +0000

What is a Data Type?

A data type tells Java what kind of value a variable can store, such as numbers, decimal values, characters, or text.

Every variable in Java must have a data type before we can use it.

Example:

int age = 25;
String name = "John";
double salary = 25000.50;

Types of Data Types in Java

Java data types are divided into two categories:

Primitive Data Types
Non-Primitive Data Types

1. Primitive Data Types

Primitive data types are the basic data types available in Java. They store simple values directly.

Java provides eight primitive data types.

Integer Types:

Data Type	Size	Description
`byte`	8 bits	Small whole numbers
`short`	16 bits	Short-range integers
`int`	32 bits	Commonly used for integers
`long`	64 bits	Large whole numbers

Floating-Point Types:

Data Type	Size	Description
`float`	32 bits	Decimal values
`double`	64 bits	More precise decimal values

Other Types:

Data Type	Size	Description
`char`	16 bits	Stores a single character
`boolean`	JVM-dependent	Stores `true` or `false`

Example:

int age = 25;
long population = 8000000L;

float price = 99.5f;
double salary = 25000.75;

char grade = 'A';
boolean isPassed = true;

Default Values of Primitive Data Types

When primitive variables are declared as class fields without assigning values, Java provides default values.

Data Type	Default Value
`byte`	0
`short`	0
`int`	0
`long`	0L
`float`	0.0f
`double`	0.0d
`char`	`'\u0000'`
`boolean`	`false`

2. Non-Primitive Data Types

Non-primitive data types are used to store references to objects rather than directly storing simple values.

Some common examples are:

String

A String is used to store a sequence of characters (text).

String name = "Java";

Array

An array is used to store multiple values of the same data type in a single variable.

int[] numbers = {10, 20, 30, 40};

Class and Object

A class is a blueprint used to create objects. An object is an instance of a class.

Creating a Class:

class Student {
    String name;
    int age;
}

Creating an Object:

Student s1 = new Student();

s1.name = "John";
s1.age = 22;

Here, Student is the class, and s1 is the object created from that class.

Default Value of Non-Primitive Data Types

The default value of a non-primitive reference variable is null when declared as a class field without an assigned value.

Example:

class Student {
    String name;
    int age;
}

Here, the default value of name is null, and the default value of age is 0.

Note: Java provides default values for class fields, but local variables must be initialized before they are used.

Variables and Objects in Java

Subash — Fri, 30 Oct 2026 13:55:25 +0000

What is a Variable?

A variable is a named memory location used to store data in a program.

Syntax:

dataType variableName = value;

Example:

int age = 25;
String name = "John";
double salary = 25000.50;

Rules for Creating Variables

Names can contain letters, digits, _ and $.
A variable name cannot start with a digit.
Spaces are not allowed.
Java keywords cannot be used as variable names.
Variable names are case-sensitive (age and Age are different).
Use meaningful names and follow camelCase.

Types of Variables in Java

Java has three types of variables:

Local Variables
Instance Variables (Non-static)
Static Variables

1. Local Variables

Declared inside a method, constructor, or block.

Accessible only within that method or block.
Must be initialized before use.
Do not receive default values.

void display() {
    int age = 25;
    System.out.println(age);
}

Here, age is a local variable.

2. Instance Variables (Non-static)

Declared inside a class but outside methods and constructors.

Each object gets its own copy.
Can have different values for different objects.
Receive default values if not initialized.

class Student {
    String name;
    int age;
}

Here, name and age are instance variables.

3. Static Variables

Declared inside a class using the static keyword.

Only one shared copy exists for the class.
All objects share the same variable.
Can be accessed using the class name.

class Student {
    static String college = "ABC College";
}

Here, college is a static variable shared by all Student objects.

Remember: Instance variables belong to objects, whereas static variables belong to the class.

What is an Object?

An object is an instance of a class.

A class is a blueprint used to create objects.

Every object has three characteristics:

State: Properties or data (model, price).
Behavior: Actions (drive, brake).
Identity: Distinguishes one object from another.

Creating a Class and Object

Let's understand this with a simple Car example.

Example:

public class Cars {

    String model;  // Instance variable
    int price;     // Instance variable

    void drive() {  // Instance method
        System.out.println("Car is driving...");
    }

    public static void main(String[] args) {

        Cars myCar = new Cars();  // Object creation

        myCar.model = "XUV";
        myCar.price = 600000;

        myCar.drive();  // Method calling
    }
}

Output:

Car is driving...

Understanding the code:

Cars – Class name.
model and price – Instance variables.
drive() – Instance method (non-static).
new Cars() – Creates an object.
myCar – Reference variable that refers to the object.
myCar.drive() – Calls the object's method.

Day 2 of Learning Python: Variables, Identifiers, and Data Types

Subash — Wed, 28 Oct 2026 15:51:38 +0000

Day 2 of Learning Python: Variables, Identifiers, and Data Types

Welcome to Day 2 of my Python learning journey!

Today, I learned about identifiers, variables, assignment operators, reserved words, and basic data types in Python.

Let's understand each concept with simple examples.

1. What Is an Identifier?

An identifier is a name used to identify a variable, function, class, or other named object in a Python program.

For example:

name = "Loki"
question = 5
doubt = False

Here, name, question, and doubt are identifiers.

Rules for Naming Identifiers

Identifiers can contain uppercase and lowercase letters (A-Z, a-z).
They can contain digits (0-9), but cannot start with a digit.
Underscores (_) are allowed, including at the beginning.
Spaces and special characters such as @ and # are not allowed in ordinary identifiers.
Python identifiers are case-sensitive.

Examples:

name = "Loki"       # Valid
_name = "Stark"     # Valid
name2 = "Tony"      # Valid
2name = "Thor"      # Invalid

The last example is invalid because an identifier cannot start with a digit.

2. What Is a Variable?

A variable is a name that refers to an object in Python.

For example:

name = "Loki"

Here, name refers to a string object containing "Loki".

We can assign a different object to the same name:

doubt = False
doubt = True

print(doubt)

Output:

True

The second assignment makes doubt refer to True instead of False.

In Python, variables are often described as names or references rather than fixed containers that permanently store a particular type of value.

3. What Is the Assignment Operator?

The assignment operator (=) assigns an object to a name.

Example:

name = "Loki"
question = 5
doubt = True

In the statement:

question = 5

Left side: question — the identifier.
= — the assignment operator.
Right side: 5 — an integer object.

Remember: In Python, = means assignment, whereas == is used to compare two values for equality.

Example:

x = 10
print(x == 10)

Output:

True

4. Single and Double Underscores in Python

Python uses underscores in naming conventions, but their meanings are different.

Single Leading Underscore (`_name`)

_name = "Stark"

A single leading underscore is a convention indicating that a name is intended for internal use.

It does not make the variable truly private.

Double Leading Underscore (`__name`)

class Company:
    def __init__(self):
        self.__name = "Stark Industries"

Inside a class, a name beginning with two underscores triggers name mangling. Python changes the internal attribute name to help avoid accidental naming conflicts in subclasses.

It is not a strict privacy mechanism.

Double Underscores at Both Ends (`name`)

Names such as __init__ and __str__ are commonly called dunder or special names.

Python uses these names for special methods and other language-defined purposes.

We should generally avoid inventing such names for our own ordinary variables.

5. What Are Keywords?

Keywords are reserved words that have special meaning in Python's syntax.

Examples include:

if
else
for
while
break
continue
return
class
def
import

We cannot use keywords as ordinary variable names.

For example:

if = 10

This produces a syntax error because if is a keyword.

A small correction: Python has 35 keywords in Python 3.13, but the number can change between Python versions. Also, elif is Python's keyword for the condition commonly called "else if" in other languages.

6. Basic Data Types in Python

A data type describes the kind of object a value represents.

Let's look at some common built-in types.

Integer (`int`)

Used for whole numbers.

age = 25
quantity = -10

print(type(age))

Output:

<class 'int'>

Floating-Point Number (`float`)

Used for numbers with a fractional part.

price = 99.50
temperature = 36.6

String (`str`)

Used to represent text.

Strings can be enclosed in single or double quotes.

name = "Loki"
city = 'Chennai'

Boolean (`bool`)

Represents one of two values: True or False.

is_learning = True
has_doubt = False

Note that True and False must start with uppercase letters in Python.

Day 1 of Learning Python: Introduction and Python Architecture

Subash — Wed, 28 Oct 2026 15:49:33 +0000

I've started learning Python, and I thought it would be a good idea to share what I learn every day. Writing things down should help me understand the concepts better, and maybe it will help other beginners too.

I missed the first class, so I'm catching up on the basics before moving forward.

What is Python?

Python is a high-level, general-purpose programming language. One thing I like about Python is that its syntax is easy to read compared to many other programming languages.

It is used in different fields, such as:

Web development
Artificial intelligence and machine learning
Data science
Automation
Software development

Let's start with a simple example.

print("Hello, World!")

Output:

Hello, World!

The print() function displays the message on the screen. Pretty simple, right?

How does Python work?

This was one of the interesting topics I wanted to understand.

When we write code, the computer cannot directly execute our Python source code as written. In the commonly used CPython implementation, the code goes through a process involving parsing, compilation into bytecode, and execution.

Here is a simplified view of the process:

Python source code → Parsing and compilation → Bytecode → Python Virtual Machine (PVM) → Output

Let's break it down:

1. Python source code

This is the code we write in a .py file.

2. Parsing and compilation

Python checks the syntax and compiles valid code into bytecode.

3. Bytecode

Bytecode is an intermediate form of instructions generated from our Python code.

4. Python Virtual Machine (PVM)

The PVM executes the bytecode instructions.

5. Output

Finally, we get the result of our program.

For example, when we run print("Hello, World!"), the output is displayed in the terminal.

This is a simplified explanation of how CPython works, but it helped me understand the basic execution flow.

What I learned today

What Python is and where it is used.
How to print output using print().
The basic process Python follows to execute a program.
What bytecode and the Python Virtual Machine do.

Java Architecture – How Java Works?

Subash — Wed, 28 Oct 2026 15:42:09 +0000

1. Introduction

When I started learning Java, I came across a lot of terms like JDK, JRE, JVM, bytecode, and class files. Initially, it was a little confusing to understand how all these things work together.

So, I decided to write a simple blog explaining what Java is and how its architecture works. I'm sharing what I have learned so far, and I hope this will help other beginners too.

2. What Is Java?

Java is a high-level, object-oriented, general-purpose programming language developed by Sun Microsystems. It is now owned and maintained by Oracle.

Java is widely used to develop web applications, enterprise applications, desktop software, and many other types of applications.

One of the main reasons Java is popular is its platform independence.

We often hear the phrase "Write Once, Run Anywhere" (WORA). It means that we can compile Java code once and run the generated bytecode on different operating systems, provided they have a compatible Java Virtual Machine (JVM).

3. Java Architecture

To understand Java architecture, we need to understand how Java code gets executed.

When we write a Java program, it doesn't directly become machine code. First, it is compiled into bytecode, which is then executed by the JVM.

How Does It Work?

Let's understand the process step by step.

Step 1: Write the Java code

First, we write our program in a file with the .java extension.

For example, Hello.java.

This file contains the source code that we write and understand.

Step 2: Compile the code

The Java compiler, called javac, compiles the source code and generates a .class file.

For example, Hello.class.

This file contains bytecode rather than ordinary Java source code.

Step 3: Load the class

The JVM's Class Loader loads the required class files into memory so that the program can be executed.

Step 4: Verify the bytecode

The Bytecode Verifier checks whether the bytecode follows the required rules and is structurally valid.

Step 5: Execute the bytecode

The JVM executes the bytecode using its execution engine. Depending on the implementation, this can involve interpretation and Just-In-Time (JIT) compilation into native machine code.

That's how our Java program gets executed!

4. Components of Java Architecture

There are three important terms we need to understand: JDK, JRE, and JVM.

4.1 JDK (Java Development Kit)

JDK stands for Java Development Kit.

It provides the tools required to develop Java applications. It includes the Java runtime components along with development tools such as:

javac – Compiles Java source code.
javadoc – Generates documentation from Java source code.
jdb – A command-line debugger.

In simple words, if we want to develop Java applications, we need a JDK.

4.2 JRE (Java Runtime Environment)

JRE stands for Java Runtime Environment.

It provides the runtime components and libraries required to run Java applications. In the traditional Java distribution model, it includes the JVM and supporting libraries.

For example, Java provides ready-to-use classes such as String and ArrayList, which we can use in our programs instead of implementing everything from scratch.

In simple words, the JRE provides the environment needed to run Java applications.

Note: Modern Java releases do not always provide a separate JRE download. The runtime can also be packaged using tools such as jlink.

4.3 JVM (Java Virtual Machine)

JVM stands for Java Virtual Machine.

It is responsible for executing Java bytecode. It also helps make Java platform-independent.

Some of its important components and responsibilities are:

Class Loader: Loads the required class files.
Bytecode Verifier: Checks bytecode validity and safety constraints.
Execution Engine: Executes bytecode using interpretation and JIT compilation.
Memory Management: Manages runtime memory, including garbage collection.

The JVM is platform-specific, but Java bytecode can run on any compatible system that provides an appropriate JVM.

5. Difference Between JDK, JRE, and JVM

Here is a simple way to remember the difference:

JDK: Used to develop Java applications.
JRE: Provides the environment and libraries needed to run Java applications.
JVM: Executes Java bytecode.

Think of it this way: the JDK provides development tools, the runtime provides what the application needs to run, and the JVM executes the bytecode.

6. Summary

Let's quickly revise what we learned.

Java is a high-level, object-oriented programming language.
Java source code is saved in a .java file.
The javac compiler converts source code into bytecode stored in a .class file.
The JVM loads and executes the bytecode.
The JDK provides development tools, while the runtime provides the components needed to run Java applications.
Java supports platform independence because compatible JVM implementations can execute the same bytecode on different operating systems.

These are the basics of Java and its architecture. Understanding these concepts makes it easier to learn more advanced Java topics.

I'm still learning Java, and I'll keep sharing my notes as I progress. If you find anything that needs correction or have a suggestion, feel free to share it in the comments!

Thanks for reading!

Object in Java

Subash — Tue, 27 Oct 2026 13:56:44 +0000

Object in Java

In Java, an object is an instance of a class. It represents a real-world entity and has state (data) and behavior (methods).

For example, a car can have properties like its color and brand, and behaviors like starting and stopping.

Example

Let's create a simple Java class and an object.

class Car {
String brand = "BMW";
String color = "Black";

void start() {
    System.out.println("The car is starting");
}

}

public class Main {
public static void main(String[] args) {
Car myCar = new Car();

    System.out.println(myCar.brand);
    System.out.println(myCar.color);

    myCar.start();
}

}

Output

BMW
Black
The car is starting

Understanding the code

Class: Car is a blueprint for creating car objects.

Object: myCar refers to the object created using new Car().

State: brand and color represent the object's data.

Behavior: start() is a method that represents what the object can do.

new keyword: It creates a new Car object.

Conclusion

A class defines the structure, while an object is an instance of that class. Objects help us represent real-world entities and organize code using object-oriented programming (OOP).

Variable and Data Types in Java

Subash — Mon, 26 Oct 2026 14:00:10 +0000

In Java, there are two types of data types: Primitive and Non-Primitive (Reference) Data Types.

1. Primitive Data Types

In Java, we have 8 primitive data types:

byte
short
int
long
float
double
boolean
char

These are the basic data types available in Java.

2. Non-Primitive Data Types

In non-primitive data types, we have String, arrays, and classes that we create.

For example, if we create a class called Home, it is a user-defined class and its type is a reference type.

String name = "Stark";
Home home = new Home();

Here, String and Home are reference types.

We also use System.out.println() to print something in Java. Here, System is a predefined class in Java, and println() is a method used to print output.

3. What is a Variable?

A variable is a name given to a storage location that holds a value.

For example:

String name = "Stark";

Here, String is the data type, name is the variable, and "Stark" is the value assigned to it.

4. Types of Variables in Java

We commonly discuss local variables, instance variables, and static variables in Java.

Local Variable: A variable declared inside a method, constructor, or block. It can be accessed within its declared scope.

Instance Variable: A variable declared inside a class but outside methods and without the static keyword. Each object has its own copy of an instance variable.

Static Variable: A variable declared using the static keyword inside a class. It belongs to the class, and the class shares it among its objects.

For example:

class Home {
    static String type = "House";
    String owner = "Stark";

    void display() {
        int number = 10;
        System.out.println(number);
    }
}

In this example:

type is a static variable because it is declared using the static keyword.
owner is an instance variable because it belongs to each object.
number is a local variable because it is declared inside the display() method.

About a Programing Paradigm

Subash — Sat, 24 Oct 2026 13:03:51 +0000

Imperative Paradigms

Procedural programming Paradigm: A traditional method where code is written as a top-down list of step-by-step instructions or routines for the computer to follow.

Object Oriented Programming: A style that groups related variables and functions into everyday "objects," as covered in the earlier post.

Parallel Processing Approach: A method that divides complex tasks into smaller chunks so the computer's processors can execute them all at the exact same time.

Declarative Paradigms

Logic Programming Paradigm: A system where the programmer sets up a list of facts and rules, and the computer uses formal logic to deduce the answers.

Functional Programming: A style that treats computation like mathematical equations, strictly avoiding changing or mutating data once it is created.

Database Processing Approach: A method used for interacting with large databases, where you simply state what data you want to retrieve without writing the search algorithm.

Finding Error in a simple "Hello World!" Program.

Subash — Sat, 24 Oct 2026 10:03:49 +0000

Above is the simple Hello Universe! program and we can see how the simple syntax error cause the program to fail to run.

1)If we remove the class name Home below error occurs

2)If we remove the class form the first line below error occurs

3)If we remove the semicolon from the output line below error occurs

4)If we remove the double quotation from the string Hey Universe below error occurs

5)If we put single quotation instead of double quotation in string below error may occurs

6)If we remove the main in psvm below error occurs

It ask for identifier expected...

7)If we remove void form public static void main(psvm) below error occurs

its asks for return type...

8)If we remove the System form the code below error occurs

9)If we remove the curly braces from psvm it shows the error below:

10)If we remove println form the output line below error occurs

useEffect-Hooks

Subash — Thu, 01 Oct 2026 13:38:20 +0000

1. Run Only Once

Print "Component Mounted" only once when page loads.

- How will you write useEffect?

- What should be in dependency array? Why?

The dependency array should be an empty array [ ].

An empty dependency array tells React to run the useEffect after the component's initial render, so the effect runs only once when the component is mounted.

2. Run on Every Render

Print "Rendered" on every render.

- How will you write useEffect?

- What happens if dependency array is not provided?

If we don't provide a dependency array, the useEffect will run after every render of the component.

For example, if the component renders 5 times, the useEffect will also run 5 times.

3. Run When State Changes

const [count, setCount] = useState(0);
Log "Count changed" only when count changes.

- What should dependency array contain?

The dependency array should contain the count variable.

This means the useEffect will run whenever the count value changes.

- What happens if it is empty [ ]?

If the dependency array is empty [ ], the useEffect will run only once after the component's initial render.

It will not run again when count changes.

So, if we want the effect to run whenever count changes, we need to put count in the dependency array: [count]

4. Two States, One Effect

const [count, setCount] = useState(0);
const [name, setName] = useState("");
Run effect when count OR name changes.

- How will dependency array look?

The dependency array should contain both count and name:

This means the useEffect will run whenever count changes OR name changes.

- What if only count is added?

The useEffect will run whenever count changes.

Changes to name will not trigger this useEffect because name is not included in the dependency array.

5. Derived Logic

Show "Even Number" whenever count becomes even.

- Should this logic be inside render or useEffect? Why?

The logic is inside useEffect because we want to perform the console log when count changes. The [count] dependency makes the UseEffect to run whenever count changes, and the if condition checks whether the new count is even.

6. API Call on Mount

Fetch users when component loads.

- Why do we use [ ]?

We use an empty dependency array [ ] because we want the API call to run only after the component's initial render

- What happens if we remove [ ]?

If we remove [ ], the useEffect runs after every render. Therefore, the API call will be made after every render, which can cause unnecessary API requests and may lead to performance problems.

7. Infinite Loop Trap

useEffect(() => {

setCount(count + 1);

}, [count]);

- What will happen?

The setCount will increase the count value. Since count is in the dependency array, the useEffect will run again whenever count changes, creating an infinite loop.

- Why does this cause infinite re-render?

Since count is in the dependency array, changing count triggers the effect again, which changes count again, causing an infinite re-render loop.

8. Fix the Infinite Loop

- How can you increment count only once using useEffect?

If we give an empty dependency array [ ], the useEffect will run only once after the initial render. Therefore, setCount will increment the count only once, avoiding the infinite loop.

9. Document Title Sync

useEffect(() => {

document.title = count;

}, [?]);

- What should go inside ? Why?

We should put count inside the dependency array because whenever count changes, the useEffect will run and update the document title with the new count value.

10. Cleanup Basic

useEffect(() => {

window.addEventListener("click", handleClick);

});

- What problem may happen?

Without cleanup, a new click event listener will be added on every render. This can cause the handleClick function to run multiple times for a single click.

- How to fix properly?

- When does cleanup run?

The cleanup function runs before the effect runs again and when the component is unmounted (removed from the screen).

DEV Community: Subash

Functions in Python

What is a Function?

How to Create a Function in Python?

Why Should We Learn Functions?

Functions with Parameters and Arguments

Function Overloading

Pass Statement in Functions:

Return Function:

Operators in Python

What are Operators?

Types of Operators in Python

1. Arithmetic Operators

2. Relational (Comparison) Operators

3. Logical Operators

4. Bitwise Operators

5. Assignment Operators

6. Conditional (Ternary) Operator

Data Types in Java

What is a Data Type?

Types of Data Types in Java

1. Primitive Data Types

Default Values of Primitive Data Types

2. Non-Primitive Data Types

String

Array

Class and Object

Default Value of Non-Primitive Data Types

Variables and Objects in Java

What is a Variable?

Rules for Creating Variables

Types of Variables in Java

1. Local Variables

2. Instance Variables (Non-static)

3. Static Variables

What is an Object?

Creating a Class and Object

Day 2 of Learning Python: Variables, Identifiers, and Data Types

Day 2 of Learning Python: Variables, Identifiers, and Data Types

1. What Is an Identifier?

Rules for Naming Identifiers

2. What Is a Variable?

3. What Is the Assignment Operator?

4. Single and Double Underscores in Python

Single Leading Underscore (_name)

Double Leading Underscore (__name)

Double Underscores at Both Ends (__name__)

5. What Are Keywords?

6. Basic Data Types in Python

Integer (int)

Floating-Point Number (float)

String (str)

Boolean (bool)

Day 1 of Learning Python: Introduction and Python Architecture

What is Python?

How does Python work?

What I learned today

Java Architecture – How Java Works?

1. Introduction

2. What Is Java?

3. Java Architecture

How Does It Work?

4. Components of Java Architecture

4.1 JDK (Java Development Kit)

4.2 JRE (Java Runtime Environment)

4.3 JVM (Java Virtual Machine)

5. Difference Between JDK, JRE, and JVM

6. Summary

Object in Java

Variable and Data Types in Java

1. Primitive Data Types

2. Non-Primitive Data Types

3. What is a Variable?

4. Types of Variables in Java

About a Programing Paradigm

Finding Error in a simple "Hello World!" Program.

Above is the simple Hello Universe! program and we can see how the simple syntax error cause the program to fail to run.

1)If we remove the class name Home below error occurs

2)If we remove the class form the first line below error occurs

4)If we remove the double quotation from the string Hey Universe below error occurs

Single Leading Underscore (`_name`)

Double Leading Underscore (`__name`)

Double Underscores at Both Ends (`name`)

Integer (`int`)

Floating-Point Number (`float`)

String (`str`)

Boolean (`bool`)