CPP

1.Cpp program without main function can be compiled , but not executed as
main () is the entry point to the code

2.An enumeration is a user-defined data type that consists of integral constants.

To define an enumeration, keyword enum is used.
Enum { a, b, c} means a=0 , b=1 ,c=2 default start value is 0, and incremented by
1
Enum { a , b= 5 , c } means a=0 , b=5 , c=6

3.Friend function can access private and protected members of a class.

In class definition define
’ friend <return type> functionname(); ’

4.What are the differences between references and

pointers?
Both references and pointers can be used to change the local variables of one
function inside another function. Both of them can also be used to save copying
of big objects when passed as arguments to functions or returned from functions,
to get efficiency gain. Despite the above similarities, there are the following
differences between references and pointers.

References are less powerful than pointers as:

● Once a reference is created, it cannot be later made to reference another

object, it cannot be reseated. This is often done with pointers.
● References cannot be NULL. Pointers are often made NULL to indicate
that they are not pointing to any valid thing
● A reference must be initialized when declared. There is no such restriction
with pointers

Due to the above limitations, references in C++ cannot be used for implementing
data structures like Linked List, Tree, etc. In Java, references don’t have the
above restrictions and can be used to implement all data structures. References
being more powerful in Java is the main reason Java doesn’t need pointers.
5. Diff between c and cpp and java

6.C++ code is compiled into machine code, which can be directly executed by
the computer's processor. The compilation process involves several steps:

1. Preprocessing: The preprocessor examines the source code and performs

operations such as including header files, macro expansion, and
conditional compilation based on directives like #include and #define.
2. Compilation: The preprocessed code is fed into the compiler, which
translates it into assembly language. The compiler performs lexical
analysis, syntax analysis, semantic analysis, and optimization to generate
an intermediate representation called object code.
3. Linking: If your code includes external libraries or uses functions from
other source files, the linker comes into play. It takes the object code from
the compilation step, resolves external references, and combines them
with the necessary library code to produce an executable file.
4. Loading: The executable file is loaded into memory by the operating
system, preparing it for execution.
5. Execution: The processor executes the loaded machine code, following
the instructions and logic of the program.

7. Diff between class and struct cpp CLICK

8. Operator overloading - click

9. Virtual functions - click

10.malloc() vs new -

The main difference between new and malloc lies in their usage and behavior
within C++.

1. Allocation and Deallocation:

○ new: In C++, new is an operator used for dynamic memory allocation. It
not only allocates memory but also calls the constructor to initialize the
allocated memory. To deallocate memory allocated with new, you use the
delete operator, which not only frees the memory but also calls the
destructor for proper cleanup.
○ malloc: In C, malloc is a function that allocates a block of memory of the
specified size in bytes. It does not initialize the allocated memory. To
deallocate memory allocated with malloc, you use the free function, which
simply frees the memory without any additional cleanup.
 2. Type Safety:
○ new: new is type-safe and works with C++ classes. It automatically
calculates the size of the object being allocated based on the type.
○ malloc: malloc is not type-safe and operates purely in terms of bytes. It
does not know or consider the type of object being allocated. You need to
manually specify the number of bytes to allocate.

11.What is the stack and the heap in C++?

1. Stack:

The stack is a region of memory that is managed automatically by the

compiler and used for storing local variables, function call information, and
other related data. It works on a "last-in, first-out" (LIFO) principle,
meaning that the most recently pushed item is the first to be popped out.

● Stack memory is organized in frames, with each frame representing a

function call. When a function is called, a new frame is created on top of
the stack, and when the function returns, its frame is removed from the
stack.
● Variables declared within a function, including parameters and local
variables, are typically allocated on the stack.
● Stack memory allocation and deallocation are fast, as it involves simple
pointer manipulation.
 ● The stack size is usually limited, and exceeding this limit can result in a
stack overflow and program termination.

2. Heap

The heap is a region of memory used for dynamic memory allocation. It is not
automatically managed and requires explicit allocation and deallocation by the
programmer.

● Memory on the heap is typically allocated using operators like new and
new[] in C++ or functions like malloc in C.
● Heap memory is used for objects with a longer lifespan, such as
dynamically created objects and data structures.
● The programmer is responsible for deallocating the memory when it is no
longer needed using operators like delete and delete[] in C++ or the free
function in C.
● Heap memory allocation and deallocation can be slower compared to the
stack because it involves searching for available blocks of memory and
maintaining a heap data structure.
● The heap size is usually larger than the stack and can grow dynamically as
needed, but excessive and uncontrolled allocation can lead to memory
fragmentation and potential performance issues.

12. Dangling pointer - pointing to memory location which doesnt have any value

13. Memory Leak - Memory leaks occur when dynamically allocated memory is
not properly deallocated. Over time, these leaks accumulate, resulting in unused
memory that is not released back to the system. As a result, the program's
memory usage gradually increases, leading to excessive memory consumption.
This can cause performance degradation and may eventually result in the
program running out of available memory and unknown erors and bugs

14. Smart pointers - here

15. Shallow vs deep copy

16. What and why templates - The simple idea is to pass the data type as a
parameter so that we don’t need to write the same code for different data types.
Templates are expanded at compiler time. This is like macros. The difference is,
that the compiler does type-checking before template expansion.Templates allow
you to write generic code that works with multiple types, reducing the need for
code duplication and providing flexibility and reusability.

17. Template types -

function template- We write a generic function that can be used for different data
types. Examples of function templates are sort(), max(), min(),

Class template - class templates are useful when a class defines something that
is independent of the data type. Can be useful for classes like LinkedList,
BinaryTree, Stack, Queue, Array, etc.
18. STL

The STL (Standard Template Library) is a library in the C++ programming

language that provides a collection of generic algorithms and data structures. It
is a key component of the C++ Standard Library and is widely used by C++
programmers to write efficient and reusable code.

Components - containers ( map , set, linkedlist , vector ) , algorithms ( sort ,

search , transform( like merge reverse algorithms ) , iterators (traverse over
containers allowing input output and random access in case of vector) , function
objects , Allocators ( flexible mechanism for alloc and delloc of memory)

19. Exception Handling -

Exceptions are runtime anomalies or abnormal conditions that a program

encounters during its execution. There are two types of exceptions:
a)Synchronous, b)Asynchronous (i.e., exceptions which are beyond the
program’s control, such as disc failure, keyboard interrupts etc.)
Fixed using try catch finally block

If an exception is thrown and not caught anywhere, the program terminates

abnormally
Implicit type conversion doesn’t happen for primitive types.
Catch all block ( catch(...) {} ) executes if exception thrown of any type

Unlike Java, in C++, all exceptions are unchecked, i.e., the compiler doesn’t
check whether an exception is caught or not

Like Java, the C++ library has a standard exception class which is the base class
for all standard exceptions. All objects thrown by the components of the standard
library are derived from this class. Therefore, all standard exceptions can be
caught by catching this type

20. Multiple Inheritance - here

21. Diff between friendship functions and inheritance - click
22. Const vs constexpr

In summary, while both const and constexpr are used to create constants, const
is evaluated at runtime and can have different values for different instances,
while constexpr is evaluated at compile-time and must have a value that can be
determined during compilation.

23. Pass by ref vs pass by pointer - here

24. Pointer logic in cpp

Int x = 10 ; // created a new variable called x with value 10
Int* ptr = &x // a pointer created called ptr which points to memory location of x
// &x is used to retrieve the memory location of x
Cout << ptr //outputs memory address of x
Cout << *ptr //outputs value stored in memory location of x*ptr = 100 // edits
value to 100 for x as it was pointing to mem addr of x
cout<<x // outputs 100

Int &ref = x; // ref is an alias for x , i.e. any change in x or ref , will result in
change for both ref and x , both variables point to the same location

*x is dereferencing a pointer variable,

&x is getting the address of a variable

List Node* tmp = new ListNode() is creating a new list node object with the
default constructor on the heap and storing a pointer to it as tmp
fn (vector<int> &nums) is passing nums by reference, meaning nums is not
copied it is used as-is from the place the function is called
&nums is basically a shortcut to passing a pointer and dereferencing it yourself
to use

25. Volatile keyword tells the compiler that the value of a variable must never be
cached as its value may change outside of the scope of the program itself.This is
crucial when dealing with hardware registers or shared memory accessed by
multiple threads.

26. Name mangling in cpp - here

27.Upcasting and Downcasting in cpp - here

28. Inline Functions - here

29. Vtable and Vptr
The compiler places the addresses of the virtual functions for that particular class
in the VTABLE. In each class with virtual functions, it secretly places a pointer,
called the vpointer (abbreviated as VPTR), which points to the VTABLE for that
object
JAVA

1.Both equals() method and the == operator are used to compare two objects in
Java. == is an operator and equals() is method. But == operator compares
reference or memory location of objects in a heap, whether they point to the
same location or not.
Whenever we create an object using the operator new, it will create a new
memory location for that object. So we use the == operator to check memory
location or address of two objects are the same or not.

{
String s1 = "HELLO";
String s2 = "HELLO";
String s3 = new String("HELLO");

System.out.println(s1 == s2); // true

System.out.println(s1 == s3); // false
System.out.println(s1.equals(s2)); // true
System.out.println(s1.equals(s3)); // true
}

2.Exceptions - 2 types , builtin ( out of bounds, arithmetic , file not found etc)
User defined -create your own exception subclass by
inheriting Exception class

3.Error vs exception
Error refers to an illegal operation performed by the user which results in the
abnormal working of the program. Programming errors often remain undetected
until the program is compiled or executed. (compile time , run time or logical)
Exceptions are the conditions that occur at runtime and may cause the
termination of the program. But they are recoverable using try, catch and throw
keywords. Types - CHecked( compiler knows like ArrayIndex out of bounds
exception) , unchecked (found during runtime like filenotfound)
4.throw is a keyword in java which is used to throw an exception manually
throws is also a keyword in java which is used in the method signature to
indicate that this method may throw mentioned exceptions
Throwable is a super class for all types of errors and exceptions in java. This
class is a member of java.lang package

5.finalize is the method in Java which is used to perform clean up processing

just before object is garbage collected , i.e. object destroyed
finally is the block in Java Exception Handling to execute the important code
whether the exception occurs or not.
Final is the access modifier used with function class or variable
(1) Once declared, final variable becomes constant and cannot be modified.
(2) final method cannot be overridden by sub class.
(3) final class cannot be inherited.

6.A thread is also known as a lightweight process. The idea is to achieve

parallelism by dividing a process into multiple threads. For example, in a
browser, multiple tabs can be different threads.

7.Threads in java created by implementing the Runnable interface and defining

task in run() or extending thread class and overriding run() method

When multiple threads access shared resources concurrently, it can lead to race
conditions and inconsistencies. Java provides synchronization mechanisms,
such as the synchronized keyword, to ensure that only one thread can access
a shared resource at a time.

Synchronization and concurrency issues - deadlocks , race conditions , data

inconsistency

8.https://www.javatpoint.com/c-vs-cpp-vs-java

9.JVM (Java Virtual Machine): JVM(Java Virtual Machine) acts as a run-time

engine to run Java applications. JVM is the one that calls the main method
present in Java code.
JRE (Java Runtime Environment): JRE refers to a runtime environment in
which Java bytecode can be executed. It implements the JVM (Java Virtual
Machine) and provides all the class libraries and other support files that JVM
uses at runtime. It is to transform bytecodes into native machine code at runtime,
the Just-In-Time (JIT) compiler, a part of the runtime environment, improves the
performance of Java applications.
(Java Development Kit): It is the tool necessary to compile, document, and
package Java programs. The JDK completely includes JRE which contains tools
for Java programmers.

10.java.lang.Object is the root class for all the Java classes and we don’t need to
extend it

11.A static method cannot access non-static variables or methods because static
methods can be accessed without instantiating the class, so if the class is not
instantiated the variables are not initialized and thus cannot be accessed from a
static method.

3 types of variable in java - local , static , instance

12.Wrapper classes convert the Java primitives into reference types (objects).
Every primitive data type has a class dedicated to it. These are known as
wrapper classes because they “wrap” the primitive data type into an object of
that class.

13.Java doesnt have pointers because pointers are not necessary for OOP
model and also pointers make the program complex .JVM is responsible for
implicit memory allocation, thus to avoid direct access to memory by the user,
pointers are discouraged in Java.

● Can we overload static methods? The answer is ‘Yes’. We can have

two ore more static methods with same name, but differences in input
parameters
● Can we Override static methods in java? We can declare static
methods with same signature in subclass, but it is not considered
overriding as there won’t be any run-time polymorphism. Hence the
answer is ‘No’. Static methods cannot be overridden because method
overriding only occurs in the context of dynamic (i.e. runtime) lookup of
methods. Static methods (by their name) are looked up statically (i.e. at
compile-time).
When we remove static modifier from main method Program compiles
successfully. But at runtime throws an error “NoSuchMethodError”.

This keyword - Used to refer current class instance variable.To invoke current
class constructor

14. Abstract class vs interface click

15.Abstract classes are classes that contain one or more abstract methods. An
abstract method is a method that is declared but contains no implementation.
Abstract classes may not be instantiated, and require subclasses to provide
implementations for the abstract methods.

16.In Java, all classes inherit from the Object class directly or indirectly.
Therefore, there is always a single inheritance tree of classes in Java, and
Object class is the root of the tree.

17.In Java, all objects are dynamically allocated on Heap. This is different from
C++ where objects can be allocated memory either on Stack or on Heap. In C++,
when we allocate object using new(), the object is allocated on Heap, otherwise
on Stack if not global or static.
In Java, when we only declare a variable of a class type, only a reference is
created (memory is not allocated for the object). To allocate memory to an object,
we must use new(). So the object is always allocated memory on the heap.

18.Java is pure OO , as there is no concept of global scope , however it can be

not pure OO as primitive datatypes exist

19.Create objects in java by -

1. Using new keyword
2. Using new instance of class
3. Using clone() method implement Cloneable
4. Using serialization and deserialization implement Serializable
5. Using newInstance() method of Constructor class

20.The main objective of Garbage Collector is to free heap memory by

destroying unreachable objects , i.e. if no reference is made to an object from
any part of code, it means this object is no longer needed hence garbage
collector frees up space in the heap.
Java garbage collection is an automatic process. Automatic garbage collection is
the process of looking at heap memory, identifying which objects are in use and
which are not, and deleting the unused objects. An in-use object, or a referenced
object, means that some part of your program still maintains a pointer to that
object. An unused or unreferenced object is no longer referenced by any part of
your program. So the memory used by an unreferenced object can be reclaimed.
The programmer does not need to mark objects to be deleted explicitly. The
garbage collection implementation lives in the JVM.

21. Arraylist vs Linkedlist - here

22, static vs instance variable - here
24. Super keyword -
1. super can be used to refer immediate parent class instance variable.
2. super can be used to invoke immediate parent class method.
3. super() can be used to invoke immediate parent class constructor.

JS

1)It is dynamically typed languge ,i.e. We dont need to provide data types while
coding

2)single threaded language , handles promises and callbacks and timers using a event
loop. It has a call stack which is maintained.
3) anonymous functions
var a = function () // called anonymous function
{
//do something
}

We can not name functions if we assign them to variables, can invoke this
function using ‘a’

Java vs JS – here
4) JavaScript data types - String , number, bigint , bool , undefined , null , symbol , object

5) null vs undefined - Undefined means the variable has been declared, but its value has
not been assigned. Null means an empty value or a blank value. The typeof() operator returns
undefined for an undefined variable. The typeof() operator returns the type as an object for a
variable whose value is assigned as null

6)

Immediately Invoked Function Expression (IIFE)

(function sum(a,b) {
Return a+b
})(3,4) will invoke as soon as compiler comes across this code line.

5)JS allows functions inside a function

PYTHON
link 1 link 2
6) Scope and hoisting example -

HOISTING
Declaration of functions and variables ( declared by var only moved to the top of
the current scope) only declarations hoisted not initializations
In above example , var b is declared at start of function fun

As I've explained in this article, let and const variables are hoisted, only they
are hoisted without a default initialization. This makes them inaccessible (as
such variables are in a temporal dead zone). Variables declared with var , on the
other hand, are hoisted with a default initialization of undefined

7)CLOSURE - A closure is a feature of JavaScript that allows inner functions to

access the outer scope of a function. Closure helps in binding a function to its
outer boundary and is created automatically whenever a function is created.
Closure is the concept of function + lexical environment in which function it was
created. so every function declared within another function then it has access to
the scope chain of the outer function and the variables created within the scope
of the outer function will not get destroyed.
8) Rest operator -(spread operator)

function f(...args) {
const sum = args[0] + args[1];
return sum;
}
console.log(f(3, 4)); // 7

(...) rest operator , allows arguments to be read as an array

9)Arrow functions do not support function hoisting

Arrow functions donot have this binding , no super binding , cannot be used as
constructors and dont have their own argument object

10) create objects in java by - enclosing key value pairs within {} ,

Object.create(<prototype>) creates an object of passed prototype , using classes
or constructor functions with new keyword

11)map() creates a new array from calling a function for every array element.
The filter() method creates a new array filled with elements that pass a test
provided by a function.
The reduce() method executes a reducer function for array element.The reduce()
method returns a single value: the function's accumulated result.

12)Js alternative of for(auto it: vector ) is –

for(var i in array) // here i is index , if u want to use i in operations , change it to
number by Number(i) , it is by default string

for(var i of array) // here i is now element of array

13)Js apply method can be used to give context to some function about an
object. Parameters passed as array
Js apply and Js call and js bind
Read more here
14)Asynchronous Operations in JS by callback functions or Promises.

Callback Hell - Callback Hell is essentially nested callbacks stacked below one
another forming a pyramid structure. Every callback depends/waits for the
previous callback, thereby making a pyramid structure that affects the readability
and maintainability of the code.

Promises
they are like callbacks but better.
Syntax →

let myPromise = new Promise(function(myResolve, myReject) {

// "Producing Code" (May take some time)

myResolve(); // when successful

myReject(); // when error
});

// "Consuming Code" (Must wait for a fulfilled Promise)

myPromise.then(
function(value) { /* code if successful */ }),
.catch( function(error) { /* code if some error */ })
);

Resolve - when success , reject when failure

Promise.then ( what happens on success )
.catch ( when rejected)
.finally(), which allows you to run code regardless of whether the promise
was fulfilled or rejected.

Promise.all([p1,p2,p3…p50]).then( //all promises resolved )

Promise.race([p1,p2,p3…p50]).then( //when any one promise resolved )

.
Promises have three states:

1. Pending: The initial state when a promise is created, indicating that the
asynchronous operation is still in progress and the final result is not yet
available.
2. Fulfilled: The state of a promise when the asynchronous operation has
completed successfully. The promise returns a value, and this value is
passed as an argument to the resolve function.
3. Rejected: The state of a promise when the asynchronous operation
encounters an error. The promise returns an error, and this error is passed
as an argument to the reject function.

We can use promises with async await syntax which is much much easier to
read
JavaScript Async Await

16)High order functions - fns which take other functions as args or returns
another funs

JS passes objects by reference

JS is garbage collected

17)EVENT LOOP
JavaScript run time can do one thing at a time . Javascript = JS Runtime +
Browser Web APIS.
Most async functions like setTimeout fetch etc are taken care of by web APIs

Call stack - functions executed based on this stack in LIFO manner

When async function encountered, it is sent to web api to perform , meanwhile
code execution furthers.
When api execution done , the callback function is added to event queue.
Event loop pulls items from the event queue and pushes into the stack whenever
stack becomes empty
This event loop gives java the illusion of being multithreaded
18)PROTOTYPAL INHERITANCE

Arrays , functions , objects all have some predefined methods which we can use
without implementing they come from Array Object , Function Object , etc

arr = [ 1,2,3]
Arr.__proto__ // equals Array Object
Arr.__proto__ .__proto__ ??equals Object

inheritance in JS => When an object trying to access variables and properties of

another object
prototype is an Object that get attach to function/method/object and this object
has some hidden properties
Whenever we create object/ function/ methods/ array/ variable , these all are
attached with some hidden properties, which we call prototype _proto_ is
reference to prototype ( or it points towards prototype ), if we want to access
prototype, we do _proto_ prototype object has a prototype of its own, and so on
until an object is reached with null as its prototype, this is called prototype
chaining

Very good video

Prototype and Prototypal Inheritance in Javascript | Frontend Interview Que…

19)Map vs WeakMap here

Set vs WeaksSet here

20)Currying - transforms the function of multiple arguments into several functions

of a single argument in sequence.
Useful - It helps us to create a higher-order function
● It reduces the chances of error in our function by dividing it into multiple
smaller functions that can handle one responsibility.
● It is very useful in building modular and reusable code
● It helps us to avoid passing the same variable multiple times
● It makes the code more readable
21)What is rate limiting - An implementation for limiting the amount of time
between function calls in JavaScript may be necessary when any sort of process
requires regulation like generating network requests. Whether it’s an API call,
data store, or even a DOM event, multiple consecutive firings of a function may
not give enough time for the intended result before the next invocation occurs

Debouncing in JavaScript is a practice used to improve browser performance.

There might be some functionality in a web page that requires time-consuming
computations. If such a method is invoked frequently, it might greatly affect the
performance of the browser, as JavaScript is a single-threaded language.

Throttling implies limiting the number of times a function gets called in a certain
time period. It will prohibit a function from executing if we have invoked it
“recently

Throttling vs debouncing - here

https://www.youtuube.com/watch?v=8eRVxE9PEF0
https://www.youtube.com/watch?v=83ZSwO3BdHk

Web Dev Related Questions

1) How to save password in Database -
We save the hash values of passwords in our database.
Hash is a one way function , which means if an attacker has the hashed value it
is not easy for him to get the password.
Nowadays, techniques like rainbow tables can be used to crack hashed
passwords , so to be more secure what we do is,

We hash ( password + salt ) salting means adding a randomly generated string

to our password.
In data base we save -
USER ID — SALT VALUE — HASH( password + salt )

Now when a user tries to login , we add this salt value with the password entered
and then hash it. Now we compare this with the hash value stored.
Hashing is absolutely necessary , saving password plain text in database is very
dangerous because it means that anyone with the access to data base or if the
db is compromised the password can be seen.

2) Web Dev things -

internet protocol first assigns every computer an IP address which is used to
identify that computer
Then these computers can send data back and forth using TCP , Data broken
into small packets.
World wide web sits on top of internet and is a software where people can sit on
their laptops and access web pages using http
Every website is given a unique URL.
Humans use Web Browser to access web pages.
Browser is a client which sends http request and the server sends response
containing web page content.
Every website has a domain name , which is routed via the DNS. which maps
the domain to actual Ip address on a server located somewhere.
DNS can be thought of as the phonebook of the internet.

Website are html which contain lots of elements , these elements are nested
together in a hierarchy to form the Document Object Model.
After the root element, webpage is split into two parts. The head contains
invisible content like the meta data and the title , then comes the body which the
end user can see.

Media Querys allow you to get information about the device thats rendering the
web page and apply different styles and layouts accordingly.
We need JS to handle events , whenever any interaction is done on the browser
like click , we can handle these events using browser apis like document which
provides a method called QUERY SELECTOR that allows us to grab elements
with a css selector. Now that we have that element set as a variable we can
assign event listeners to it .

Writing JS HTML CSS on its own for websites can be too low level , and most
developers use frameworks like react or angular these do the same thing in a
different way , these represent the UI as a tree of components. A component
encapsulates html css and js into a format which looks like a custom html
element and these framworks makes the code declarative , i.e. we write what the
ui does.
Http requests are sent to the backend to fetch or update data.
Most apps are containerized with docker making them easy to scale up and
down based on traffic received

3)Authentication - jwt session id cookies

Authentication serves as the foundation for secure systems and applications,

preventing unauthorized access, protecting sensitive data, and ensuring user
accountability. It is an essential aspect of building secure and trustworthy digital
experiences.

Jwt - Json web token is fullform

Before we deep dive into what jwt is , lets see why it is needed and what was
used before this.
The entire problem lies with how http works. Since it is stateless , so we have to
send all the details in the request every single time. To combat this , session id
was used which would be a reference to user details which would be saved in file
system locally as cookies now the website knows who i am and i dont have to
privide details till that session id expires. This is stored in browser in form of
cookies. Now this works fine but the problem is server architecture has changed
with time. Earlier there would be one monolithic server which would have a
lookup table with all session ids and we were doing fine. But now there are
multiple servers and a load balancer is used to route request to different servers .
Server 1 knew who i was , but now my request routed to server 2. This could be
solved by having a common lookup table , but what if it fails it is not fault tolerant.
So to combat all this jwt is used. Instead of browser giving us a reference to our
data , it generates a json token containing all the necessary details. Which is
used for Authorization purposes.

A JSON web token(JWT) is JSON Object which is used to securely transfer

information over the web(between two parties). It can be used for an
authentication system and can also be used for information exchange.The token
is mainly composed of header, payload, signature.
A header in a JWT is mostly used to describe the cryptographic operations
applied to the JWT like signing/decryption technique used on it
The payload is the part of the JWT where all the user data is actually added. This
data is also referred to as the ‘claims’ of the JWT.This information is readable by
anyone so it is always advised to not put any confidential information in here
Signature is the third part of JWT and used to verify the authenticity of token.
BASE64URL encoded header and payload are joined together with dot(.) and it
is then hashed using the hashing algorithm defined in a header with a secret key.

4)What is restful api?

Most apps these days follow client server architecture ,ie the frontend part is
what the client sees and under the hood it needs to talk to a server which is the
backend code. This communication is done by http requests which is were restful
api comes in
For every crud operations there are requests like post , get , put , delttee

http:/<domain> / api / resource

The resource is exposed on which the http requests will work

5) HTTP vs HTTPS
The main difference is that data passed in http requests are plain texts hence
not secure.
In https , the requests are encrypted using TLS.
TLS handshake —->

Step 1 - normal TCP handshake

Step 2- Certificate Check
a) Client hello sent - it contains list of encryption algos which client supports
b) Server hello sent - contains info about encryption algo selected for the
entire communication
Server sends the certificate - contains public key of the server.
Client will use public key of server to perform asymmetric encryption
Step 3 - Key exchange
a) Client creates a session key and encrypts it with the server public key.
b) Server received the encrypted session key and decrypts using its private
key. Now both client and server have session key and data exchange can
happen
6) what happens when u type www.google.com and press enter ?

Before diving into what happens on typing a url , lets discuss briefly what url is.
So it contains http or https which is the protocol or scheme used to establish
connection.
The next part is domain which is necessary to retrieve the requested webpage.

Once a URL is entered the browser needs to know how to reach the server and
its done by DNS LOOKUP. DNS or Domain Name System can be thought of as a
phonebook for the internet as it maps domain names with ip addresses of the
servers.

Now we try to find the DNS entry in different places till it is found
FIrst browser cache is checked , then OS cache , then the router cache then the
ISP cache.
If not found in above 4 caches, browser runs a recursive lookup from 1 dns
server to another until the required IP of the server is fetched.

Caching at so many places is necessary because it helps in regulating network

traffic by improving data transfer times.
The next step is establishing a TCP connection between the server anf the
browser
This is a three-step process where the client and the server exchange
SYN(synchronize) and ACK(acknowledge) messages to establish a connection.

1. The client machine sends a SYN packet to the server over the internet, asking
if it is open for new connections.

2. If the server has open ports that can accept and initiate new connections, it’ll
respond with an ACKnowledgment of the SYN packet using a SYN/ACK packet.

3. The client will receive the SYN/ACK packet from the server and will
acknowledge it by sending an ACK packet.

Now a connection is established.

Now the browser will send a GET request and the server and the server will send
back adequate response. The browser will render the response and display the
HTML content.

7) DOM
DOM stands for Document Object Model. It is a programming interface for web
documents, such as HTML, XML, or XHTML. The DOM represents the structure
of a document as a tree-like model, where each element, attribute, and text node
in the document is represented as an object.

The DOM tree consists of various types of nodes, including the document node,
element nodes, attribute nodes, and text nodes. Each node in the tree can have
child nodes and parent nodes, forming a hierarchical structure. By traversing and
manipulating this tree structure, developers can interact with and modify the
document's content and structure.

8) ORM
ORM stands for Object-Relational Mapping. It is a programming technique and a
software pattern that enables developers to work with relational databases using
an object-oriented approach. ORM bridges the gap between the relational
database and the object-oriented programming language, allowing developers to
interact with the database using objects and their methods instead of writing SQL
queries directly.

9) Browser Security
XSS-XSS stands for Cross-Site Scripting. It is a type of security vulnerability that
occurs when a web application does not properly sanitize or validate
user-supplied input and allows malicious scripts to be injected and executed in
users' browsers.

The basic idea behind XSS is that an attacker can inject malicious code, typically
JavaScript, into a web page viewed by other users. This can happen through
input fields, comment sections, or any other user-input areas where the
application fails to properly filter or escape the input. When unsuspecting users
view the affected web page, the injected script is executed in their browsers,
potentially compromising their sensitive data, session information, or enabling
further attacks.

SQL INJECTION - SQL injection is a type of security vulnerability that occurs

when an application fails to properly validate or sanitize user-supplied input that
is used to construct SQL queries. This allows an attacker to manipulate the SQL
statements executed by the application's database, potentially gaining
unauthorized access to data, modifying data, or performing other malicious
actions.

The vulnerability arises when user input is directly concatenated into SQL
queries without proper sanitization or parameterization. If the application does
not validate or escape user input, an attacker can craft input in such a way that it
alters the intended SQL query structure or injects malicious SQL code.

CSRF
CORS -CORS stands for Cross-Origin Resource Sharing. It is a mechanism that
allows web browsers to relax the same-origin policy and enables web pages
from different origins (domains, protocols, or ports) to request and share
resources with each other.

The Same-Origin Policy is a fundamental security concept enforced by web

browsers to prevent web pages from making requests to different origins
(domains, protocols, or ports) and accessing each other's resources. It is an
important security mechanism that helps protect sensitive data and prevents
various types of attacks, such as cross-site scripting (XSS) and cross-site
request forgery (CSRF).

According to the Same-Origin Policy, web pages can only access resources
(such as APIs, cookies, or DOM elements) from the same origin as the page
itself. An origin is defined by the combination of the protocol (e.g., HTTP or
HTTPS), the domain (e.g., example.com), and the port number (if specified).
CSP stands for Content Security Policy. It is a security feature implemented by
web browsers to mitigate the risks of cross-site scripting (XSS) attacks and other
types of code injection vulnerabilities. CSP allows website administrators to
define a policy that specifies which sources of content, such as scripts,
stylesheets, or images, are considered trusted and allowed to be loaded by the
browser.

REACT
Event emitter

React component lifecycle - 3 phases

1)mounting - methods are called in the following order when an instance of a
component is being created and inserted into the DOM
Likeconstructor(),getstatefromprops(), render() ,componentDidMount()

2) updating - these methods called when component re-renders due to change in

state - GetDerivedStateFromProps() , render() ,
did component update()

3)unmounting - method is called when a component is being removed from the

DOM - componentDidUnmount()

Hooks –
1) only in func components
2) call hooks in the same order they are decalred

UseState - allows us to track state in a function component.

Syntax -
Const [ data , setData (is a function) ] = useState(defsult value)
When setData function executed everything re rendered

When using setState , always use spread operator to old merge data. If we have
setstate running on an object , entire thing will be overridden if we dont merge in
the old values

useEffect - allows you to perform side effects in your components.

useEffect(<function>, <dependency>) 2nd argument optional. Its an array which has
props or states .use effect called when these props altered

Everytime page renders, the function is called

useContext
Imagine a situation where we have 5 nested components and the 1st and 5th
component needs access to some state. However to allow this all intermediate
components will have to pass the state as props which increases complexity
(called prop drilling), to combat this we use Use context hooks
React Context is a way to manage state globally
Check some examples

link 1 link 2

NEXT JS -
frame work built on top of react with some added features

SSr -Server-side rendering (SSR) is a technique that renders a web page on the server rather
than in the browser. When a website's JavaScript is rendered on the website's server, a fully
rendered page is sent to the client. The user will then get an fully rendered HTML page that
contains all of the necessary information for them to see your site without having to wait for any
JavaScript or CSS files to load.
Ease of routing - For
routing in react we have to rely on 3rd party libraries like
React Router where as for next it has an inbuilt routing based on file
system structure, so by adding /dashboard will route us to dashboard.js

Django
link 1 link 2

OOPS
Link link
 OS
OPEN AT SIDE – MAIN NOTES , following is extra info

1) What is OS ? why Important ? functions ?

An operating system is a piece of software that manages all the resources of a
computer system,both hardware and software, and provides an environment in
which the user can execute his/her programs in a convenient and efficient
manner by hiding underlying complexity of the hardware and acting as a
resource manager.
Functions - resource and process management , memory management ,
security and virtualization , file system management
Goals - maximise cpu util , Higher priority job execution ,Less process starvation

2) Types of OS -
a)Batch-Processing OS - A Batch Operating System is a type of operating
system that does not interact with the computer directly. There is an operator
who takes similar jobs having the same requirements and groups them into
batches and then processor works on them. Problems - priorities cant be set ,
idle time during IO , lead to starvation
b)Distributed OS - manages a group of different computers and makes appear
to be a single computer. These operating systems are designed to operate on a
network of computers. They allow multiple users to access shared resources and
communicate with each other over the network
c)Real time OS - serves a real-time system and the time interval required to
process and respond to inputs is very small. These operating systems are
designed to respond to events in real time. They are used in applications that
require quick and deterministic responses, such as embedded systems,
industrial control systems, and robotics.
d) Time Sharing OS - A time-shared operating system uses CPU scheduling
and multi-programming to provide each user with a small portion of a shared
computer at once. Each user has at least one separate program in memory. A
 program is loaded into memory and executes, it performs a short period of time
either before completion or to complete I/O. This short period of time during
which the user gets the attention of the CPU is known as time slice, time slot,
or quantum.

3)RAM vs ROM + Types - here

4)Virtualization vs Containerization - here
5)Program vs Process vs thread - here

6)User-level thread vs kernel level thread - here

7) Kernels - Heart of OS , system which interacts directly with the hardware and
performs the most crucial tasks.
A shell, also known as a command interpreter, is that part of the operating system
that receives commands from the users and gets them executed.

8)Explain how does a process gets executed inside memory - explain process state
and queue

9)Optimal number of threads for a process - 1 thread per core

10) Ageing is a technique of gradually increasing the priority of processes that wait
in the system for a long time
It solves problem of starvation

11)What is the role of the file system in an operating system?

A file system is a method an operating system uses to store, organize, and manage
files and directories on a storage device
12)What is a device driver and what is its purpose?
A device driver is a specialized software that operates a particular
computer-connected device—offering a software interface to the hardware allows
operating systems and other computer applications to access hardware
functionalities.

13)How does an operating system handle I/O operations? Using device driver
14)What is the role of the interrupt handler in an operating system? here
15)How does a process communicate with another process in an operating system?
Inter Process COmmunication happens in 2 ways
a) Shared memory model - processes read write data in shared memory
space and exchange info
b) Message passing -

16) How does an operating system handle file permissions and security?
File protection is an essential component of modern operating systems, ensuring
that files are secured from unauthorised access, alteration, or deletion.
Some mechanisms are - file permissions , encryption , access control lists , logging ,

17)Explain the concept of spooling in an operating system.

Spooling is an acronym for simultaneous peripheral operation online. Spooling is
the process of temporary storage of data for use and execution by a device,
program, or system. Data is sent to and stored in main memory or other volatile
storage until it is requested for execution by a program or computer. Spooling makes
use of the disc as a large buffer to send data to printers and other devices. It can
also be used as an input, but it is more commonly used as an output. Its primary
function is to prevent two users from printing on the same page at the same time,
resulting in their output being completely mixed together. It prevents this because it
uses the FIFO(First In First Out) strategy to retrieve the stored jobs in the spool, and
that creates a synchronisation preventing the output to be completely mixed together

18)How does an operating system handle file system fragmentation

In computing, file system fragmentation, sometimes called file system aging, is
the tendency of a file system to lay out the contents of files non-continuously to allow
in-place modification of their contents. It is a special case of data fragmentation. File
system fragmentation negatively impacts seek time in spinning storage media, which
is known to hinder throughput. Fragmentation can be remedied by re-organizing files
and free space back into contiguous areas, a process called defragmentation.

19) What is the purpose of a bootloader in an operating system?

enables loading the operating system within the computer memory when a
computer is started or booted up. A boot loader is also known as a boot manager
or bootstrap loader

SECONDARY STORAGE DISKS

Seek Time

Seek time is the time taken in locating the disk arm to a specified track where the
read/write request will be satisfied.

Rotational Latency

It is the time taken by the desired sector to rotate itself to the position from where
it can access the R/W heads.

19. Disk scheduling algorithms

Disk scheduling is a key component of disk management that determines the

order in which disk I/O (input/output) requests are processed and serviced by the
disk controller. It aims to minimize the seek time and rotational latency and
maximize the overall disk performance.

1. FCFS (First-Come, First-Served): This is the simplest disk scheduling

algorithm that processes requests in the order they arrive. It does not
consider the position of the disk head or the proximity of the requests,
resulting in potential delays if there are long seek times between requests.
2. SSTF (Shortest Seek Time First): This algorithm selects the request with
the shortest seek time from the current position of the disk head. It
minimizes the average seek time and reduces the overall disk access time.
However, it may lead to starvation of requests located farther away from
the current position.
 3. SCAN: Also known as the elevator algorithm, SCAN moves the disk head
in one direction (e.g., from the outermost track to the innermost or vice
versa) and services requests along the way. Once it reaches the end, it
changes direction and continues the same process. This algorithm
provides a fair distribution of service and prevents starvation, but it may
result in longer response times for requests at the far ends of the disk.
4. C-SCAN (Circular SCAN): Similar to SCAN, C-SCAN moves the disk
head in one direction, but instead of reversing direction, it jumps to the
other end of the disk and starts again. This ensures a more consistent
response time for all requests, but it may cause delays for requests that
arrive after the head has passed their location.
5. LOOK: LOOK is a variant of SCAN that only goes as far as the last
request in its current direction. Once there are no more requests in that
direction, it reverses direction. This reduces unnecessary traversal of the
entire disk and improves response times for requests.
6. C-LOOK (Circular LOOK): Similar to C-SCAN, C-LOOK jumps to the
other end of the disk without servicing requests along the way. This
reduces seek time and improves disk throughput.

DBMS

CN

System Design LLD

What is LLD ?
In LLD, the focus is more on designing each component in detail such as what classes are
needed, what abstractions to use, how object creation should happen, how data flows between
different objects, etc. LLD converts the high-level design into detailed design (ready to code)
components.
Class diagrams reflect the real world problem in terms of classes their relationship with other
classes how they interact with other classes responsibility of every class in terms of class
methods and functions and the data and information those classes hold in terms of class
attributes.
while designing complex systems these class interactions can get fairly complicated
and hence uml sequence diagram actually help us to understand how different instances of
classes are interacting with each other what messages they are passing to each other in what
particular order .

Tip - to understand classes kya honge , find the nouns in the problem statement , and the verbs
associated will the methods of that class

Relation between classes– ( not necessary ki 2 class ke beech relation hoyega )

a) Has a

Composition - when one class has no meaninful existence without another class. Example
Class Human and Class Credit card. Every human has a credit card , but without human card is
useless or doesnt make sense
Aggregation - one class’ existence doesnt matter to another class. They can exist
independently
Example - Class Cart has Class Fruit
But fruit class can exist even if no cart

b) is a relation - refers to inheritance . example class fruit and class banana and class apple
So class banana is a class fruit

KEY IDEA is to hide information of one class from another as much as possible
Done by reducing msgs passed between classes as much as possible and exposing only
necessary methods in classes

SOLID PRINCIPLES

Single Responsibility Principle -

Every module should allow changes in exposed function or functions by 1 actor only.
lets say an employee salary class has two functions , calcSalary and calcHours.
If the HR edits the calcHours class , then based on the new implementation cfo will have to edit
clacSalary class.
This is a big problem because with time the product goes through a lot of changes , if every
time a change is made and to incorporate that we have to change all the components
connected to it , then it will be very tough to scale the product.

If adhered to correctly , change in one class shouldnt affect other classes in anyway
Open CLosed Principle
Open for extension closed for modification
It promotes the use of interfaces to enable you to adapt the functionality of your application
without changing the existing code.

Liskov Substitution Principle

The principle defines that objects of a superclass shall be replaceable with objects of its
subclasses without breaking the application. That requires the objects of your subclasses to
behave in the same way as the objects of your superclass.
This is used to check if inheritance in our code is done correctly and logically.
Good example – Low Level Design 107 | Liskov Substitution Principle | 2022 | System D…

Interface Segregation Principle

We tend to write big interfaces which include or hide lot of details.
This is not a good practise and its better to break them into multiple diff interfaces.
Its like single responsibility principle but for interfaces
Classes implementing an interface shouldnt have too many unused functions.

Dependency Inversion Principle

High-level modules should not depend on low-level modules. Both should depend on
abstractions.
Low Level Design 108 | Dependency Inversion Principle | 2022 | System Design

DESIGN PATTERNS ‘

https://youtu.be/tAuRQs_d9F8

Even after tools like , uml diagrams, objects classes , solid principles it is somewhat tough to
convert real world problems to OOP model.
SOme commonly encountered complex design problems were identified by people over time
and we study them to save time and use the solution directly, solution here is design patterns
which are tried and tested

Types -
Creational - when instantiating new objects or create new classes
Structural - how different objects and classes are structured in relation to each other like
inheritance or how the implementation is done.
Behavioural -how objects and classes coomunicate

1) Factory method design pattern

Creational design pattern when we want to create multiple similar objects.

Here the client code creates an object which calls a factory class which has a hidden
implementation in the concrete subclass
Factory class is abstract interface , where as concrete class is the implementation

factory method hides complexity of object creation

Pros and cons →

2)Builder Design Pattern

 How does Builder Design Pattern solves problems like URL creation?

Situations where a class needs to have lots of constructors this can be used.

For example - class URL

It can have , protocol , domain , port , queryParam , pathParam

However only protocol and domain is necessary rest are optional

If we decide to write a constructor for every combination then it will be too many constructors
It is used to construct a complex object step by step and the final step will return the object. The
process of constructing an object should be generic so that it can be used to create different
representations of the same object.

Singleton Design Pattern

When we need only one instance of a class , ie a shared resource which many modules
can access but we need to make sure it is noy over written

We do it my creating a class with a private variable and its private constructor we only
expose its getter function
Facade Design Pattern

Facade means to have a positive outward appearance in order to hide the chaos inside

Similarly in this design pattern , we allow the client to use a facade class to simplify his task
Instead of client having access to 3-4 different classes for some functionality , give user access
to facade class which will do the operations for the client.

Adapter Design Pattern

Acts as a medium to connect 2 diff classes which output and input different things

Flyweight Design Pattern

In cases where similar objects are created in large numbers , program starts becoming slow.
To optimize this we use flyweight patterns

In these n number of objects there are some properties common among all which dont change (
intrinsic properties ) , we store them in our code and this saves memory
 System Design HLD
We try to store data in different geographical regions to decrease latency.
WHere data stored and how fetched is content delivery network.

Video streaming - data broken into chunks and we fetch these chunks. At the start we see some
buffering. Now while we watching 1 chunk , the other chunks arrive and placed in a queue
before chunk1 is viewed.
Quality adjustment - data is encoded into different quality bsed on bitrate, its the number of bits
used to store some data

Scaling Our Systems

1) Horizontal – add more servers

2) Vertical – improve server power

Load balancing - when we have multiple servers and many clients are sending requests ,
the problem we face is which server out of n servers to send the data to ? WIll the client
decide send request to server-2 , so client sends request to a load balancer which is
responsible for routing the request to a server making sure the load is spread optimally
among all servers

Monolithic server - all logic in one server

Microservice - logic divided into many servers

There can be some requests which are asked more frequently and has the same response , so
such responses are cached using different strategies.

PROJECTS
https://docs.google.com/document/d/1zphPiyJFyxWJjKo_z1d84O9ZKzMab-Bz2776ui3oJ9M/edi
t