DEV Community: Veera Ganapathi

OOP(Object Oriented Programming) Part 1

Veera Ganapathi — Thu, 24 Sep 2026 06:30:46 +0000

Variables

Static variable
Non-static variable

Static Variable
A static variable is a variable that belongs to the class, not to a specific object.

Declared using the static keyword.
Only one copy of the variable is created.
It is shared by all objects of the class.
It can be accessed using the class name.

public class Student {
    static String college = "College";
    public static void main(String[] args){
       System.out.println(Student.college);
}
}

Non-Static Variable

A non-static variable belongs to a specific object of the class.

It is declared without the static keyword.
Each object gets its own copy.
Its value can be different for each object.
It is accessed using an object.

public class Student {
    String name;
    public static void main(String[] args){
    Student s1 = new Student();
    s1.name = "Ganapathi";
    Student s2 = new Student();
    s2.name = "Kumar";
    System.out.println(s1.name);
    System.out.println(s2.name);
}
}

Java OOP(Object Oriented Programming):

Object-Oriented Programming (OOP) is a programming paradigm based on the concept of objects that contain data (fields) and behavior (methods). It focuses on designing software that closely represents real-world entities.

Class

A Class in Java is a blueprint or template used to create objects.
It defines the properties (data) and behaviors (methods) that objects of that class will have.

Java Class Naming Rules

Meaningful name
Start's with uppercase
No space allowed
No special character allowed[$,_]
Cannot start with a number

public class SuperMarket
{
//-----------
}

Object

An Object in Java is an instance of a class that represents a real-world entity.
It is used to access the variables and methods defined inside a class.
State: Represents the current data or attributes of an object.
Behavior: Represents the actions that an object can perform.

public class Student {
    String name;
    public static void main(String[] args){
    Student s1 = new Student();
    s1.name = "Ganapathi";
    Student s2 = new Student();
    s2.name = "Kumar";
    System.out.println(s1.name);
    System.out.println(s2.name);
}
}

Java Data Types

Veera Ganapathi — Wed, 23 Sep 2026 04:23:37 +0000

Data Types

Java data types define the type of data a variable can store in a program. They help the compiler allocate memory efficiently and ensure type safety. Java provides two main categories: primitive and non-primitive data types.

Types of Data Types

Data types in Java define the kind of data a variable can hold and the memory required to store it. They are broadly divided into two categories:

Primitive Data Types: Store simple values directly in memory.
Non-Primitive (Reference) Data Types: Store memory references to objects.

Primitive Data Types

Primitive data types store simple values directly in memory. Java provides eight primitive data types, each with a fixed size and range, which are summarized below:

Non-Primitive (Reference) Data Types

Non-primitive data types store references (memory addresses) rather than actual values. They are created by users and include types like String, Class, Object, Interface, and Array.

1. String

String represents a sequence of characters enclosed in double quotes. Unlike C/C++, Java strings are objects and are immutable.

Syntax:

String str = "Hello";

2. Class

A class is a user-defined blueprint that defines variables and methods. It represents a type of object and forms the foundation of Object-Oriented Programming.

3. Object

An Object is an instance of a class representing real-world entities. It has state (data), behavior (methods), and identity (unique reference).

Programming Paradigms

Veera Ganapathi — Wed, 23 Sep 2026 03:48:58 +0000

Introduction of Programming Paradigms

A programming paradigm is a method or style of solving problems using a programming language. It provides a structured approach and set of principles that guide how programs are designed and implemented.

Different programming paradigms use different techniques and strategies to solve software development problems efficiently.
A programming language may support one or more paradigms, allowing developers to choose the best approach based on project requirements.

Imperative Programming Paradigm

Imperative programming is one of the oldest programming paradigms and is closely related to machine architecture and Von Neumann architecture. It works by changing the program state through assignment statements and executes tasks step-by-step to achieve the desired result.

Type:

Procedural programming paradigm
Object oriented programming
Parallel processing approach

1.Procedural programming paradigm:

This paradigm emphasizes on procedure in terms of under lying machine model. There is no difference in between procedural and imperative approach. It has the ability to reuse the code and it was boon at that time when it was in use because of its reusability.

Examples of Procedural programming paradigm:

C: developed by Dennis Ritchie and Ken Thompson
C++: developed by Bjarne Stroustrup
Java: developed by James Gosling at Sun Microsystems
ColdFusion: developed by J J Allaire
Pascal: developed by Niklaus Wirth

2. Object oriented programming:

The program is written as a collection of classes and object which are meant for communication. The smallest and basic entity is object and all kind of computation is performed on the objects only. More emphasis is on data rather procedure. It can handle almost all kind of real life problems which are today in scenario.

Examples of Object Oriented programming paradigm:

Simula: first OOP language
Java: developed by James Gosling at Sun Microsystems
C++: developed by Bjarne Stroustrup
Objective-C: designed by Brad Cox
Visual Basic .NET: developed by Microsoft
Python: developed by Guido van Rossum

3. Parallel processing approach:

Parallel processing is the processing of program instructions by dividing them among multiple processors. A parallel processing system posses many numbers of processor with the objective of running a program in less time by dividing them. This approach seems to be like divide and conquer. Examples are NESL (one of the oldest one) and C/C++ also supports because of some library function.

Declarative programming paradigm

Declarative programming is a programming style that focuses on what needs to be done rather than how to do it. It expresses the logic of computation without describing the step-by-step control flow of the program. This paradigm includes logic, functional, and database programming and is often useful for simplifying complex and parallel programming tasks.

Type:

Logic programming paradigms
Functional programming paradigms
Database/Data driven programming approach

1. Logic programming paradigms:

Logic programming is a paradigm based on facts, rules, and a knowledge base to solve logical problems such as puzzles and reasoning tasks. The program execution works like proving a mathematical statement, where the system derives results from given facts and rules.

2. Functional programming paradigms:

Functional programming is a paradigm based on mathematical functions where computation is performed through the execution of functions. It focuses on using functions for specific tasks while keeping data loosely coupled and minimizing changes in program state. Some of the languages like perl, javascript mostly uses this paradigm.

3. Database/Data driven programming approach:

Database or data-driven programming focuses on data and its movement rather than hard-coded program steps. In this approach, program behavior is controlled by data operations such as storage, retrieval, filtering, and reporting. It is widely used in business information systems and database applications for managing structured data efficiently.

Java Error task

Veera Ganapathi — Tue, 22 Sep 2026 05:52:12 +0000

10 java Error

Error 1

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

Output:

C:\Users\acer\Desktop\java>javac Home.java
Home.java:5: error: ';' expected
System.out.println("Hello Wolrd!!!")
                                    ^
1 error

Error 2

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

Output:

C:\Users\acer\Desktop\java>javac Home.java
Home.java:1: error: class home is public, should be declared in a file named home.java
public class home
       ^
1 error

Error 3

public class home
{
public Static void main(String [] args)
{
System.out.println("Hello Wolrd!!!");
}
}

Output:

C:\Users\acer\Desktop\java>javac home.java
home.java:3: error: <identifier> expected
public Static void main(String [] args)
             ^
1 error

Error 4

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

Output:

C:\Users\acer\Desktop\java>javac home.java
home.java:5: error: cannot find symbol
System.out.println(veera);
                   ^
  symbol:   variable veera
  location: class home
1 error

Error 5

public class home
{
public static void main(String [] args)
{
System.out.println('veera');
}
}

Output:


C:\Users\acer\Desktop\java>javac home.java
home.java:5: error: unclosed character literal
System.out.println('veera');
                   ^
home.java:5: error: unclosed character literal
System.out.println('veera');
                         ^
home.java:5: error: not a statement
System.out.println('veera');
                     ^
3 errors

Error 6

public class home
{
public static void main(string [] args)
{
System.out.println("veera");
}
}

Output:

C:\Users\acer\Desktop\java>javac home.java
home.java:3: error: cannot find symbol
public static void main(string [] args)
                        ^
  symbol:   class string
  location: class home
1 error

Error 7

public class home
{
public static void main(String args)
{
System.out.println("veera");
}
}

Output:

C:\Users\acer\Desktop\java>javac home.java

C:\Users\acer\Desktop\java>java home
Error: Main method not found in class home, please define the main method as:
   public static void main(String[] args)
or a JavaFX application class must extend javafx.application.Application

Error 8

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

Output:

C:\Users\acer\Desktop\java>javac home.java
home.java:3: error: '{' or ';' expected
public static void main(String [] args):
                                       ^
1 error

Error 9

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

Output:

C:\Users\acer\Desktop\java>javac home.java
home.java:3: error: <identifier> expected
public static void main(String [])
                                 ^
1 error

Error 10

public class home
{
public static void main(String [] args)
{
System.Out.println("veera");
}
}

Output:

C:\Users\acer\Desktop\java>java home
veera
C:\Users\acer\Desktop\java>javac home.java
home.java:5: error: Out has private access in System
System.Out.println("veera");
      ^
1 error

Java Introduction

Veera Ganapathi — Tue, 22 Sep 2026 05:25:38 +0000

Introduction

Java is a popular and powerful programming language, created in 1995.
It is owned by Oracle, and more than 3 billion devices run Java.

It is used for:

Mobile applications (specially Android apps)
Desktop applications
Web applications
Web servers and application servers
Games
Database connection

Java Architecture

The JVM, JRE, and JDK are all components of Java Architecture. It combines the interpretation and compilation processes. It enumerates all of the steps involved in writing a Java program. The Java Architecture describes each step in the compilation and execution of a program. The below-mentioned points and diagram will simply illustrate Java architecture:

There is a compilation and interpretation process in Java.
After the JAVA code is written, the JAVA compiler comes into the picture that converts this code into byte code that can be understood by the machine.
After the creation of bytecode JAVA virtual machine(JVM) converts it to the machine code, i.e. (.class file)
And finally, the machine runs that machine code.

Components of Java Architecture

Java architecture consists of three main components and those are JRE(Java Runtime Environment), JDK(Java Development Kit), and JVM(Java Virtual Machine).

Java Runtime Environment(JRE)

Java programs can run in a runtime environment created by the JRE software. The Java Runtime Environment (JRE) is a disk-based system that mixes Java code with necessary libraries. Finally, the Java Virtual Machine (JVM) begins to run the Java code. The Java Runtime Environment (JRE) contains all of the libraries and software required to run Java programs. Although JRE is included in the JDK, it is also available for download individually.

Java Development Kit(JDK)

It’s a Java application and applet development environment. JRE, a compiler, an interpreter or loader, and a number of development tools are all included in the Java Development Kit. Now we will walk through these development tools which come along with JDK:

Java(loader/executor): responsible for launching Java applications
javac(compiler): It is responsible for compilation of java programs
Javadoc: provides support for generation of API documentation
Jar: responsible for creating and managing all JAR files.

Java Virtual Machine(JVM)

WORA is Java’s most important feature. Write Once, Run Anywhere is an acronym for WORA. We may develop our code once and utilize it anywhere and on any operating system, according to the feature. Due to the Java Virtual Machine, our Java software can execute on any platform. It is a Java platform component that provides us with a platform in which we can run Java programs. The basic job of the JVM is to transform byte code into machine code. On the whole, JVM performs these functions – loads and verifies the code and then executes the code, and enables the runtime environment.

java code

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

Output:
C:\Users\acer\Desktop\java>javac Home.java
C:\Users\acer\Desktop\java>java Home
Hello Wolrd!!!

React Hooks Part 2

Veera Ganapathi — Thu, 10 Sep 2026 05:57:23 +0000

React useEffect

The useEffect Hook allows you to perform side effects in your components.Some examples of side effects are: fetching data, directly updating the DOM, and timers.useEffect accepts two arguments. The second argument is optional.

useEffect(function, dependency)

Type

No dependency
An empty array
Props or state values

Example

An empty array
Runs the effect only once when the component is first loaded (mounted).

import {useState, useEffect} from 'react'


 function Clock(){
    const[time, setTime]=useState(new Date())
    useEffect(function(){
        setInterval(function(){
            setTime(new Date());
        },1000)
    },[])

    return(
        <div>
            <h1>Clock</h1>
      <p>{time.toLocaleTimeString()}</p>
        </div>

    )
 }

 export default Clock


Output:

Clock
11:07:30

Props or state values

Runs the effect when the specified dependency value changes.

import { useState } from 'react'
import {useEffect} from 'react'

function App() {

const [count, setCount] = useState(0);
useEffect(function(){
  console.log("Count change:", count)
}, [count]);
function increase() {
  setCount(count+1);
}
function decrease() {
  if(count>0){
    setCount(count - 1);
  }

}
  return (

    <div>
      <h1>Counter</h1>
      <p>Count: {count}</p>
      <button onClick={increase}>Increase</button>
      <button onClick={decrease}>Decrease</button>
      <button onClick={() => setCount(0)}>Reset</button>

    </div>


  )
}

export default App

Output:

Count change: 0
Count change: 0
Count change: 1
Count change: 2
Count change: 3
Count change: 4
Count change: 5
Count change: 6
Count change: 7
Count change: 8

No dependency

Runs the effect after every render of the component.

import { useState } from 'react'
import {useEffect} from 'react'

function App() {

const [count, setCount] = useState(0);
useEffect(function(){
  console.log("Count change:", count)
});
function increase() {
  setCount(count+1);
}
function decrease() {
  if(count>0){
    setCount(count - 1);
  }

}
  return (

    <div>
      <h1>Counter</h1>
      <p>Count: {count}</p>
      <button onClick={increase}>Increase</button>
      <button onClick={decrease}>Decrease</button>
      <button onClick={() => setCount(0)}>Reset</button>

    </div>


  )
}

export default App

React Quiz Project

Veera Ganapathi — Thu, 10 Sep 2026 04:00:49 +0000

App.jsx

import { BrowserRouter, Route, Routes } from 'react-router-dom'
import './App.css'
import User from './components/User'
import Questions from './components/Questions'
import Result from './components/Result'
import { createContext, useState } from 'react'

export const quizContext = createContext();
function App() {
  const [user, setUser] = useState("");
  const [score, setScore] = useState(0);

  return (
    <div>
      <BrowserRouter>
       <quizContext.Provider value={{ user, setUser, score, setScore }}>
        <Routes>
            <Route path='/' element={<User />} />
            <Route path='/questions' element={<Questions />} />
            <Route path='/result' element={<Result />} /> 
        </Routes>
        </quizContext.Provider>
      </BrowserRouter>
    </div>
  )
}

export default App

User.jsx

import { useContext } from "react"
import { quizContext } from "../App"
import { useNavigate } from "react-router-dom";

function User() {
    const navigate = useNavigate();
    const { user, setUser } = useContext(quizContext);

    function start() {
        if (user) {
            navigate("/questions")
        } else {
            alert("Please enter valid input");
        }
    }
    return (
        <div className="user">
            <h1 className="head">Quiz App</h1>
            <input type="text" className="form-control" placeholder='Enter userName' onChange={(e) => setUser(e.target.value)} />
            <button className="user-btn" onClick={start}>Start Quiz</button>
        </div>
    )
}

export default User

Questions.jsx

import React, { useContext, useState } from 'react'
import quiz from '../assets/quiz.json'
import { quizContext } from '../App';
import { useNavigate } from 'react-router-dom';


function Questions() {
  const { score, setScore } = useContext(quizContext);
  const [currentQuestion, setCurrentQuestion] = useState(0);
  const [optionChoosen, setOptionChoosen] = useState("");

  const navigation = useNavigate();

  function next() {
    if (optionChoosen === quiz[currentQuestion].answer) {
      setScore(score + 1);
    }
    setCurrentQuestion(currentQuestion + 1);


  }

  function finish() {
     if (optionChoosen === quiz[currentQuestion].answer) {
      setScore(score + 1);
    }
    navigation("/result");
  }
  return (
    <div className='quiz'>
      <h1 className="question">{quiz[currentQuestion].prompt}</h1>
      <button className='quesBtn' onClick={() => setOptionChoosen("optionA")}>{quiz[currentQuestion].optionA}</button>
      <button className='quesBtn' onClick={() => setOptionChoosen("optionB")}>{quiz[currentQuestion].optionB}</button>
      <button className='quesBtn' onClick={() => setOptionChoosen("optionC")}>{quiz[currentQuestion].optionC}</button>
      <button className='quesBtn' onClick={() => setOptionChoosen("optionD")}>{quiz[currentQuestion].optionD}</button>
      {
        currentQuestion == quiz.length - 1 ? <button className='nextBtn' onClick={finish}>Finish</button> : <button className='nextBtn' onClick={next}>Next</button>
      }

    </div>
  )
}

export default Questions

Result.jsx

import React, { useContext } from 'react'
import { quizContext } from '../App';
import Questions from './Questions';
import { useNavigate } from 'react-router-dom';


function Result() {
  const { user, score } = useContext(quizContext);
  const navigation = useNavigate();

  function reset() {
    navigation("/");
    window.location.reload();
  }

  return (
    <div className='result'>
      <h1 className='headRes'>Quiz Result</h1>
      <p className='resultSco'>{user}, your score is: {score}</p>
      <p className='resultSco'>Thank you for participating!</p>
      <button className='resBtn' onClick={reset}>Play Again</button>
    </div>
  )
}

export default Result

App.css

/* userCss */

.user{
  height: 100vh;
  width: 100%;
  background-image: url("https://t4.ftcdn.net/jpg/03/45/88/07/360_F_345880772_zIT2mkdCzTthplO7xqaGGrMspN0jw0ll.jpg");
  background-size: cover;
  background-position: center;
}
.form-control{
  padding: 10px;
  border-radius: 5px;
  border: none;


}
.user-btn{
  margin: 10px;
  padding: 10px;
  border-radius: 5px;
  border: none;
  cursor: pointer;
  background-color: #c6c6d8;

}
.head{

  color: rgb(245, 239, 239);
  font-size: 50px;
  margin-right: 20px;
  padding-top: 200px;

}

/* questionCss */

.quiz{
  height: 100vh;
  width: 100%;
  background-image: url("https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcRgt3hNmO2Q_xmX2Nll5Zj9xtcOgB3oXMjKyE7-xT5LqL4ng2zNanS4wFmm&s=10");
  background-size: cover;
  background-position: center;
  display: flex;
  flex-direction: column;
  margin:0;


}

.question{
  color: rgba(15, 14, 14, 0.973);
  font-size: 30px;
  /* border: 2px solid black; */
  padding: 10px;
  margin: 10px;
  border-radius: 20px;
  background-color: rgba(255, 255, 255, 0.863);
  margin-bottom: 100px;

}

.quesBtn{
  margin: 20px;
  padding: 15px;
  border-radius: 5px;
  border: none;
  cursor: pointer;
  background-color: #c6c6d8;
}

.quesBtn:hover{
  background-color: #80808f;
  color: white;
}

.nextBtn{
  width: 120px;
  margin: 20px;
  padding: 15px;
  border-radius: 5px;
  border: none;
  cursor: pointer;
  background-color: #0808e9;
  margin-left: 1000px;
  color: white;

} 

/* resultCss */

.result{
  height: 100vh;
  width: 100%;
  display: flex;
  flex-direction: column;
  margin:0;
  background-color: rgba(10, 165, 226, 0.863);

}

.headRes{
  color: rgba(15, 14, 14, 0.973);
  font-size: 50px;
  margin-top: 100px;
  margin-bottom: 100px;
}

.resultSco{
  color: rgba(15, 14, 14, 0.973);
  font-size: 30px;
  margin-bottom: 100px;
}

.resBtn{
  width: 120px;
  margin: 20px;
  padding: 15px;
  border-radius: 5px;
  border: none;
  cursor: pointer;
  background-color: #0808e9;
  margin-left: 500px;
  color: white;
}

Output:

React Task

Veera Ganapathi — Wed, 09 Sep 2026 06:29:35 +0000

Task 1:

Show/Hide

import { useState } from 'react';

function Show() {
    const [name,setName]=useState(true)
function hide(){
   if(true){
    setName(!name)
   }
}

  return (
    <div>
      {name && <h1>Hello Ganapathi</h1>}
      <button onClick={hide}>Click Me</button>
    </div>
  );
}

export default Show;

Output:
Show

Hide

Task 2

Input Field Value:

import { useState } from 'react';
function InputBox() {
const [input,setInput] = useState("");

function handleChange(event){
  setInput(event.target.value);
}
function clearButton(){
    setInput("");
}
  return (
    <div>
      <input type="text" placeholder='Enter your name' onChange={handleChange} value={input} />
      <p>Hello {input}</p>
      <button onClick={clearButton}>Clear</button>
    </div>
  );
}

export default InputBox;

Output:

Task 3

Counter app

import {useState} from 'react';

function Counter() {
  const [count, setCount] = useState(0);

  return (
    <div>
      <p>Counter: {count}</p>
      <button onClick={() => setCount(count + 1)}>Increment</button>
      <button onClick={() => setCount(count - 1)}>Decrement</button>
      <button onClick={() => setCount(0)}>Reset</button>
    </div>
  );
}

export default Counter;

Output:

Task 4

Toggle Button:

import {useState} from 'react';

function Name(){
    const [changeName, setChangeName] = useState("Off");
function changeFunction(){
    if(changeName === "Off"){
        setChangeName("On");
    }
    else{
        setChangeName("Off");
    }

}

    return(
        <div>
            <h2>On/Off</h2>
            <h3>{changeName}</h3>
            <button onClick={changeFunction}>Button</button>
        </div>
    )
}

export default Name;

Output:

React Hooks Part 1

Veera Ganapathi — Wed, 09 Sep 2026 05:59:37 +0000

Hooks

Hooks allow functions to have access to state and other React features without using classes.They provide a more direct API to React concepts like props, state, context, refs, and lifecycle.

Hook Rules

There are 3 rules for hooks:

Hooks can only be called inside React function components.
Hooks can only be called at the top level of a component.
Hooks cannot be conditional

Types of React Hooks:

useState
useEffect
useContext

useState

The useState hook is used to declare state variables in functional components. It allows us to read and update the state within the component.

const [state, setState] = useState(initialState);

state:The current value of the state.
setState: A function used to update the state.
initialState: The initial value of the state, which can be a primitive type or an object/array

import {useState} from 'react';

function Name(){
    const [changeName, setChangeName] = useState("Ganapathi");
function changeFunction(){
    if(changeName === "Ganapathi"){
        setChangeName("Veera");
    }
    else{
        setChangeName("Ganapathi");
    }

}

    return(
        <div>
            <h1>NameChange</h1>
            <p>{changeName}</p>
            <button onClick={changeFunction}>NameChange</button>
        </div>
    )
}

export default Name;

Output:

React Js introduction

Veera Ganapathi — Wed, 09 Sep 2026 05:28:57 +0000

React is a powerful JavaScript library for building fast, scalable front-end applications. Created by Facebook, it's known for its component-based structure, single-page applications (SPAs), and virtual DOM, enabling efficient UI updates and a seamless user experience.

Importance of React

Before React, front-end development struggled with:

Manual DOM Manipulation:Traditional JavaScript directly modified the DOM, slowing down the performance.
Complex State Management: Maintaining UI state became messy and hard to debug.
Tight Coupling in Frameworks: Frameworks like Angular introduced complex two-way data binding that made code harder to manage.

Core Features

Virtual DOM: React updates only the changed parts of the DOM, resulting in faster rendering.
One-Way Data Binding: Ensures predictable and easy to debug data flow.
Component-Based Architecture: Breaks UI into reusable pieces, improving the code reusability and scalability.

function App() {
  return (
    <div>
      <h1>Hello World!</h1>
    </div>
  );
}

export default App;

Output:
Hello World!

Closure in JavaScript

Veera Ganapathi — Tue, 25 Aug 2026 14:36:23 +0000

What is Closure?

A closure is the combination of a function and its lexical environment, allowing the function to access variables from its outer scope even after the outer function has finished executing.

Retains access to outer function variables.
Preserves the lexical scope.
Allows data encapsulation and privacy.
Commonly used in callbacks and asynchronous code.

function bank() {

            let min_balance = 500;

            const actions = {

                deposit: function (amt) {
                    min_balance = min_balance + amt;
                },

                withdraw: function (amt) {
                    min_balance = min_balance - amt;
                },
                checkbalance: function () {
                    console.log(min_balance);

                }



            }
            return actions;
        }

        const customer1 = bank();
        customer1.deposit(1000);
        customer1.checkbalance();

Output:
1500

Testing Levels:

Veera Ganapathi — Mon, 17 Aug 2026 16:09:50 +0000

Main Testing Levels:

Unit Testing
Integration Testing
System Testing

Unit Testing

Unit Testing is the first level of software testing in which individual units or components of an application are tested independently. It is usually performed by developers to verify that each unit works correctly before integration.

Tests individual functions, methods, or classes in isolation.
Detects defects early, reducing debugging time and development cost.
Ensures each component behaves as expected.

Integration Testing

Integration Testing verifies the interaction and data flow between two or more integrated modules. It ensures that combined components communicate correctly and work together without interface issues.

Tests communication between integrated modules.
Identifies interface and data exchange defects.
Ensures seamless interaction among software components.

Integration Testing Approaches

Top-Down Approach
Bottom-Up Approach

Top-Down Approach
In Top-Down Integration Testing, testing starts from the top-level module and moves down to the lower-level modules.

Stubs

Stubs are developed by software developers to use them in place of modules, if the respective modules aren't developed, missing in developing stage, or are unavailable currently while Top-down testing of modules
Stubs are basically known as a "called programs" and are used in the Top-down integration testing.

Bottom-Up Approach
In Bottom-Up Integration Testing, testing starts from the lower-level modules and moves up to the top-level modules.

Drivers

Drivers serve the same purpose as stubs, but drivers are used in Bottom-up integration testing and are also more complex than stubs.
Drivers are the "calling program" and are used in bottom-up integration testing.

System Testing

System Testing evaluates the complete and integrated software application to verify that it meets all specified functional and non-functional requirements. It is performed in an environment similar to production.

Tests the complete application from end to end.
Verifies functional and non-functional requirements.
Ensures the software behaves correctly in real-world scenarios.

Error vs Bug vs Defect

Error
A mistake made by the developer/programmer.
Bug
A problem in the software caused by an error and found during testing.
Defect
When the actual result does not match the expected result or requirement.