Software Developer Interview Handbook 2026

Variables are named memory locations used to store data. In statically typed languages like C/C++/Java, you declare them with a type (e.g., int a = 10;). In dynamically typed languages like Python, the type is inferred (e.g., a = 10).

Primitive data types are predefined by the language (e.g., int, float, char, boolean). Non-primitive (or reference) types are created by the programmer and refer to objects (e.g., Arrays, Strings, Classes).

Operators perform operations on variables and values. Main types include:
- Arithmetic: +, -, *, /, %
- Logical: && (AND), || (OR), ! (NOT)
- Bitwise: &, |, ^, ~, <<, >>

- For loop: Best when the number of iterations is known.
- While loop: Best when the number of iterations is unknown and depends on a condition.
- Do-while loop: Similar to the while loop, but guarantees the block of code is executed at least once.

A function is a reusable block of code that performs a specific task. Benefits include code reusability, modularity, easier debugging, and improved readability.

A constructor is a special method invoked automatically when an object is created. It is used to initialize the object. Unlike regular methods, it has the same name as the class and no return type.

A reference variable acts as an alias or an alternative name for an already existing variable. In C++, changing the reference changes the original variable.

A pointer is a variable that stores the memory address of another variable. They are used in C/C++ for dynamic memory allocation, efficient array/structure passing, and direct hardware access.

Header files (e.g., <iostream>) contain declarations of functions, macros, and variables that can be shared across multiple source files. They tell the compiler how a function should be called.

A function that belongs to the class itself, not the object. It can be called without creating an instance and can only access static data.

In C++, a function declared with friend inside a class. It can access the private and protected data of that class, even though it is not a member function.

A struct is a user-defined data type that groups related variables of different data types under a single name. By default, members of a struct are public in C++.

A union is similar to a struct, but all its members share the same memory location. Its size is determined by its largest member, making it memory efficient when only one member is used at a time.

- Struct: Allocates separate memory for each member. Size is the sum of all members.
- Union: Shares the same memory for all members. Size is the size of the largest member.

- C: Procedural, does not support classes/objects, no function overloading, uses malloc/free.
- C++: Object-oriented, supports classes/objects, supports function/operator overloading, uses new/delete.

- C++: Platform-dependent, supports pointers, supports multiple inheritance, uses manual memory management.
- Java: Platform-independent (bytecode), no explicit pointers, no multiple inheritance (uses interfaces), automatic garbage collection.

(Subjective, frame as model answer): I prefer Python for its concise syntax and extensive libraries in AI/ML and data processing. I also use Java/C++ when strong typing, performance, and OOP structures are highly critical.

- Pre-increment (++i): Increments the value first, then uses the new value in the expression.
- Post-increment (i++): Uses the current value in the expression, then increments it afterwards. In loops (like for), ++i can be slightly more efficient in C++ for complex iterators.

Variable shadowing occurs when a variable declared within a certain scope (like a local variable inside a method) has the same name as a variable declared in an outer scope (like a class instance variable). The inner variable 'shadows' or hides the outer variable.

An anonymous function (a function without a name) that can be passed around as a value.
- Python: add = lambda x, y: x + y
- Java: (x, y) -> x + y
- C++: [](int x, int y) { return x + y; }

A list in Python is an ordered, mutable (changeable) collection of elements, enclosed in square brackets []. It can hold mixed data types.

A tuple is an ordered, immutable (unchangeable) collection of elements, enclosed in parentheses (). It is faster than a list and used for fixed data.

A dictionary is an unordered, mutable collection of key-value pairs, enclosed in curly braces {}. Keys must be unique and immutable.

In C++, std::set stores unique elements in sorted order (using a Red-Black tree). unordered_set uses hashing.

- List: Mutable, slower, uses []. Suitable for data that changes over time.
- Tuple: Immutable, faster, uses (). Suitable for fixed data (e.g., coordinates).

- List: Ordered, mutable, allows duplicates.
- Tuple: Ordered, immutable, allows duplicates.
- Set: Unordered, mutable, NO duplicates.
- Dictionary: Unordered, mutable, key-value pairs (keys are unique).

A DataFrame is a 2D labeled data structure. You can create it from a dictionary:

import pandas as pd
data = {'Name': ['Alice', 'Bob'], 'Age': [25, 30]}
df = pd.DataFrame(data)

Used extensively in ML for fast array operations, linear algebra calculations, and manipulating datasets before feeding them to models.

You can use the built-in csv module or pandas:

import pandas as pd
df = pd.read_csv('file.csv')

Use the built-in json module:

import json
with open('data.json') as f:
    data = json.load(f)

import json
data = {'key': 'value'}
json_string = json.dumps(data)

Use the requests library:

import requests
response = requests.get('https://api.example.com/data')
data = response.json()

Use the zip() function:

keys = ['a', 'b', 'c']
values = [1, 2, 3]
my_dict = dict(zip(keys, values))

In Python, strings are immutable. For efficient string concatenation (like Java's StringBuffer), it is recommended to append elements to a list and then use ''.join(list_name).

Counter from the collections module is a subclass of dictionary used to count hashable objects.

from collections import Counter
counts = Counter(['a', 'a', 'b']) # Counter({\'a\': 2, \'b\': 1})

In Python, you can use slicing:

s = 'hello'
reversed_s = s[::-1]

Similar to reversing a string:

name = 'John Doe'
print(name[::-1])

n = 12345
rev = int(str(n)[::-1])

def is_palindrome(s):
    return s == s[::-1]

from collections import Counter
counts = Counter('hello')
# OR
count = s.count('l')

vowels = set('aeiouAEIOU')
count = sum(1 for char in s if char in vowels)

vowels = set('aeiouAEIOU')
count = sum(1 for char in s if char.isalpha() and char not in vowels)

Using CTE and Window function:

WITH CTE AS (
  SELECT *, ROW_NUMBER() OVER(PARTITION BY name ORDER BY id) as rn 
  FROM table
)
DELETE FROM CTE WHERE rn > 1;

from collections import Counter
words = text.split()
repeats = [w for w, c in Counter(words).items() if c > 1]

Focus on string immutability, traversing, ASCII conversions (ord()/chr()), and efficient concatenation (join()).

Java's StringBuffer is a thread-safe, mutable sequence of characters. Unlike String which creates a new object on every modification, StringBuffer modifies the original object, saving memory during heavy concatenations.

Two strings are anagrams if they contain the same characters with the same frequencies.

def is_anagram(s1, s2):
    return sorted(s1) == sorted(s2)

N-Grams are continuous sequences of n items from a text.

def n_grams(s, n):
    words = s.split()
    return [' '.join(words[i:i+n]) for i in range(len(words)-n+1)]

def is_prime(n):
    if n <= 1: return False
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0: return False
    return True

def fact(n):
    return 1 if n == 0 else n * fact(n-1)

Recursion:

def fib(n): return n if n<=1 else fib(n-1)+fib(n-2)

dp=[0,1]+[-1]*(n-1)
for i in range(2,n+1): dp[i]=dp[i-1]+dp[i-2]

A number equal to the sum of its digits raised to the power of the number of digits (e.g., 153).

num_str = str(n)
power = len(num_str)
return n == sum(int(d)**power for d in num_str)

Using Binary Search for integer square root:

l, r, ans = 1, x, 0
while l <= r:
    mid = (l + r) // 2
    if mid * mid <= x:
        ans = mid; l = mid + 1
    else:
        r = mid - 1
return ans

temp = a
a = b
b = temp

a = a + b
b = a - b
a = a - b

for i in range(1, n+1):
    print(' ' * (n-i) + '*' * (2*i-1))

Standard right-angled triangle:

for i in range(1, n+1):
    print('*' * i)

- Array: Contiguous memory, O(1) access, fixed size (static arrays), O(N) insertion/deletion.
- Linked List: Non-contiguous (nodes with pointers), O(N) access, dynamic size, O(1) insertion/deletion (if pointer is known).

def rotate(arr, k):
    k %= len(arr)
    arr[:] = arr[-k:] + arr[:-k]

Using set: list(set(arr)). Without preserving order, or using a loop if order matters.

zero_count = arr.count(0)
arr = [x for x in arr if x != 0] + [0]*zero_count

Built in: arr.sort(). Manual (e.g., Bubble sort):

for i in range(n):
    for j in range(n-i-1):
        if arr[j] > arr[j+1]:
            arr[j], arr[j+1] = arr[j+1], arr[j]

Checks each element one by one until the target is found. Time Complexity: O(N). Works on unsorted arrays.

Works on sorted arrays. Repeatedly divides the search interval in half. Time Complexity: O(log N).

Repeatedly swaps adjacent elements if they are in the wrong order. Time Complexity: O(N^2).

Divide and Conquer. Divides array in half, sorts them, and merges. Time Complexity: O(N log N). Space Complexity: O(N).

Divide and Conquer. Picks a pivot, partitions array around the pivot. Time Complexity: Avg O(N log N), Worst O(N^2) (when already sorted and bad pivot). Space: O(log N).

The C++ std::sort() uses IntroSort. It is a hybrid sorting algorithm that uses QuickSort, and switches to HeapSort when recursion depth gets too large, and InsertionSort for small arrays. Time Complexity: O(N log N).

Arrays store elements of the same type in contiguous memory locations. They offer O(1) time complexity for accessing elements using index. Fixed in size (in languages like C/Java) but dynamic variants exist (like ArrayList/Vector).

A linear data structure where elements (nodes) are not stored in contiguous memory. Each node points to the next.
- Singly: Points to next.
- Doubly: Points to next and previous.
- Circular: Last node points to the first.

In a Linked List, a pointer (or reference in Java/Python) is a variable that stores the memory address of the next node. For a doubly linked list, each node has two pointers: one pointing to the previous node and one pointing to the next node.

A hierarchical data structure with a root node and children nodes. Binary Tree Depth is the number of edges from the root to the farthest leaf node.

def max_depth(root):
    if not root: return 0
    return 1 + max(max_depth(root.left), max_depth(root.right))

Binary Search Tree (BST) property: Left child < Node < Right child.

def insert(root, key):
    if not root: return Node(key)
    if key < root.val: root.left = insert(root.left, key)
    else: root.right = insert(root.right, key)
    return root

A special Tree-based structure that satisfies the Heap property.
- Max Heap: Parent is greater than children.
- Min Heap: Parent is smaller than children.
Used in Priority Queues and Heap Sort.

A container adaptor providing LIFO functionality. Elements are pushed and popped from the top.

A container adaptor providing FIFO functionality. Elements are pushed at the back and popped from the front.

Stores data in key-value pairs. Internally uses an array of linked lists (or trees in Java 8+ for collisions). Hashing function calculates the index for the key to provide O(1) average time complexity for put/get.

A function that converts a given key into an index (integer) within the hash table array. A good hash function is fast to compute and minimizes collisions (uniform distribution).

An algorithmic technique that solves complex problems by breaking them into overlapping subproblems and storing the results (Memoization or Tabulation) to avoid redundant calculations.

Least Recently Used (LRU) Cache discards the least recently used items first. Implemented using a Doubly Linked List (for fast removal/addition) and a HashMap (for O(1) access to nodes).

Merge Sort is the preferred algorithm for sorting a Linked List because it operates efficiently (O(N log N) time) and doesn't require random access to elements (unlike Quick Sort). It also requires only O(1) auxiliary space if done bottom-up.

Describes how the runtime of an algorithm grows with respect to the input size (N), typically expressed in Big O notation (e.g., O(1), O(N), O(N^2)).

Describes the amount of extra memory an algorithm requires as a function of the input size (N). Excludes the space required by the input itself.

The Standard Template Library (STL) in C++ provides a set of programming tools: Containers (vector, list, map), Algorithms (sort, search), and Iterators. It allows for writing generic, reusable code.

A dynamic array in C++. It automatically resizes itself when an element is inserted or deleted. Elements are stored contiguously.

In C++, std::map stores key-value pairs in sorted order of keys. It is implemented using a Self-Balancing Binary Search Tree (Red-Black Tree), offering O(log N) operations. unordered_map uses hashing (O(1)).

In C++, std::set stores unique elements in sorted order (using a Red-Black tree). unordered_set uses hashing.

A container adaptor providing FIFO functionality. Elements are pushed at the back and popped from the front.

A container adaptor providing LIFO functionality. Elements are pushed and popped from the top.

std::sort(begin, end) in C++ STL uses IntroSort (a hybrid of QuickSort, HeapSort, and InsertionSort). It guarantees O(N log N) worst-case time complexity.

A Class is a user-defined blueprint or prototype from which objects are created. It represents the set of properties or methods that are common to all objects of one type.
Example in C++:
class Car {
public:
string brand;
void honk() { cout << "Beep!" << endl; }
};

The bundling of data (variables) and methods (functions) that operate on the data into a single unit (class). It restricts direct access to some of the object's components, achieved using access modifiers (private, protected).

The mechanism where a new class (child) inherits properties and behavior from an existing class (parent).
Multilevel Inheritance: Class C inherits from Class B, which inherits from Class A.

A class inherits from more than one base class. Not directly supported in Java/C# (using classes) to avoid the Diamond Problem (ambiguity when two parents have the same method). Solved using interfaces (Java) or virtual inheritance (C++).

Hiding complex implementation details and showing only the essential features of the object. Achieved using abstract classes and interfaces.

The ability of a message/method to be displayed in more than one form.
- Compile-time: Method Overloading, Operator Overloading.
- Run-time: Method Overriding.

Also known as Dynamic Method Dispatch. Achieved using Method Overriding. The compiler determines which method to call at runtime based on the actual object type, not the reference type.

Achieved using Method Overloading. The compiler decides which method to execute during compilation based on the number and types of arguments.

Multiple methods in the same class with the same name but different parameters (type or number of arguments). Return type doesn't matter.

A child class provides a specific implementation of a method that is already provided by its parent class. Name, return type, and parameters must be exactly the same.

Giving a special meaning to an existing operator (like +, -) for user-defined data types. (Supported in C++, Python, but NOT Java).

A special method invoked when an object is created. Types:
- Default: No arguments.
- Parameterized: Takes arguments.
- Copy: Initializes an object using another object of the same class.

A function that belongs to the class itself, not the object. It can be called without creating an instance and can only access static data.

In C++, a function declared with friend inside a class. It can access the private and protected data of that class, even though it is not a member function.

Copies the memory address of objects inside the main object. If the original modifies the inner object, the copied object also reflects the change.

Creates a completely independent copy of the object and all the objects it references. Modifying the copy does not affect the original.

Retrieves data from a database. SELECT * FROM table_name;

Adds new rows of data into a table. INSERT INTO table (col1) VALUES (val1);

Modifies existing data in a table.
UPDATE table SET col1 = val1 WHERE condition;

Used to delete a resource from the server.

Removes the entire table structure and its data from the database. DDL command. Cannot be rolled back.
DROP TABLE table;

Deletes all rows from a table but keeps the structure. DDL command. Faster than DELETE and cannot be rolled back in most databases.
TRUNCATE TABLE table;

Used to create databases, tables, views, etc. DDL command.

Used to add, delete, or modify columns in an existing table. DDL command.
ALTER TABLE table ADD col_name datatype;

A column or combination of columns that uniquely identifies each row in a table. Cannot be NULL and must contain unique values. Only one per table.

A column in one table that refers to the Primary Key in another table, establishing a relationship and enforcing referential integrity.

Any set of columns that can uniquely identify a row. A table can have multiple Candidate Keys, and one of them is chosen as the Primary Key.

A set of one or more columns that can uniquely identify a row. A Candidate Key is a minimal Super Key.

An Entity-Relationship (ER) Diagram is a visual representation of the relationships among entities in a database. Entities (like tables) are represented by rectangles, attributes (columns) by ovals, and relationships (like foreign keys) by diamonds.

(Bonus Answer): To find the Nth highest salary in SQL without LIMIT: SELECT salary FROM Employee e1 WHERE N-1 = (SELECT COUNT(DISTINCT salary) FROM Employee e2 WHERE e2.salary > e1.salary);

(Bonus Answer): The CAP theorem states that a distributed data store can only simultaneously provide two out of three guarantees: Consistency (every read receives the most recent write), Availability (every request receives a non-error response), and Partition Tolerance (the system continues to operate despite network failures dropping messages).

Ensures all values in a column are unique. Unlike Primary Key, a Unique Key allows one NULL value, and a table can have multiple Unique Keys.

- Primary Key: Uniquely identifies a record. Cannot accept NULL values. Only one Primary Key is allowed per table.
- Unique Key: Ensures all values in a column are distinct. Can accept one NULL value. A table can have multiple Unique Keys.

- UNION: Combines the result sets of two or more SELECT statements and removes duplicate rows.
- UNION ALL: Combines result sets but keeps duplicate rows. It is faster than UNION because it doesn't incur the overhead of deduplication.

SQL functions are divided into two main categories:
1. Scalar Functions: Return a single value based on the input value (e.g., UCASE(), LCASE(), ROUND(), GETDATE()).
2. Aggregate Functions: Return a single value calculated from values in a column (e.g., SUM(), COUNT(), AVG(), MAX(), MIN()).

Perform calculations on a set of values and return a single value: COUNT(), SUM(), AVG(), MIN(), MAX().

Perform calculations across a set of table rows related to the current row, but unlike aggregate functions, they do not collapse the rows into a single output row (e.g., ROW_NUMBER(), RANK()).

Assigns a rank to each row within the partition of a result set. If there is a tie, the same rank is assigned, and the next rank is skipped (e.g., 1, 1, 3).

Similar to RANK(), but if there is a tie, the next rank is NOT skipped (e.g., 1, 1, 2).

SELECT MAX(salary) FROM Employee 
WHERE salary < (SELECT MAX(salary) FROM Employee);

SELECT department, MAX(salary) FROM Employee 
GROUP BY department;

SELECT COUNT(DISTINCT age) FROM Users;

Using CTE and Window function:

WITH CTE AS (
  SELECT *, ROW_NUMBER() OVER(PARTITION BY name ORDER BY id) as rn 
  FROM table
)
DELETE FROM CTE WHERE rn > 1;

Prepared SQL code that you can save and reuse. It can accept parameters, perform complex logic, and improve performance by reducing network traffic.

A special type of stored procedure that automatically executes (fires) when an event (INSERT, UPDATE, DELETE) occurs in the database table.

- INNER JOIN: Returns records matching in both tables.
- LEFT JOIN: All records from left table, matched records from right.
- RIGHT JOIN: All records from right table, matched from left.
- FULL OUTER JOIN: All records when there's a match in either.

Process of organizing data to reduce redundancy and improve integrity.
- 1NF: Atomic values, unique columns.
- 2NF: 1NF + no partial dependency.
- 3NF: 2NF + no transitive dependency.

Data Definition Language: Commands that define the database structure/schema. E.g., CREATE, ALTER, DROP, TRUNCATE.

Data Manipulation Language: Commands that manipulate the data itself. E.g., SELECT, INSERT, UPDATE, DELETE.

- SQL (Relational): Table-based, predefined schema, vertical scaling, ACID properties. Best for complex queries and transactional systems.
- NoSQL (Non-Relational): Document/Key-Value/Graph based, dynamic schema, horizontal scaling, BASE properties. Best for rapid development, unstructured data, and big data.

- DROP: DDL, removes table structure and data, cannot be rolled back.
- DELETE: DML, removes rows (can use WHERE), can be rolled back.

- DELETE: DML, removes row by row, logs each deletion, slower, can rollback.
- TRUNCATE: DDL, deallocates data pages, doesn't log each row, very fast, cannot rollback.

- DROP: Removes the table entirely from the database.
- TRUNCATE: Empties the table but keeps the table structure intact for future inserts.

In Node.js using Mongoose:

const mongoose = require('mongoose');
mongoose.connect('mongodb://localhost:27017/mydb');

db.users.insertOne({name: 'Alice', age: 25});
db.users.find({age: {$gt: 20}});
db.users.updateOne({name: 'Alice'}, {$set: {age: 26}});

Use query operators in the find() method:

db.collection.find({ 
  age: { $gte: 18, $lte: 30 }, 
  status: 'active' 
});

MongoDB stores data in JSON-like documents (BSON) with dynamic schemas. SQL stores data in rigid tables with rows and columns. MongoDB is better for unstructured data and rapid iteration.

(Recent Trend): A Vector Database (like Pinecone or Milvus) is designed to store data as high-dimensional vectors (embeddings). They are crucial for modern AI applications because they allow for extremely fast "semantic similarity" searches, enabling features like recommendation engines and RAG for LLMs.

MongoDB is a NoSQL (Not Only SQL) database because it does not store data in relational tables with strict schemas. Instead, it stores data in flexible, JSON-like documents (BSON). It does not use SQL for querying, nor does it strictly adhere to ACID properties by default, prioritizing horizontal scalability and flexibility.

An open-source, in-memory key-value data store. Extremely fast. Commonly used for caching, session management, real-time analytics, and message brokering (pub/sub).

Use NoSQL when dealing with large volumes of unstructured/semi-structured data, requiring high scalability (horizontal), agile development with changing schemas, or real-time big data applications.

An advanced, open-source object-relational database system (ORDBMS). Known for high reliability, feature robustness (JSONB support, advanced indexing), and strict SQL standard compliance.

- PostgreSQL: Open-source, free, cross-platform, strong JSON support.
- MSSQL: Microsoft proprietary (commercial), tightly integrated with Windows/.NET, excellent tooling (SSMS).

- PostgreSQL: Heavyweight, persistent, enterprise-grade database.
- H2: Lightweight, written in Java, often used as an in-memory database for testing and fast prototyping.

Main types include: Batch OS (jobs grouped), Time-Sharing OS (CPU time shared among users), Distributed OS (multiple independent CPUs), Network OS (runs on a server), and Real-Time OS (strict time constraints, e.g., pacemakers).

A program in execution. It contains the program code, current activity (PC), stack, data section (global variables), and heap (dynamic memory).

A thread is the smallest sequence of programmed instructions managed independently by a scheduler. It is a lightweight process. Multiple threads share the same memory and resources of a single process.

A situation where two or more processes are unable to proceed because each is waiting for a resource held by another. Necessary conditions (Coffman): Mutual Exclusion, Hold and Wait, No Preemption, Circular Wait.

A property of concurrency control preventing multiple processes/threads from executing critical sections of code (accessing shared resources) at the same time.

Simultaneous Peripheral Operations On-Line. It refers to putting jobs in a buffer, a special area in memory or on a disk where a device can access them when it is ready (e.g., Print Spooling).

A region of memory used for dynamic memory allocation during runtime. It is managed via malloc()/free() in C or garbage collection in Java/Python. It is shared across all threads in a process.

The process of controlling and coordinating computer memory. Techniques include: Paging (dividing memory into fixed-size pages) and Segmentation (dividing memory into variable-sized segments).

The main components are the Kernel (core, hardware interaction), Process Management, Memory Management, File System, I/O Management, and the User Interface (Shell/GUI).

The Kernel is the core and most important component of an Operating System. It has complete control over everything in the system and acts as a bridge between applications and data processing performed at the hardware level. It manages memory, processes, and hardware communication.

Deadlocks can be resolved or handled using three main strategies:
1. Deadlock Prevention: Ensure at least one of the four necessary conditions (Mutual Exclusion, Hold and Wait, No Preemption, Circular Wait) cannot hold.
2. Deadlock Avoidance: Use algorithms like Banker's Algorithm to dynamically analyze resource requests and ensure the system stays in a safe state.
3. Deadlock Detection & Recovery: Allow deadlocks to occur, detect them, and recover by killing processes or preempting resources.

Open Systems Interconnection model has 7 layers:
7. Application
6. Presentation
5. Session
4. Transport (TCP/UDP)
3. Network (IP, Routers)
2. Data Link (MAC, Switches)
1. Physical (Cables)

- Class A: 1.0.0.0 to 126.255.255.255 (Huge networks)
- Class B: 128.0.0.0 to 191.255.255.255 (Medium networks)
- Class C: 192.0.0.0 to 223.255.255.255 (Small networks)
- Class D: Multicast.
- Class E: Experimental.

A communication protocol providing full-duplex communication channels over a single, long-lived TCP connection. Unlike HTTP (request-response), WebSockets allow servers to push data to clients in real-time (e.g., chat apps).

Software Development Life Cycle is a process used by software industry to design, develop and test high-quality software. Phases: Requirement Analysis, Planning, Design, Coding, Testing, Deployment, Maintenance.

An iterative approach to software development. It emphasizes flexibility, continuous improvement, and rapid delivery of functional software in small increments (sprints). Welcomes changing requirements.

A linear, sequential approach where each phase must be completed before the next begins. Difficult to go back and change things. Best for projects with very clear, unchanging requirements.

The standard steps to build software: 1. Requirement Gathering, 2. Design/Architecture, 3. Implementation (Coding), 4. Testing, 5. Deployment, 6. Maintenance.

Testing individual components or functions of the software in isolation to ensure they work correctly. Usually written by developers (e.g., using JUnit, Jest).

Testing the combination of individual units to expose faults in the interaction between integrated units. Ensures different modules work together.

Testing based on an analysis of the internal structure, code, and logic of the software. The tester knows the internal workings.

A preliminary testing to reveal simple failures severe enough to reject a prospective software release. Checks if the critical functionalities are working.

Re-running functional and non-functional tests to ensure that previously developed and tested software still performs after a change (like a bug fix or new feature).

Testing the fully integrated software system to evaluate its compliance with the specified requirements. It is a high-level, black-box testing.

A platform that uses OS-level virtualization to deliver software in packages called containers. Containers bundle their own software, libraries, and configuration files, ensuring the app runs consistently anywhere.

- VM: Includes a full Guest OS, heavy, slow boot time, isolated at hardware level.
- Docker: Shares the Host OS kernel, lightweight, fast boot time, isolated at process level.

A distributed version control system used to track changes in source code during software development. It allows multiple developers to work together non-linearly.

While Git is the version control tool (software), GitHub is a cloud-based hosting service that lets you manage Git repositories and collaborate with others online.

- init: Start new repo.
- clone: Copy remote repo.
- add: Stage changes.
- commit: Save changes to local repo.
- push: Send changes to remote.
- pull: Fetch and merge remote changes.

An umbrella term that encompasses Continuous Integration (CI), Continuous Testing, and Continuous Delivery/Deployment. It means code is constantly being written, tested, and prepped for release.

In Continuous Delivery, code changes are automatically built and tested, but require a manual trigger to deploy. In Continuous Deployment, every change that passes tests is automatically deployed to production without human intervention.

HyperText Markup Language. HTML5 introduced semantic tags (<header>, <article>), multimedia support (<audio>, <video>), Canvas for drawing, and local storage APIs.

- Box Model: Content, Padding, Border, Margin.
- Flexbox: 1D layout system for aligning items in rows/columns.
- Grid: 2D layout system for complex web structures.

- Closures: A function remembering its lexical scope even when executed outside it.
- Promises: Represents the eventual completion of an async operation.
- Async/Await: Syntactic sugar over promises for cleaner async code.

A JS library for building UIs. Uses a Virtual DOM to optimize rendering by only updating changed elements. Hooks (like useState, useEffect) allow function components to have state and lifecycle features.

- React: A library (needs external routing/state libs), uses Virtual DOM, one-way data binding.
- Angular: A full framework, uses Real DOM, two-way data binding.
- Vue: Progressive framework, highly approachable.

A runtime environment executing JS outside the browser. It uses an Event Loop and non-blocking I/O, making it lightweight and efficient for data-intensive real-time applications.

Node Package Manager. It is the default package manager for Node.js, used to install, share, and manage project dependencies via the package.json file.

User Interface design focuses on the visual elements (buttons, colors, typography). Best practices include consistency, simple navigation, responsive design, and clear hierarchy.

User Experience focuses on the overall feel and journey of the user. Principles include understanding user needs, minimizing cognitive load, providing clear feedback, and ensuring accessibility.

Representational State Transfer. A standard for building web APIs. Constraints: Client-Server architecture, Statelessness, Cacheability, Layered system, Uniform interface.

(General Guide): Explain the authentication mechanism (e.g., using Passport.js, Firebase Auth, or a custom JWT implementation upon login).

(General Guide): Explain how you managed user roles (e.g., Admin vs User) using middleware to protect specific API routes.

JSON Web Token is an open standard for securely transmitting information as a JSON object. Consists of Header, Payload, and Signature. Used for stateless authentication.

HTTP headers pass additional information with an HTTP request or response (e.g., Content-Type, Authorization tokens, CORS policies).

- Local Storage: Stores data with no expiration date (5-10MB).
- Session Storage: Data is cleared when the page session ends (tab closed).
- Cookies: Small data (4KB) sent to server with every request, used for auth/tracking.

Representational State Transfer. A standard for building web APIs. Constraints: Client-Server architecture, Statelessness, Cacheability, Layered system, Uniform interface.

Used to retrieve data from a server. Should not modify data (idempotent and safe). Parameters are sent in the URL.

Used to create new resources or submit data to the server. Data is sent in the request body.

Used to update/replace an entire resource on the server. It is idempotent (repeating it has the same effect).

Used to apply partial modifications to a resource.

Used to delete a resource from the server.

A request where the payload (body) is formatted as JSON. Must include the header Content-Type: application/json.

The server replies with JSON data. In frontend (fetch API), parsed using response.json().

The frontend makes asynchronous HTTP requests (using Fetch API or Axios) to the Backend API endpoints. The backend processes the request, interacts with the DB, and returns a JSON response which the frontend renders.

Improved via: Caching (Redis), Database Indexing, Pagination, Asynchronous processing, Load balancing, and payload compression (GZIP).

Troubleshooting steps: 1. Check network/latency. 2. Analyze DB queries (add indexes, avoid N+1 queries). 3. Implement caching. 4. Use pagination. 5. Scale horizontally.

Amazon Web Services. Core services: EC2 (Virtual Machines), S3 (Object Storage), RDS (Relational Databases), Lambda (Serverless computing).

- IaaS: Infrastructure as a Service (EC2 - raw servers).
- PaaS: Platform as a Service (Heroku - environment managed for you).
- SaaS: Software as a Service (Google Workspace - fully hosted app).

A branch of AI focused on creating new content (text, images, audio) based on learned patterns from existing data. Examples include ChatGPT and DALL-E.

Generative Pre-trained Transformer. It is a type of LLM created by OpenAI that uses a transformer architecture to generate human-like text based on the input prompt.

The practice of designing and refining input text (prompts) to effectively guide an AI model to produce the most accurate and desired output.

Retrieval-Augmented Generation. A technique that enhances LLMs by connecting them to an external database. It retrieves relevant documents and feeds them to the LLM as context before generating an answer, reducing hallucinations.

AI systems (agents) designed to act autonomously to achieve specific goals. They can plan, use tools, and make decisions in multi-step processes without constant human intervention.

Convolutional Neural Network. Highly effective for Image Processing. Uses convolutional layers to automatically extract spatial hierarchies of features from images.

Recurrent Neural Network. Designed for sequential data (like time series or text). It has a 'memory' that captures information from previous steps to influence the current output.

An ensemble learning method for classification and regression. It operates by constructing a multitude of decision trees during training and outputting the mode/mean of the individual trees to prevent overfitting.

Extreme Gradient Boosting. A highly optimized gradient boosting library. It builds trees sequentially, minimizing errors of previous models. Highly successful in Kaggle competitions for tabular data.

Unsupervised learning where data points are grouped based on similarity. K-Means partitions data into K distinct clusters based on distance to the centroid.

Algorithms (like Gradient Descent) used to minimize the Loss/Error function of a model by updating the model's weights iteratively.

Used extensively in ML for fast array operations, linear algebra calculations, and manipulating datasets before feeding them to models.

(Frame a personalized response focusing on the STAR method): Briefly explain the Situation/Task (what problem you solved), Action (your specific implementation and technologies used), and Result (the outcome or impact).

(General Guide): List the specific tech stack (e.g., React, Node.js, MongoDB). Justify why you chose them (e.g., React for component reusability, MongoDB for flexible schema).

(General Guide): Describe the flow: Frontend -> API Gateway -> Backend Microservices/Monolith -> Database. Mention any caching or cloud services involved.

(General Guide): Mention third-party APIs (like Stripe for payments, Google Maps for location) or the internal REST/GraphQL APIs you designed.

(Model Answer): In my Node.js project, I used Mongoose to connect to MongoDB. I stored the connection string in a .env file for security. During app initialization, I called mongoose.connect(process.env.DB_URI). For SQL projects, I used an ORM like Sequelize or Hibernate to establish connection pools.

(Model Answer): We followed the Agile methodology. We broke down the project into 2-week sprints, started with requirement gathering, created Jira tickets, and held daily stand-ups to discuss progress and blockers. This allowed us to continuously test and iterate on the product.

(General Guide): Explain if it was SQL or NoSQL and the rationale (e.g., SQL for strict ACID transactional data, NoSQL for high volume unstructured data).

(General Guide): Explain the authentication mechanism (e.g., using Passport.js, Firebase Auth, or a custom JWT implementation upon login).

(General Guide): Explain how you managed user roles (e.g., Admin vs User) using middleware to protect specific API routes.

(General Guide): JWT (JSON Web Token) was used for stateless authentication. After login, a token is sent to the client, stored in local storage/HTTP-only cookie, and attached to the Authorization header of subsequent requests.

(General Guide): Used Mongoose for schema validation. Mention specific aggregations or indexing strategies you implemented.

(General Guide): Mention complex Joins, normalized tables, and how you ensured data integrity.

(General Guide): If applicable, explain how you integrated OpenAI APIs or custom ML models to add smart features (like recommendations or automated text generation).

(General Guide): Always have a challenge ready. (e.g., Handling race conditions, optimizing a slow DB query, learning a new framework quickly). Explain how you solved it.

(General Guide): Use 'I' instead of 'We'. Highlight the specific modules you built, your code review process, and how you collaborated via Git.

(General Guide): Mention technical learnings (like better state management) and soft skills (like effective communication in agile).

(General Guide): Briefly explain what the certification covered and how it practically improved your coding or architectural skills.

(General Guide): Treat this like a standard project but emphasize client communication, gathering requirements, and delivering on deadlines.

(Model Answer): TCS is a global IT leader with a vast presence across domains. I am drawn to the learning opportunities, the massive scale of projects, and the job stability. TCS's commitment to employee growth and societal impact aligns with my long-term career goals.

TCS Vision: To separate the business from the IT infrastructure, allowing clients to focus on their core business while TCS handles the technology.

TCS was founded by J. R. D. Tata and F. C. Kohli in 1968.

The current CEO and MD of TCS is K. Krithivasan (as of mid-2023).

Mumbai, Maharashtra, India.

1968.

TCS handles massive projects like the Passport Seva Kendra in India, IRCTC ticketing system, and core banking transformations using their BaNCS product.

(Model Answer): While I am aiming for the Prime/Digital role due to my specialized skills in new technologies, I am open to the Ninja role as I value the opportunity to start my career with TCS and prove my worth to grow internally.

(Model Answer): Recently, TCS has been heavily investing in Generative AI, launching its AI-driven platform TCS Enterprise Cognitive Hub. They've also been securing mega-deals in the UK and cloud transformation projects globally. Their focus on sustainability and achieving net-zero emissions by 2030 is also prominent.

TCS (Tata Consultancy Services) is an Indian multinational IT services and consulting company, part of the Tata Group. It operates in 150 locations across 46 countries.

(Model Answer): I am a recent graduate with a degree in CSE. I have a strong foundation in [Your Languages] and web development. Recently, I built [Project Name] where I utilized [Tech Stack]. I am passionate about solving problems through code and eager to bring my skills to a professional team.

(General Guide): Keep it brief and positive. E.g., 'I come from a nuclear family of four. My father is in [profession], my mother is [profession]. They have always supported my educational pursuits.'

(General Guide): Mention your city and state clearly.

(General Guide): Be prepared to mention 1-2 interesting facts (historical significance, famous food, or industries).

(General Guide): Mention hobbies that show positive traits (e.g., playing a team sport shows teamwork, reading shows continuous learning).

(General Guide): Mention professional interests like AI trends, open-source contribution, or tech blogs, alongside personal interests.

(Model Answer): My key strengths are my adaptability, problem-solving mindset, and ability to learn new technologies quickly.

(Model Answer): Sometimes I focus too much on details (perfectionism), which can slow me down. However, I am actively using time-boxing techniques to ensure I meet deadlines efficiently.

(General Guide): Be honest. If it was for medical reasons, state it briefly. If for preparation (like UPSC/GATE), frame it positively as a period of intense learning and discipline.

(General Guide): Highlight your consistent performance. If grades dropped, explain what you learned from the setback and how you improved.

(Model Answer): I am flexible, but if given a choice, I would prefer [City]. However, I am completely open to relocating wherever the company needs me.

(Model Answer): Yes, I am absolutely willing to relocate. I see it as a great opportunity to explore a new city and grow independently.

(Model Answer): My goal right now is to find a stable company where I can learn, contribute, and build a long-term career. While career growth is important, I value loyalty and am looking for an organization like yours where I can grow internally rather than jumping from company to company.

(Model Answer): Yes, I am flexible and ready to work in night shifts if the project requires interaction with global clients.

(Model Answer): I am 100% flexible regarding location. My priority is starting my career with a great company.

(Model Answer): I would evaluate the job profile, learning curve, company culture, and long-term growth prospects. Money is secondary at this stage of my career. (Imply that this company wins on those metrics).

(Model Answer): You should hire me because I have a solid technical foundation that matches your requirements. I am a quick learner, highly adaptable, and eager to contribute to the company's success from day one.

(Model Answer): I admire this company's culture of innovation and its impact on the industry. The opportunity to work alongside industry experts here aligns perfectly with my career aspirations.

(Model Answer): I am expecting standard industry compensation for a fresher of my skill level, but my primary focus right now is learning and securing a good role.

(Model Answer): I would first break the remaining tasks into smaller chunks and prioritize them. If I foresee missing the deadline, I would proactively communicate the status to my senior/manager and ask for guidance or help.

(Model Answer): I would try to understand their perspective through open communication. If there's a misunderstanding or a blocker, I'd help resolve it. If it persists, I would escalate it professionally to the team lead.

(Model Answer): I view constructive criticism as an opportunity for growth. I listen objectively, ask clarifying questions, and actively work to implement the feedback.

(Model Answer): I use the Eisenhower Matrix (Urgent vs Important) to prioritize tasks and ensure clear communication with stakeholders regarding realistic timelines.

(Model Answer): Yes, I work well under pressure. I stay calm, prioritize tasks, and focus on one thing at a time to ensure quality isn't compromised.

(HR Question Answer): If I were an HR, I would ask: 1. "Can you describe a time you failed and how you handled it?" (To check resilience and accountability). 2. "How do you prioritize your tasks when you have multiple tight deadlines?" (To check time management and work ethic).

(HR Question Answer): My experience in the technical interview was challenging but very engaging. I enjoyed discussing my project architecture and algorithms. It gave me a good glimpse of the high technical standards expected at this company.

(Bonus Answer): (HR) In a team conflict, I focus on the problem, not the person. I schedule a 1-on-1 meeting to listen to their perspective without interrupting. We discuss our differing views calmly, identify the common goal, and brainstorm a compromise that benefits the project.

(Bonus Answer): (HR) In 5 years, I see myself as a Senior Software Engineer or Technical Lead. I want to have deep expertise in building scalable systems and be in a position where I can mentor junior developers and drive architectural decisions for the team.

(General Guide): Mention any relevant personal projects, coding competitions, or soft-skill experiences (like event organizing) that didn't fit on the page.

You have 3L and 5L jugs, need 4L.
1. Fill 5L jug.
2. Pour from 5L to 3L jug (leaving 2L in 5L jug).
3. Empty 3L jug.
4. Pour the 2L into the 3L jug.
5. Fill 5L jug again.
6. Pour from 5L into the 3L jug until it's full (takes 1L).
7. The 5L jug now has exactly 4L.

To find one missing number in an array of 1 to N:

def find_missing(arr, n):
    expected_sum = n * (n + 1) // 2
    actual_sum = sum(arr)
    return expected_sum - actual_sum

In code: use a Set to store ages, then return the size of the Set. In SQL: SELECT COUNT(DISTINCT age).

(Interview Tip): When writing code on paper, focus on correct logic and indentation. Speak your thoughts aloud so the interviewer understands your approach. Don't worry about minor syntax errors.

(Interview Tip): Give a 2-minute chronological walkthrough. Start with education, highlight key skills, spend the most time on your best project, and conclude with what you are looking for.

(Interview Tip): Be prepared to answer fundamental questions on EVERY skill listed. If you rate yourself 8/10 in Java, expect advanced multithreading/JVM questions.

(Interview Tip): Be able to explain the core concepts learned in the certification, not just that you passed the exam.

(Interview Tip): Stick to the language you are most comfortable solving algorithmic problems in (usually C++, Java, or Python).

(Interview Tip): Be ready to explain the pros and cons of the technology stack you chose for your projects.

(Interview Tip): Highlight practical application over theoretical knowledge. Mention bug fixes, optimizations, or real-world constraints you faced.

(Model Answer): Yes, I use AI tools like Copilot/ChatGPT to boost productivity (like writing boilerplate code or explaining complex errors), but I ensure I thoroughly understand the logic before integrating it into my project.

(Interview Tip): Clearly delineate your responsibilities. 'My teammate handled the frontend, while I designed the database schema and built the REST APIs.'

(Prime Interview Answer): UI focuses on the visual interface (buttons, layouts), while UX focuses on the overall user journey and experience. For a Prime role, you should emphasize how you design scalable and accessible interfaces.

(Prime Interview Answer): I enjoy coding side-projects and participating in hackathons. These hobbies help me stay updated with the latest technologies, which is crucial for a Prime role where deep technical expertise is expected.

(Prime Interview Answer): Briefly explain your family background. Interviewers ask this to understand your support system and personal motivations.

(Prime Interview Answer): I chose my university because of its diverse environment and strong practical curriculum. It gave me the platform to work on advanced projects, which prepared me for a specialized role like TCS Prime.

(Prime Interview Answer): React is used for building dynamic UIs using a virtual DOM. NPM manages packages and dependencies. HTML provides the structural foundation. In a Prime role, you are expected to know how they interact seamlessly in a full-stack environment.

(Prime Interview Answer): Reversing a string is a common screening question. In Python, you can simply use slicing: s[::-1]. In C++ or Java, use a two-pointer approach, swapping the first and last characters, then moving inwards until the pointers meet, achieving O(N) time and O(1) space.

(Prime Interview Answer): To move all zeroes to the end of an array while maintaining the order of non-zero elements, use a two-pointer approach. Keep a pointer insertPos = 0. Iterate through the array; if an element is non-zero, place it at arr[insertPos] and increment insertPos. Finally, fill the rest of the array from insertPos to the end with zeroes. Time: O(N), Space: O(1).

(Prime Interview Answer): An Armstrong number (like 153) is a number that is equal to the sum of its own digits each raised to the power of the number of digits. Logic: extract digits using modulo 10 (num % 10), cube them (or raise to the required power), add to a sum, and divide the number by 10 (num / 10) until it reaches 0.

(Prime Interview Answer): Authentication verifies who the user is (e.g., login via email/password or OAuth). Authorization determines what the user is allowed to do (e.g., checking if the logged-in user has 'admin' privileges to access a specific route or file).

(Prime Interview Answer): A Struct in C/C++ is a composite data type that groups together variables of different data types under a single name. Unlike Classes in C++ where members are private by default, members of a Struct are public by default. It's often used for simple data structures like points or nodes.

(Prime Interview Answer): Reversing a name is identical to reversing a string. In C++, we can use the std::reverse function from the algorithm library, or manually swap characters from both ends using two pointers until they meet in the middle.

(Bonus Answer): To scale for 1 million users: Use load balancers to distribute traffic across multiple app servers (Horizontal Scaling). Implement caching (Redis/Memcached) to reduce database load. Use a CDN for static assets. Implement database sharding or read-replicas. Transition to a Microservices architecture if the monolith becomes a bottleneck.

(Bonus Answer): A Monolith is a unified single unit where UI, business logic, and database access are tightly coupled. Microservices break the application into small, loosely coupled, independently deployable services that communicate via APIs. Microservices offer better scalability and fault isolation but introduce complexity in deployment and monitoring.

(Prime Interview Answer): To optimize code further, I look at algorithmic complexity first—can an O(N^2) loop be reduced to O(N) using a Hash Map? Then I look at space complexity, removing unnecessary data structures. Finally, in web apps, I optimize network calls (debouncing, caching) and database queries (indexing).

(Prime Interview Answer): To validate if a binary tree is a Binary Search Tree (BST), we can use a recursive approach. We pass a minimum and maximum valid range to each node. For the root, it's (-infinity, +infinity). For the left child, the max becomes the root's value. For the right child, the min becomes the root's value. Time complexity is O(N).

(Ninja Interview Answer): GPT stands for Generative Pre-trained Transformer. It is an AI model that generates human-like text. Types include GPT-3, GPT-4, etc.

(Ninja Interview Answer): I am a highly adaptable person. Outside of my technical skills, I frequently organize tech meetups in my college, which has built my leadership and communication skills.

(Ninja Interview Answer): Keep it simple. "I come from a supportive family of four..." They want to see your communication skills.

(Ninja Interview Answer): I have lived away from my family for my studies for several years. This has taught me independence and adaptability, so relocating for the Ninja role is completely fine with me.

(Ninja Interview Answer): Method overriding is when a child class provides a specific implementation of a method that is already provided by its parent class. Variable overriding (shadowing) is when a local variable has the same name as an instance variable, hiding it.

(Ninja Interview Answer): TCS (Tata Consultancy Services) was established in 1968. Its headquarters are in Mumbai, Maharashtra. The current CEO is K. Krithivasan. It is one of the largest IT services and consulting companies globally.

(Ninja Interview Answer): When faced with multiple tasks, I use the Eisenhower Matrix. I prioritize urgent and important tasks first (hard tasks with tight deadlines). Then, I schedule important but non-urgent tasks. If easy tasks can be finished quickly (under 2 minutes), I knock them out to clear my plate.

(Ninja Interview Answer): In my project, I used encryption to secure sensitive user data before storing it in the database. I used standard libraries (like bcrypt for passwords) which apply one-way hashing with a salt, and AES for two-way encryption/decryption of other sensitive fields.

(Ninja Interview Answer): Unit Testing verifies individual components or functions. Integration Testing checks if different modules work correctly together. White Box Testing is a method where the internal structure/code is known to the tester, allowing them to test specific execution paths.

(Bonus Answer): final is a keyword used to restrict modification (constant variables, non-overridable methods, non-inheritable classes). finally is a block in exception handling that executes regardless of whether an exception occurs. finalize is a method called by the garbage collector before an object is destroyed.

(Ninja Interview Answer): I used Local Storage to persist the user's theme preference and cart items across sessions. The main drawback is security; Local Storage is vulnerable to Cross-Site Scripting (XSS) attacks, so sensitive data like JWT tokens shouldn't be stored there.

(Infosys Specific): Infosys typically hires for two main roles: Systems Engineer (SE) and Specialist Programmer (SP). SE focuses on standard application development and support, while SP requires deep programming skills, advanced DSA knowledge, and focuses on complex architectural problems and cutting-edge technologies.

(Infosys Specific): Infosys is famous for its puzzle rounds (often sourced from Shakuntala Devi books). A common one: "Measure 4 liters of water using a 3L and 5L jug." Answer: Fill 5L, pour into 3L. You have 2L left. Empty 3L, pour the 2L into 3L. Fill 5L, pour 1L into 3L until full. You now have exactly 4L in the 5L jug.

(Wipro Specific): Elite is the standard hiring profile targeting freshers for core engineering roles. Turbo is the premium profile offered to candidates who clear advanced coding assessments, offering a significantly higher package and requiring strong problem-solving and algorithmic skills.

(Accenture Specific): Accenture heavily relies on Agile methodologies. You should know that Agile promotes iterative development, daily stand-ups, sprints, and continuous feedback, allowing teams to adapt to changing client requirements quickly compared to traditional Waterfall methods.

(Capgemini Specific): Capgemini often features a dedicated Pseudo-code round. You will be given language-agnostic code snippets involving loops, bitwise operators, and recursion, and you must predict the output. Practice tracing variables line-by-line to ace this.

(Cognizant Specific): GenC is the base profile for fresh graduates. GenC Next (and Elevate) are premium profiles requiring you to pass a skill-based assessment focusing on advanced Java/Python, database querying, and scenario-based coding challenges.

(Deloitte Specific): Deloitte is a consulting firm, so client interaction is key. If a client disagrees with your technical approach, you should: 1. Listen actively to their concerns without getting defensive. 2. Explain the pros and cons of your approach using data. 3. Be willing to compromise to find a solution that meets their business needs.

(IBM/HCL Specific): Companies like IBM and HCL manage massive IT infrastructures for global banks and airlines, many of which still rely on Mainframes for extreme reliability and transaction volume. A common interview topic is discussing the challenges of modernizing these legacy systems to Cloud-native architectures (Hybrid Cloud).

(Product Company Specific): Unlike service companies that test basic syntax and logic, Product companies (FAANG, top startups) focus on optimization. You must know how to use HashMaps for O(1) lookups, understand Dynamic Programming, and confidently calculate Big O Time and Space complexities.

(Product Company Specific): The STAR method (Situation, Task, Action, Result) is crucial for behavioral rounds, especially at Amazon. Always structure your answers to highlight what *you* specifically did (Action) and back up the outcome with measurable data (Result).

(Product Company Specific): High-Level Design (HLD) focuses on the overall system architecture (Load Balancers, Databases, Microservices). Low-Level Design (LLD) focuses on the actual code structure, class diagrams, Object-Oriented principles, and Design Patterns.