DEV Community: Pavan Varma

Google Chrome Not Working on Windows 10 or 11? Here's What Finally Worked for Me

Pavan Varma — Thu, 22 May 2025 10:31:03 +0000

The Chrome browser on my Windows 10 has not been working properly for the past few months. Whenever I tried, it wouldn't open, or it would launch and freeze instantly. I tried a couple of ways to fix it, like removing the cache, reinstalling, etc. I kept pushing off, but in the meantime, I used Brave Browser, which is good. But finally, I have solved the problem. Here's how I fixed it - and how you might be able to as well.

🔍The Problem

Whenever I launched Chrome:

It takes time to open, or sometimes it doesn't open
It froze immediately, or
It would run, but the pages wouldn't load

I lived with this issue for months, then switched to Brave, but I always tried to fix it because Chrome is my go-to browser all the time.

❌ What Didn't Work

Before I found the fix, I tried:

Reinstalling Chrome
Removed all the extensions
Cleared cached and profile data
Restarting the laptop

✅ The Fix(what worked for me): Disable Graphics Acceleration

Go to your Chrome settings

Now, in the settings, select the System option, and you'll see options like these or maybe other options as well.

I disabled the "Use graphics acceleration when available" option, and it worked fine afterwards without any freezes occurring.

After disabling it, restart Chrome.

💡 Why This Happens

I'm not sure of the exact details, but ChatGPT explained it to me in a clear and organised manner.,
Chrome uses GPU hardware acceleration to improve performance. But on some systems - especially older laptops or those with certain GPU drivers - this can cause freezing or crashes.
Disabling it forces Chrome to rely on CPU rendering instead, which is more stable in these cases.

🎉Conclusion

I wish I had tried this sooner, but you know what? I got my Chrome working normally again, and I am very happy.
If you're Chrome browser also didn't work properly, try disabling the Graphics acceleration first.
Follow the steps I mentioned above :)

💬 Let's Connect

Did this fix work for you? Got a different solution that helped?
Drop a comment or connect with me - I'd love to hear your experience!

Mastering JavaScript Functions: Declarations, Expressions, and Arrow Functions

Pavan Varma — Mon, 24 Mar 2025 02:11:35 +0000

Introduction:

In this article, we can master the Functions in JavaScript, including how they work internally, how to write different function types and more!

So, let’s start with what is a Function exactly.

In simple terms, we can say that a “Function is a block of code designed to perform a particular task“

Why do we use Functions?

Using functions allows us to reuse code effectively, avoiding the
need to duplicate it repeatedly.
We can write code that can be used many times
We can use the same code with different arguments, to produce
different results

Syntax:

Let’s understand the Function syntax,

function name(parameter 1, parameter 2){
    // code to be executed
}

In JavaScript, a Function is defined with the function keyword, followed by a name, and followed by parentheses ().

Function names can contain letters, digits, underscores, and dollar signs (same rules as variables).

You understood the syntax of the function and now we can write an example of how a function works

// Example 1
function myName(){
  console.log("My name is Pavan Varma"); 
}
myName(); // this will print - My name is Pavan Varma

Now, we write an example of a function with parameters:

// Example 2
function fruitJuice(apples, oranges){
    console.log(apples, oranges);
    console.log(`Juice with ${apples} apples and ${oranges} oranges`);
}
fruitJuice(2, 3);
// it prints 
// 2, 3
// Juice with 2 apples and 3 oranges

Different Function Types:

There are three different writing functions, but they all work similarly: receive input data, transform data, and then output data.

1) Function Declaration:

A function that can be used before it’s declared

// function declaration example
function(birthYear){
    return 2025 - birthYear;
}

2) Function Expression:

Function value that stored in a variable

// function expression example
const calcAge = function(birthYear){
    return 2025 - birthYear;
}

3) Arrow Function:

Arrow Functions are great for quick one-line functions. It has no ‘this’ keyword.

// Arrow function example
const calcAge = birthYear => 2025 - birthYear;

Parameters and Arguments in Functions

In functions, parameters are placeholders to receive input values
like local variables of a function
Arguments are actual values of parameters to input data
Sometimes, we can assign default values to parameters. If no argument
is passed, the default value will act as the argument.

Default parameters are introduced in ES6.

// parameters
function greet(parameter1 = 'Hey', parameter2){ 
// in parameter1 we passed a value which acts as the default parameter
    // body
}

greet('hi', 'hello'); // hi and hello are the arguments

Return Statement:

Whenever JavaScript reaches the return then the functions stop executing and terminate.

Then, the caller will receive the return value.

// return example
// sum of two numbers

function sum(a, b){
    return a + b;
}

let a = 10;
let b = 20;

const sumOfTwo = sum(a, b); // return value stores here
console.log(sumOfTwo); // prints the result

Function Scope:

Scope refers to the accessibility and visibility of variables within different parts of a program. It determines where variables can be used and how they are accessed in the code.

In Function Scope, variables are accessible only inside the function, NOT outside.

// global scope
let language = 'JavaScript';

// function scope example
console.log(firstName); // it throws an error because the firstName is only available in myName fn
function myName(){
    let firstName = 'Pavan';
    let lastName = 'Varma';
    console.log(`${firstName}${lastName} likes ${language}`); 
    //It works here, because the language variable is a global variable
    // Pavan Varma likes JavaScript. 
}
console.log(lastName); // throws error as well..!

Function Review: Anatomy of a function:

Callback Functions:

On a simple level, Calling one function inside another is called a Callback Function.

// callback function example
function calculator(a, b, fnToCall){ //(2, 5, sum)
    const ans = fnToCall(a, b); // goes to sum(2, 5) fn
    return ans; // returns to caller
}

function sum(a, b){ // sum(2, 5)
    return a + b; // 7 returns to calculator fn
}

function sub(a, b){
    return a - b;
}

function product(a, b) {
    return a * b;
}

const value = calculator(2, 5, sum); 
// Here the callback function is applied and will receive the return value
console.log(value); // prints the answer

Now we see some functions that act as callback functions,

setTimeout():

It is a function, that is supposed to call a function after a certain duration.

// example
function greet() {
    console.log("Hello World!");
}

setTimeout(greet, 2 * 1000); // Now the greet fn will run after 2 seconds.

setInterval():

It is a function, that runs after runs on some interval which is given by the user.

// example
function greet() {
    console.log("Hello World!");
}
setInterval(greet, 3 * 1000); // Now the greet fn will run again and again for every 3 seconds.

Higher-Order Functions:

A function that receives another function as an argument, that returns a new function, or both. This is only possible because of first-class functions.

The function that receives another function:

//We have already seen this example in the callback function that will receive fn as an argument
function greet() {
    console.log("Hey Pavan");
}
btnClose.addEventListener('click', greet); 
// Here addEventListener is a function and that receives greet as an argument which is a callback fn

The function that returns a new function:

// example
const greet = function(greeting){
    // Here the fn returning a new fn.
    return function(name){
        // The greeting parameter is accessible in this return fn.
        console.log(`${greeting} ${name}`);
    }
}
// Firstly, the greet fn will called and returns the new fn and now 
// greetHello will act as new return fn
const greetHello = greet("Hello");
greetHello("Pavan"); // prints - Hello Pavan

Closures:

A closure is the closed-over variable environment of the execution
context in which a function was created, even after that execution
context is gone.
A closure gives a function access to all the variables of its parent
function, even after that parent function has returned. The function
keeps a reference to its outer scope, which preserves the scope chain
throughout time.
A closure is like a backpack that a function carries around wherever
it goes. This backpack has all the variables that were present in the
environment where the function was created.
We do NOT have to manually create a closure, this is a JavaScript
feature that happens automatically.
We can’t even access closed-over variables explicitly.

// Example 1
const a = function(){
    const x = 23;
    y = function (){
        console.log(x * 2);
    }
}
a(); // it executes upto y fn
y(); // now y fn has access to x variable even after a fn stopped executing
// prints 23 * 2 = 46

// Example 2
const secureBooking = function () {
  let passengerCount = 0;

  return function () {
    passengerCount++;
    console.log(
      `${passengerCount} ${passengerCount > 1 ? 'passengers' : 'passenger'}`
    );
  };
};

const booker = secureBooking();

booker(); // 1
booker(); // 2
booker(); // 3

IIFE (Immediately Invoked Function Expressions):

An IIFE (Immediately Invoked Function Expression) is a JavaScript function that runs as soon as it is defined. It is a function that is executed immediately after its declaration, without needing to be called separately.

If we ever want to run a function just once then we use IIFE.

// Example
const runOnce = function(){
    console.log("This will never run again");
}
runOnce(); // this will run for one time
// but if we again call it, then it runs one more time

// IIFE
(function (){
    console.log("This will never run again");
})(); // This will only run once and then terminated..!

Summary:

So, we covered almost every topic on Functions and if I missed anything I will write a new article for you to learn it.

We covered what is Functions, Syntax, Different types of functions, Parameters and Arguments, Return statements, Function Scope, Callbacks, Higher-order functions, Closures, and IIFE.

Hope you’ve learned something from this article, if you find any mistakes in the article please mention them in the comments I will fix them..!

It’s been a long time since my last article but from now on I will keep posting a new article every week so you learn something, for me also it will be good practice to post something that I’ve learned

Thanks for Reading this article :)

I started reading Atomic Habits recently so I’m adding one line from the book that inspires you

“ The most effective way to change your habits is to focus not on what you want to achieve, but on who you wish to become ”

Learn JavaScript Basics

Pavan Varma — Sat, 15 Feb 2025 19:00:18 +0000

JavaScript Made Easy: Understanding Basics, Control Flow, and Loops

Pavan Varma ・ Feb 15

#webdev #programming #javascript #100daysofcode

JavaScript Made Easy: Understanding Basics, Control Flow, and Loops

Pavan Varma — Sat, 15 Feb 2025 18:59:44 +0000

Introduction:

JavaScript is a high-level interpreted, object-oriented programming language created to make web pages alive.

It was created by Brenda Eich of Netscape in 1995.

JavaScript is an Interpreted language, whereas C++, Rust and Java are Compiled languages.

Compiled vs Interpreted:

Compiled	Interpreted
Firstly, we need to compile, and then we can run.	Usually, in interpreted it runs line by line.
Here, it doesn’t compile if there is an error in the code	It will run partially if the error occurs later

Write your First JavaScript Program:

So, we will write our first JavaScript program before we learn the fundamentals. For this open your browser and open google.com now right click on the tab and you will see an option called Inspect which I have shown below click on that:

Now you will see a pop-up open on the right side and in that, you will see a tab called console click on that your browser console will now be opened. In that write the JavaScript Program as I shown in below and press enter and your code will be logged..!

Congrats you just wrote your JavaScript code..!🎉🥳🥳
Writing our first JavaScript code in the browser console will always be fun and exciting.

Variables:

In JavaScript, variables can be declared in 4 ways:-

Automatically
var
let
const

Automatically

It means we can directly declare variables, but they are considered as Undeclared variables.

x = 4;
y = 2;
z = x + y;

Remember, in this way, it is not a good practice.

var

It is a variable that defines the value, and it is used whenever we don't want to change the value. It is used in all JavaScript code from 1995 to 2015.

var a = 10;
var b = 15;

let

let is also a variable to define the value and it is used whenever we want to change the value. This “let” keyword was added to JavaScript in 2015.

let firstName = "Monkey D";
let lastName = "Luffy";

const

It means constant, we cannot change the value once it is defined as const, if we try to change it throws the error. This “const” keyword was also added to JS in 2015.

const age = 24;
age = 40 // throws error.

Learn to write Comments:

Comments can be used to explain the code, and it makes users to more easily readable.

// This is a single-line comment

/*
This is a multi-line comment
*/

DataTypes:

There are several data types in JavaScript

String
Number
Boolean
BigInt
Object
Undefined
Null

// String Example
let FirstName = "Goku";

// Number Example
let num = 45;

// Boolean Example
let isLoggedIn = false;

// BigInt Example
let x = BigInt("123456789012345678901234567890");

// Arrays
let arr = [35, 38, 14, 75, 8];

// Object
let user = {
    firstName: "Pavan",
    lastName:  "Varma",
    age: 24,
};

Now, we gonna take about Primitives and Non-Primitives,

In simple terms, we say that Primitives are gonna stored in the stack and Non-Primtives are stored in Heap.

// Primitives Example
let num = 20;
console.log(typeof num); // Number

let name = "Pavan";
console.log(typeof name); // String

let isTrue = true;
console.log(typeof isTrue); // Boolean

let firstName; // Null
let lastName;
console.log(lastName); // undefined

const sm1 = Symbol("Pavan");
console.log(sm1); // Symbol

// Non-Primitives Example
let userName = {
  firstName: "Pavan",
  isLoggedIn: true,
};
console.log(userName.firstName);
console.log(userName.lastName);

console.log(typeof userName); // Object

let arr = ["a", "pavan", "JavaScript", "HTML", "CSS", true]; // array object

Operators:

Most of us already know about what are the different operators, because mostly in every programming language the operators are the same.

Assignment operator (=, +=, -=, *=, ?=).
Comparison operators (>, >=, <, <=, !, !=, ==, ===)
Arithmetic operators (+, -, , /, %, **, ++, - -)
Logical operators (&&, ||, !)

I will show some of the operator examples, hope you can practice them in your code editor.

let addition = 4 + 5;
let subtraction = 9 - 3;
let mul = 3 * 5;
let div = 8 / 2;
let remainder = 9 % 2;
let expo = 2 ** 4; // 2 ^ 4

let myScore = 110;
myScore++; // 111

let credits = 25;
credits--; // 24

// Comparison operator
let num1 = 3;
let num2 = 3;
let num3 = 6;

console.log(num1 == num2);
console.log(num1 != num3);
console.log(num1 > num3);
console.log(num1 < num3);

// Logical operators
let isLoggedIn = true;
let isPaid = false;

console.log(isLoggedIn && isPaid);

let isEmailUser = true;
let isGoogleUser = false;

console.log(isEmailUser || isGoogleUser);

Conditions:

Conditional statements perform different actions based on different conditions. For example, if we want to execute a code only if some condition is “true,” we will use conditional statements.

// Syntax
if(condition) {
    // block of code to be executed if the condition is true;
} else {
    // this block of code executes when the if(condition) is not true;
}

Now we understand how conditions we do an example program,

//Check if a number is greater than another number:

let num1 = 5;
let num2 = 10;

if (num1 > num2) {
  console.log("num1 is greater than num2");
} else {
  console.log("Nope, num1 is not greater");
}

I will mention some challenges if you’re interested, do solve those and if you solved all of them mention

“I Solved all the Conditional Challenges” in the comments :)

Check if a string is equal to another string.
Check if a variable is a number or not.
Check if a boolean value is true or false.
Check if an array is empty or not.

Loops:

What is Loops? So if we want to run a code over again and again, we use loops :)

JavaScript Supports different kinds of Loops:

for - if we know how many times our loop iterates then we will use for loop
for/in - loops through the properties of an object
for/of - loops through the values of an iterable object
forEach - this loop is used to iterate through the array
while - if we don’t know how many times our loop iterates then we
will use the while loop
do while - if we want our code to be executed at least one time
even if our condition is false then we use this.

// for loop syntax
for (expression 1; expression 2; expression 3) {
  // code block to be executed
}

// for-in syntax
for (key in object) {
  // code block to be executed
}

// for-of syntax
for (variable of iterable) {
  // code block to be executed
}

// forEach syntax
array.forEach(() => {
 // code block
)};

// while syntax
while(condition) {
 // block of code to execute
}

// do-while syntax
do{
    // block of code to execute
} while(condition)

Now, we will see some examples of these loops mentioned above,

/*
1. Write a 'for' loop that loops through the array ["green tea", "black tea", "chai", "oolong tea"].
    and stops the loop when it finds "chai".
    Store all teas before "chai" in a new array named 'selectedTrees'
*/

let teaName = ["green tea", "black tea", "chai", "oolong tea"];

let selectedTrees = [];

for (let i = 0; i < teaName.length; i++) {
  if (teaName[i] === "chai") {
    break;
  }
  selectedTrees.push(teaName[i]);
}
console.log(selectedTrees);

/*
2. Write a 'while' loop that calculates the sum of all numbers from 1 to 5 and stores the 
result in a variable called 'sum'. 
*/
let num = 1;

let sum = 0;
// 1+2+3+4+5
while (num <= 5) {
  sum += num;
  num++;
}
console.log(sum);

/*
3. Write a 'do while' loop that prompts a user to enter their favorite tea type until they enter 'stop'
  store each tea type in an array named 'teaCollection'.
*/
let teaCollection = [];

let tea;

do {
  // tea = prompt("Enter you favorite tea (type 'stop' to finish)");

  if (tea != "stop") {
    teaCollection.push(tea);
  }
} while (tea !== "stop");

/*
4. Use a 'for-of' loop to iterate through the array [1, 2, 3, 4, 5] and stop the number '4' is found.
    store the numbers before '4' in an array named 'smallNumbers'
*/

let num = [1, 2, 3, 4, 5];
let smallNumbers = [];

for (const n of num) {
  if (n == 4) {
    break;
  }
  smallNumbers.push(n);
}
console.log(smallNumbers);

/*
5. Use a 'for-in' loop to loop through an object containing city populations .
    stop the loop when the population of "berlin" is found and store all previous cities populations
    in a new object called 'cityPopulations'
*/

let citiesPopulation = {
  London: 8900000,
  "New York": 8400000,
  Paris: 2200000,
  Berlin: 3500000,
};

let cityPopulations = {};

for (const city in citiesPopulation) {
  if (city == "Berlin") {
    break;
  }
  cityPopulations[city] = citiesPopulation[city];
}
console.log(cityPopulations);

Challenges on Loops:

Write a 'for' loop that loops through the array ["london", "new
york", "paris", "berlin"] and skips "paris". Store the other cities
in a new array named 'visitedCities'.
Use a 'for-of' loop to iterate through the array ["chai," "green
tea," "herbal tea," and "black tea"], skipping the "herbal tea."
Store the other teas in an array named 'preferredTeas.'
Use a 'for-in' loop to loop through an object containing city
populations. skip any city with a population below 3 million and
store the rest in a new object named 'largeCities'.
Write a 'forEach' loop that iterates through the array ['earl grey',
'green tea', 'chai', 'oolong tea']. Stop the loop when 'chai' is
found, and store all previous tea types in an array named
'availableTeas'.
Write a 'while' loop that counts down from 5 to 1 and stores the
numbers in an array named 'countdown'.

Conclusion:

Yeah..! that’s it for this one, I hope you understand all the basics of JavaScript and in the next one we gonna talk about Arrays, Objects and their methods with different examples.

Some of the challenges are taken from the learnings that I taken to solve and I solved them and now on you. If you want to learn in YouTube I recommend you to watch Hitesh Sir Course

Hope You’re all doing well, Stay Hard..!

Code well and share your learnings in Public.

Java Functions/Methods: A Beginner's Guide to Writing Efficient Code

Pavan Varma — Tue, 17 Dec 2024 11:29:27 +0000

Intro:

In this article, I would like to share some insights about…

Functions/Methods Works
Scoping
Shadowing
Function Overloading Let's go....🙂🔥🔥✌

Functions:

A Function/Method is a block of code that only runs when called. A method can perform some specific task without returning anything. Methods allow us to reuse the code without retyping the code. In Java, a method must be part of some class that is different from some languages like C, C++, and Python.

Syntax:

public static int sum(int x, int y) {
  // body
    return x + y;
}

We can explain functions in simple terms. Suppose we have two variables and we want to calculate their sum; we can write the code as "x + y." If we want to add two more variables, we would write the same line of code again. This can be a waste of time. Instead, we can create a function to handle the addition and then call that function in the main method. This approach makes our work easier and saves a lot of time.

class Main {
    public static void main(String[] args) {
         int n1  = 25;
         int n2 =  20;
         int ans = sum(n1, n2);
         System.out.println("The Sum of two numbers is: " + ans);
    }
// Here's how we declare and initialize a function.
    public static int sum(int num1, int num2){
        return num1 + num2;
    }
}

Now, we can talk about Method Declaration:

Modifier:

It specifies how your method can be accessed within your application. There are four types of access modifiers.

Public
Private
Default
Protected

Return Type:

A return statement causes the program control to transfer back to the caller of a method. A return type may be a primitive type like int, char, boolean (or) Void type (which returns nothing).

A few important points to remember about return type,

The type of data returned by a method must be compatible with the return type specified by the method. e.g.:- If the return type of some method is boolean we cannot return an integer.
The variable receiving the value returned by a method must also be compatible with the return type specified for the method.

In Java, there is no pass-by-reference, there is only pass-by-value.

Function Name:

When specifying the name of a function, the rules for field names also apply to function names, though the convention is slightly different.

Parameter-List:

In this list input parameters are defined, preceded by their data type, within the parentheses. If there is no input we should leave it with empty parentheses.

Scoping:

Scoping refers to the visibility and lifetime of variables or functions within a program. It defines where in the code a variable or method can be accessed or used.

Types of Scoping in Java:

Function Scope: A variable declared inside a method/function scope can't be accessed outside the method.

class Main {
    public static void main(String[] args) {
        a = 20; // this shows error because 'a' variable cannot be accessed in 
// main method which declared in the function
    }
    public static int multiple(int ans) {
         int a = 1;
    }
}

Block Scope: Variables declared inside blocks of code (e.g., loops, if-else blocks) are accessible only within that block.

public class ScopeExample {
    public void display() {
        if (true) {
            int a = 5; // Block scoped variable
            System.out.println(a);
        }
        // System.out.println(a); // Error: a is not accessible outside the block
    }
}

Instance Scope: Variables declared inside a class but outside any method are instance variables. They belong to an object (instance of a class). These variables are accessible within the class and are tied to the lifetime of the object.

public class ScopeExample {
    int y = 20; // Instance variable
    public void display() {
        System.out.println(y); // Accessible here
    }
}

Shadowing:

Shadowing in Java refers to the practice of using variables with the same name in overlapping scopes, where a variable in a lower-level scope overrides a variable in a higher-level scope. In this case, the variable in the higher-level scope is shadowed by the variable in the lower-level scope.

public class Shadowing {
    static int x = 40; // this will be shadowed at line 8
    public static void main(String[] args) {
        System.out.println(x); // 40
        int x; // the class variable at line 4 shadowed by this
//        System.out.println(x); // scope will begin when value is initialised
        x = 90;
        System.out.println(x); // 90, 
        fun(); // 40
    }

    static void fun() {
        System.out.println(x);
    }
}

Variable Arguments:

Variable Arguments are used to take a variable number of argument. A method that takes a variable number of arguments is a Varargs method.

// Syntax:
static void fun (int ...a) {
    // body
}

Here, Parameters would be an array of type int[] parameters.

Function Overloading:

Function Overloading happens when a class has multiple methods with the same name but with different parameters.The methods are differentiated based on the number of parameters, types of parameters, or the order of parameters.

Rules for Function Overloading

Methods must have the same name.
The parameter list must be different (varying in type, number, or order of parameters).
The return type alone cannot differentiate methods.
Methods can have different access modifiers (public, private, etc.

public class OverLoading {
    public static void main(String[] args) {
        fun(5);
        fun("Pavan");
        int ans = sum(3, 4);
        System.out.println(ans);
        int res = sum(4, 5, 6);
        System.out.println(ans);
    }

    static int sum(int a, int b) {
        return a + b;
    }

    static int sum(int a, int b, int c){
        return a + b + c;
    }

    static void fun(int a){
        System.out.println("first one");
        System.out.println(a);
    }

    static void fun(String name){
        System.out.println("second one");
        System.out.println(name);
    }
}

Conclusion:

In Java, functions are essential for optimizing code and saving developers a considerable amount of time. I hope that anyone reading this article will gain a solid understanding of functions, scoping, shadowing, and overloading. I will also provide several challenging problems for you to solve using functions.

Function Practice:

Write a function that returns all prime numbers between two given numbers
Define a program to find out whether a given number is even or odd.
Define two methods to print the maximum and the minimum number respectively among three numbers entered by the user.
Define a method that returns the product of two numbers entered by the user.
Write a program to print the factorial of a number by defining a method.

Thank you, :)

STAY HARD

Java 101: Understanding Variables, Data Types, and Input/Output

Pavan Varma — Fri, 11 Oct 2024 11:47:20 +0000

Introduction:

Java is one of the most popular and versatile programming languages in the world, and it is used in everything from web applications to mobile apps. Understanding the basics is essential if you're starting your journey into Java. In this guide, we’ll dive into three foundational concepts—variables, data types, and input/output operations—which form the backbone of any Java program. By the end of this article, I promise that you will have a clear understanding of Java and its basics.

Types of Languages:

Before we deep dive into learning Java, we must first understand how many types of languages there are. There are three types of languages, they are

Procedural:

Procedural language specifies a series of well-structured steps and procedures to compose a program.
It Contains a systematic order of statements, functions, and commands to complete a task.

Functional:

Writing a program entails using pure functions, which means never modifying variables but only creating new ones as output.
Used in situations where we have to perform lots of different operations on the same set of data.

Object-Oriented:

Resolves around objects.
Code + Data = object.
Developed to make it easier to develop, debug, reuse, and maintain
software.

In Conclusion to this section,

“Java is predominantly an object-oriented language, but it also supports procedural and functional programming to some extent. ”

What is Java?

Java is a static programming language created by James Gosling at Sun Microsystems in 1995, Java is known for its simplicity, reliability, and portability, making it a favorite among developers for building everything from mobile apps to large-scale enterprise systems.

How Java code executes

Before Java came into the picture languages like C, and C++ they are platform-dependent, but Java is platform-independent, which means the source code that we write will be converted into byte code.

A compiler helps in doing this by turning it into executable code. This code is a set of instructions for the computer. Now, the JVM (Java Virtual Machine) converts this byte code to machine code. Here, JVM is platform-dependent.

Architecture:

Writing your First Java Program:

Before diving into the main topics let’s start by writing your first Java program. A simple program that prints “Hello World!” is a great way to start programming and it’s a universal program. Anyone who starts to learn programming will start their journey by writing this program.

Step-1:

Before you write your first Java program, make sure you have the Java Development Kit (JDK) installed on your system. You can download it from Oracle’s website if you haven’t already.

You also need an Integrated Development Environment (IDE) like Eclipse or IntelliJ IDEA to write and run your Java programs. I use Intellij

Step-2:

Now, let’s write a simple Java program that prints “Hello World!” the console.

// This is a simple Java program
public class Main {
    public static void main(String[] args) {
        // Prints "Hello, World!" to the console
        System.out.println("Hello, World!");
    }
}

Step-3:

Now, run the code in your IDE you can get the output as:

Hello, World!

Also, I will provide a coding question link for you to solve your first problem in Java from GeeksforGeeks.

Coding Question link here: Hello World

Let’s move on to the main topics…,

Variables:

Variables are containers that hold data values. In Java, every variable has a type that defines the kind of data it can store.

We can declare and initialize the variable in one step;

Data Types:

Type of data that can be stored in the variable. There are two Data types in Java, they are:

Primitive
Non-Primitive

Primitive Data type:

It means any data type that cannot be broken further.

Java has 8 primitive data types: int, byte, short, long, float, double, boolean, and char.

public class Test {
    public static void main(String[] args) {
        // Primitives
        boolean isValid = true;
        byte marks = 90;
        int num = 10;
        float weight = 70.5F;
        long views = 1_000_000_000;
        char gender = 'M';
    }
}

Non-Primitve Data type:

Non-Primitive type variables are always references.
Memory for Non-primitives is always allocated on the heap.
Members of Non-primitives get default values.

public class NonPrimitives {
    public static void main(String[] args) {
        // Non primitives in java
        String s = "GeeksforGeeks";
        // others are class, object, interface, Array
        System.out.println(s);
    }
}

Wrapper Classes in Java:

A Wrapper class is a class whose object wraps (or) contains primitive data types. When we create a field and in this field, we can store primitive data types. In easy words, we can wrap a primitive value into a wrapper class object.

Character
Byte
Short
Integer
Long
Float
Double
Boolean

Type Conversion (or) Types Casting:

If the data types are compatible, then Java will perform the conversion automatically known as Automatic type conversion, and if not then they need to be cast (or) converted explicitly.

Widening (or) Implicit Conversion:

Widening conversion takes place when two data types are automatically converted. This happens when,

The two data types are compatible.
When we assign a value of a smaller data type to a bigger data type

*Narrowing (or) Explicit Conversion:
*
If we want to assign a value of a larger data type to a smaller data type we perform explicit conversion (or) narrowing

This is useful for incompatible data types where automatic conversion cannot be done.

Input and Output:

Input:

To give some value to the system or a computer form the user is known as Input.

Java has two types of Input:

Buffered Reader
Scanner

Buffered Reader:

The Buffered Reader class reads text from an input stream, buffering characters for efficient reading. While it’s often used for file input, it can also be used for reading user input from the console.

import java.io.*;
public class Main {
    public static void main(String[] args) throws IOException {
        // BufferedReader example
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        // String example
       System.out.print("Enter a String: ");
       String s = br.readLine();
       System.out.println("You Entered: " + s);
        // Integer example
        System.out.print("Enter a Integer: ");
        int x = Integer.parseInt(br.readLine());
        System.out.println("You Entered: " + x);
    }
}

Scanner:

Scanner is a class in java.util package used for obtaining the input of the primitive types like int, double, and strings. It is the easiest way to read input in a Java program, though not very efficient if you want an input method for scenarios where time is a constraint like in competitive programming.

import java.util.Scanner;
public class ScannerExample {
    public static void main(String[] args) {
        // Scanner Example
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter: ");
//        String sr = sc.nextLine();
        int n = sc.nextInt();
        System.out.println(n);
    }
}

Output:

After giving the input we receive an value or something known as output. In Java we use;

System.out.println();
System.out.print();
System.out.printf();

Conclusion:

In this article, we have explored some of the fundamental concepts of Java, Including writing your first program. Mastering these basics is a crucial step in becoming comfortable with Java and programming in general.

And that’s it we completed learning about Java fundamentals and in the next article I’m gonna help you to learn more concepts of Java.

Keep pushing forward and STAY HARD!!

If you liked the article share it with your friends and give a like and follow.

See ya :)

My Journey in Tech: September 2024 Reflections on Java, Web Development, and Growth

Pavan Varma — Wed, 02 Oct 2024 16:15:11 +0000

Introduction:

The Beginning of My Tech Journey:

September 2024, was an important month for me as I took significant steps toward advancing my tech skills. I always wanted to learn new technology to improve my skills, but it never worked due to a lack of consistency. But this time something changed I became more determined to start and it’s good and I started learning about Java fundamentals and Web Development fundamentals simultaneously.

What Sparked the Change?

I believe that change or motivation doesn't happen suddenly; rather, it comes after experiencing various things. Whenever I wanted to learn something, I found that my initial motivation or desire to learn came quickly, but it didn't last long. This time, I took the time to reflect on what was hindering my learning and identified the distractions that were pulling me away from achieving my goals.

Setting Goals and Making a Promise

After reflecting, I set some specific learning goals and made a promise to myself to achieve them. I've been wanting to learn Data Structures and Algorithms (DSA) for a long time, but I struggled to understand them. I decided to start from scratch, which meant revisiting the basics. So, I began by learning the fundamentals of the Java programming language. Additionally, I have a strong curiosity to learn web development, so I started learning the fundamentals of it as well.

Turning Motivation into Action: Setting My Learning Plan:

After deep discussion with myself and setting clear goals on areas on which I have to focus - Java, Data Structures and Algorithms (DSA), and Web Development - I knew I needed a structured approach to get the most out of my efforts.

Java and DSA

My first goal was to build a solid foundation in Java, which I already have some knowledge of but felt I needed a deeper understanding of. I decided to focus on Data Structures and Algorithms (DSA), as I knew this would not only sharpen my coding skills but also prepare me for technical interviews in the future.

I began with online resources like:

GeeksforGeeks
Hackerrank
Leetcode

for hands-on problem-solving.

Web Development

In parallel, I also wanted to learn HTML and CSS which are fundamentals of Web Development.

I utilized:

FreeCodeCamp
MDN Web Docs
as my learning resources.

Overcoming challenges:

As I started my learning journey nature suddenly attacked me with its rage “Our Area got flooded“ and for 10 Days there was no learning just tucked in our house with no electricity or anything.

After the floods were over I immediately started my learning journey and went through the basics of Java and also HTML.

Here are the topics I covered in

Java:

Basics
Input and Output
Operators
Flow Control
Loops
Functions/Methods
Arrays

HTML and CSS,

I covered most of the topics in HTML and CSS and also did some basic projects,

Here I will share the screenshots of the basic projects that I have done using HTML and CSS

Conclusion: Embracing the Journey Ahead

As I look back on September 2024, I realize how transformative this month was for my learning journey in technology. This time I not only changed myself in learning but I also started improving myself as a person. So By setting clear goals, and making promises to myself, I’ve built a strong foundation in Java, HTML, and CSS.

I am committed to fulfilling the promises I make to myself and others.

Moving forward, I’m excited to continue building and sharing what I’ve learned.

“ Stop Breaking Promises to yourself, When you say I’m going to do something to yourself or others, and when the option comes to break the promise don’t do it. There is one win you got for the day that’s Action “