DEV Community: Ravi Bhuvan

Neural Networks

Ravi Bhuvan — Mon, 13 Apr 2026 16:46:50 +0000

what it is -

it is a system of connected nodes that learns patterns by adjusting the weights.
it is a type of model used in machine learning.
it is made by layers of nodes, where each layer can have multiple nodes.

Other things.

node is a small unit.
neural network is trained through books , websites and not just text data things like images, audio data too(everything becomes numbers/vectors so that the model can learn).
but mainly used for images.
node performs calculation and prediction done using these nodes.
node are responsible for simple calculation in the network.
node size/layers are fixed.
- meaning number of layers, neurons per layer and how they are connected( the architecture of the network).
weights and bias values changes through out training.
the problem is processed parallelly within layers.
- neurons in same layer computing simultaneously is called parallel.
- the same input is sent to all neurons and they process it differently( basically with different weights).
- as the layer increases the input is refined and transformed and the finally a output is created

steps in processing the questions.

when we give a input.
- the input is converted into vectors.
- the first layer is used and the vectors are processed
- the output = new set of numbers or vectors.
- next, this output(above output) is taken processes again (more pattern)
- going through each layers refines the output.
- finally a output is generated.

Key Words in Neural Networks

neurons == nodes small unit that performs math.
Weights are nothing but tells how much influence one neuron's has on the next neuron.
Connections are the links between the nodes.
- the connection is also responsible for the importance of that specific node.
- lets say A node, B node and C node, node A and B are connected to C, then after calculation of that node, the connection between those decided the importance, if connection between a and c is more weighted then it is given more importance in the output.
Propagation function is the weighted sum + activation that happens inside the neuron as the data moves forward.
learning Rule tells how the model updates the weights after prediction using loss and gradients.
Learning rate tells the model how much the model updates the weights after the error.
Hidden Layers middle layers that process and learn patterns.
gradient is a number which tells how loss changes, if +ve add weights and vice versa.

Basic Flow in Neural Network.

1. Input (a)

2. For each connection:
   input × weight

3. At neuron:
   sum all inputs + bias → z

4. Apply activation:
   output = activation(z)

5. Pass output to next layer

6. Final output → compare with actual

7. Loss calculated

8. Backpropagation (error goes back)

9. Gradient Descent (update weights)

10. Repeat

Activation Function

it is the math that is in the node.
in each neuron, the output transforms, this happens in each layer and helping the network getting a meaningful output.
activation function introduced non-linearity transformation.
this avoids the problem of straight line (avoids linear limitation).
each layer changes the output differently.
this makes the model learn and understand complex pattern like images, speech and languages.

Loss Function

measures the error.
a function that tells you weather the output is wrong.
this is at the output layer of the neural network.
this is used only in the training phase and can be used for evaluation.
input given -> prediction -> loss function(compares it with actual) -> loss calculated -> output.
after each loss is calculated the weights are updated using backpropagation + gradient descent.

Backpropagation

computes gradients(how error changes when weights are updated).
process of sending error back to update the weights.
the error flows backward through the layers.
it is done using gradient descent. the gradient descent uses them to update weights.

Gradient Descent

method to update the weights to reduce loss.
basically it moves the weights to where the error reduces.
the gradient tells which connection influenced the error and the weights are updated accordingly(all the connection's weights are updated accordingly).
it computes gradient mathematically, which connection affect the error and change accordingly.

Types of Activation Function

ReLU → hidden layers
Sigmoid → binary output
Tanh → alternative hidden layer

ReLU - Rectified Linear Unit

this is a activation function that keeps positive values and removes negative values.
- this helps in faster computation(makes the functions simple by removing negatives)
- not just by removing also because it is computationally simple.
- negative values are ignored.
- basically acts like filters.

If z < 0 → output = 0  
If z ≥ 0 → output = z

Sigmoid

function that converts any values into 0 to 1 range.
easy interpreting proper yes or no classification.
converting of raw output to confidence score

f(x) = 1 / (1 + e^(-x))

Tanh - Hyperbolic tangent

converts the output between -1 and 1.
exponential-based function.
centered at 0 meaning well balanced.
better than sigmoid (negative values are considered).

tanh(x) = (e^x - e^(-x)) / (e^x + e^(-x))

Types of Neural Network

Feedforward Neural Network (FNN)

the input flows in one direction there is no memory saved.
this is the simplest form of neural network.
Used in
- basic classification
- Regression

Convolutional Neural Network(CNN)

best for images, can be used for others too.
designed to process grid like data
uses the grid of pixel values (numbers) to understand the image. key components of CNN
input layer - gets the raw image data and passes it to the network.

Redis

Ravi Bhuvan — Tue, 04 Nov 2025 20:30:51 +0000

what is it?

is a REmote DIctionary Server.
it is a open-source in memory data store.
so, it like the cache stored memory, it is usually way too much faster than requesting querying the data.
usually when the query is made, first it finds in cache(redis memory) if not query is sent to DB, then the data is sent back to user while also saving it in the redis memory.
it is a structured key-value pair, but with various data structure.

redis port number : 6379

installing redis

redis can be a standalone application, but usually in production we use it through the docker.
first u need to create a redis-stack image in docker
map the port to the computer port number so that we can use it on the computer.
for executing the redis stack container we

docker exec -it <continer_ID> bash

this gives you a bash inside the redis stack, now for redis cli u should use redis-cli ping this will return pong
instead we can simply use redis-cli and skip writting the redis-cli each time

Data types in redis

Redis Strings

set name bhuv # setting the key-value pair
ok # output...
get name
"bhuv" # value which was saved

in redis DB it is not recommended that name as the key, we should always use the convention like mentioned below

set <entity>:<id> <key> <value>
set name:1 bhuv

now these are grouped according to the name (for visualizing purpose)

for setting multiple values

mset name:1 bhu name:2 rav name:3 olaa name:3 bhoo

for using redis in nodejs application

const {Redis} = require('ioredis'); // uses ioredis for connecting DB

const client = new Redis(); creates a redis instance 

module.exports = client; 
// exports it, so that it can be used in other modules.

for creating and setting in node js

const client = require('./client') // import connected redis module

async function init() {
    await client.set("name:4", "boy"); // setter
    const res = await client.get("name:4"); // getter

    console.log('Result :', res);
}
init();

in redis there is TTL

Time To Live sets an expiry time to the key in redis memory, this specifies how much time would it leave in the redis memory.
helps in freeing up used up memory, improve data retrival.
to set expiry expiry <key> <time in seconds>.

Redis Lists
- lists are similar to vectors in cpp, in redis we use lists for stacks and queues.
- in this we push the data from left or right according to the command.
- lpush and rpush pushes the data from left and right respectively.
- lpop and rpop pops element from left and right respectively.
- llen gives you the length of lists
- blpop removes element from left, if empty waits for specified time to delete the element

blpop <list> <time_in_sec>
blpop msg 20

Docker - one read to understand

Ravi Bhuvan — Sun, 26 Oct 2025 22:55:23 +0000

problem statement
developer working on a project, he has his own configuration. he installs all dependencies (Nodejs, MongoDB and so on).
when other developer comes into picture then, he want to install all dependencies.
he may also have diff OS, he installed all the latest versions when he installed. both has different versions and environment.
he can't use OS-specific software.

Containers -

these containers have their own environment with the version specified.
these containers can be shared when he shares the image.
these are lightweight, sharable and have their own env.

Docker Setup

Docker Daemon - this is the brain of docker, creating, pulling images. docker run -it ubuntu this is a normal CLI in windows it says start a ubuntu container i.e. an container with ubuntu as OS. this checks for image of ubuntu locally in your machine, if not downloads it from the docker hub , and you get an image of ubuntu. now u have a ubuntu container running in docker, u can use it. after creation of the docker container, the docker(daemon ) uses your host kernel, and not full OS and creates a container, now what ever changes you make in the container is only specific to the container. this does not affect your local OS, anything installed its only in the container.

Container and Images
you can create as many container using a single image. An image is like a blueprint for containers. each containers are isolated from each other, one data created in one container is not accessible in container created using the same image. meaning each data is isolated to their own container.

Containerizing a app
create your application.
now create a file named Dockerfile without extension.
this is your image configuration basically.

FROM ubuntu
RUN apt-get update
RUN apt-get install -y curl
RUN curl -fsSL https://deb.nodesource.com/setup_20.x | bash -
RUN apt-get upgrade -y
RUN apt-get install -y nodejs

COPY package.json package.json` -
COPY package-lock.json package-lock.json` -
COPY server.js server.js`

RUN npm install
ENTRYPOINT ["node" , "server.js"]

FROM ubuntu - this is you base image, we build on this image.
RUN apt-get update - this updates the packages.
RUN apt-get install -y curl - we are installing curl tool inside the container, and now we can download files using curl command in the container.
RUN curl -fsSL https://deb.nodesource.com/setup_20.x | bash - this downloads the nodejs packages
RUN apt-get upgrade -y updates the package.
RUN apt-get install -y nodejs this runs the nodejs.

till here we installed a OS ubuntu and then installed the nodejs application on ubuntu

COPY package.json package.json
COPY package-lock.json package-lock.json
COPY server.js server.js
this says copy the fileA in the folder to the fileA inside the container.

RUN npm install installs and creates node_modules folder with packages.

ENTRYPOINT ["node" , "server.js"] - this starts the node adn server.js

Now you have created a basic image configuration for your application.
in your terminal

docker build -t image_name .

this builds your image and . that the file is in the pwd.
-t means tag name you are giving
build builds your docker image using the configuration in Dockerfile

docker exec -it <container_ID> bash

this give u a interactive(i) terminal(t) inside the container,
lets say u build the image using ubuntu, then it gives u ubuntu terminal to interact with the container.

docker run -it -e PORT=5000 -p 8000:5000 <image_tag>

run runs your image
-it interactive terminal
-e environment variable
PORT=5000 we are defining the env variable PORT to 5000
-p this is port mapping
8000:4000 here, 8000 ---> host port and 4000 --> containers port

docker build test .

test:latest tag is used for reference for building image.
Docker images are immutable, it creates a new image replaces tag with the new images.

Layer Caching (each code in Dockerfile can be called Layers off building image).
so, basically the order of the Dockerfile command is important, lets say u do some server.js , now the docker checks the Dockerfile till where the code is cached, now everything after that line commands are executed when built again. so keep common code(installing node or other dependencies) before the actual code (that keeps changing) to avoid unnecessary downloading of dependencies on repeat.

Publishing to Docker hub
first create a repo in docker hub
now create a local image using the name given in the repo
finally docker push <image_name> to push it to your repo
u need to be logged in to push the image.

lets say you are a developer working on multiple containers that work together. like Nodejs, PostgreSQL or MongoDB. so, now manually managing these container would be huge headache. so,

Docker Compose it is a tool used to configure, define and multi-container application easily.
this lets u configure your application to run with multiple containers.
docker-compose.yml just like Dockerfile this file is used for configure the managing of containers and interacting with other containers and communication seamlessly.

version: "3.8"

services: 
  postgres: 
    image: postgres # takes the postgres imag from docker hub
    ports:
      - "5432:5432"
    environment:
      POSTGRES_USER : username
      POSTGRES_DB : review
      POSTGRES_PASSWORD : password

  redis:
    image : redis
    ports : ["6379:6379"]

version can be anything.
services: says what are the services you want
Postgres: which service u want
image: image name in docker hub. u can use ur own image too.
port: port mapping
environment: env variables

this is a basic setup for docker compose.

docker compose up

this starts the configuration and with the port mapping.
now, this creates a stack of containers with your services needed in you containers page in docker desktop.
docker compose down clears the stack of containers

Kubernetes

Ravi Bhuvan — Fri, 24 Oct 2025 07:41:38 +0000

basic prerequisites

while development,
at first people used to buy physical servers to deploy their application.
then AWS came into picture, and developers, startup started to use the AWS cloud system.
AWS - it is a cloud computing platform, used by developers, startups, to build their application on the cloud, it provides a on-demand resources, and easy to use.
now everything was on the cloud, everything became cloud native and on a different machine as always.
now, sometimes the code written code in windows and deploying the code in some other OS like the cloud platform was hard. This was solved by VMs.
but there is a problem, it to heavy-weighted for the system, their own OS, this was solved by docker, containerized application, which are light weighted.

so, managing these containers was absolute, so Kubernetes came into picture.

what is it?

it is a orchestration platform that automating deployment, scaling and managing containerized application.
so, basically its like a conductor(Kubernetes) managing the musicians(containers) to ensure a coordinative and optimized performance.
this also creates a generic development of the containerized application, meaning that applications are not specific cloud dependent.
it can run in AWS ECS(elastic container system) , DO(digital ocean) , GCP(google cloud platform).

Kubernetes Architecture -

Cluster a group of nodes(control plane , compute nodes) where Kubernetes runs workload. these are the core units of the Kubernetes.
Control plane is responsible for maintaining the desired state of the cluster, such as which applications are running and which container images they use. its like the brain of the cluster.
- API server is the central interface, all commands pass through it.
- Scheduler assigns the pods to the nodes based on availability.
- Controller Manager monitors cluster state and ensures desired matches the actual state.
- etcd key-value store maintaining cluster configuration date.
Worker nodes are the machines in a Kubernetes cluster that actually run your containers.
- Kubelet Agents ensuring containers in pods are running as instructed.
- kube-proxy manages networking, routing traffic between pods and services.
- Nodes use container runtimes.
Objects and Resources
- pods/Containers Smallest deployable units, hold one or more containers.
- Services exposes pods to network traffics.
- Deployment manages pod replicas and rolling updates
- Namespace divides cluster resources logically for isolation.

basic flow,
there is a physical server that is running the control plane, this is responsible for managing the workernodes,
this control plane runs separately from the worker node(it can run in same machine in development phase).
lets say u want to run two nginx containers,
this instruction is sent to control plane through API server.(authentication is done, weather the request is made by a authenticated system)
now, the API server tells the Controller to create two pods with nginx container, controller creates a pod, now the pod is created. now to run this we need a physical server to run this pods.
now the Scheduler checks for unassigned pods and assigns pods to the worker nodes. it also distributes the pod to the worker nodes.
the worker node is basically where your actual code runs.
now, basically the scheduler through the API server sends the message to kubelet in the worker node to start the pod which was unassigned.
Kubelet's main job it to ensure that containers that are scheduled are running in the node.
Kube proxy - redirecting of network traffics.
here desired state is matched with the current state.

Docker

Ravi Bhuvan — Wed, 22 Oct 2025 11:03:11 +0000

what is Docker?

it is a platform for developing, shipping and running application.
it separates your application from your infrastructure for faster building and delivery.
these containers are great for Continuous Integration and continuous Delivery i.e. CI/CD workflow.

Docker Platform

Docker provides a way package and run application on loosely isolated environment called containers.
Containers are lightweight and contain everything needed for application to run, so that you wont need to rely on what's installed in host.

Docker Architecture

Docker uses the client-sever architecture.
It is lightweight, meaning they share the host kernel, not include the full OS, and also have isolated user-space.

Docker daemon (dockerd)

Listens for Docker API and manages docker objects such as images, containers, networks and volumes.

Docker Client

It is the CLI of that used to communicate with the docker daemon process
It can use the REST APIs, over UNIX socket or TCP to the daemon
When you use commands such as docker run, the client sends these commands to dockerd, which carries them out. The docker command uses the Docker API.

Docker Objects

When you use Docker, you are creating and using images, containers, networks, volumes, plugins, and other objects. This section is a brief overview of some of those objects.
- Images(blue print) - A ready-made template for creating the docker container. you actually create using other images with your own customization i.e. Dockerfile .
- Containers(running instance of that blue print) - is a runnable instance of an image. You can create, stop, move or delete a container using docker API or CLI.

Docker Registries

It stores a docker images. Docker hub is a public registry that anybody can use.

so, here is the basic flow,
At, first the command is issued via Docker Client(CLI), the client creates a REST API request.
the client communicates with dockerd via UNIX socket or TCP.
daemon checks the local cache.
daemon, sends the request to Docker Registry(docker hub or private registry).
after the request, daemon uses retrieved image to create a writable layer on top of the image for the containers.
it sets up container resources using Docker Objects.
starting the container, the dockerd launches the container as a process on the host OS using the shared kernel.
during the execution of the image, it runs its defined processes.
daemon also tracks lifecycles, resource usage and logs.
response to client is sent back, container ID, logs.

User (CLI)
   ↓
Docker Client → API Request
   ↓
Docker Daemon (Server)
   ↓
Check local image → Pull from Registry if absent
   ↓
Create container using Docker objects
   ↓
Run container (process on host kernel)
   ↓
Return output to Client

Extras :
Nginx- open-source software that acts as the server, reverse proxy, load balancer and HTTP cache.
Reverse proxy - when a client sends requests to server, basically it does not send to the server directly(maintaining Abstraction), it sends to a middle server(like Nginx | VPN )that decides, which server to send the request(the deciding factor is during developing the Nginx).
Load balancer - distributing the incoming traffic to multiple servers to ensure no single server is overwhelmed.
HTTP caching - refers to NGINX's ability to store copies of responses from backend servers (origin servers) and serve those cached responses directly to clients for subsequent requests

DevOps

Ravi Bhuvan — Mon, 20 Oct 2025 08:03:49 +0000

what is it?

set of tools, that automate and integrate the processes between software development team and IT teams.
Delivery
Automation
improving the Quality
continuous Monitoring
continuous Testing

ok, but why?

for automating the testing
for faster delivery

SDLC - Software Developer Life Cycle

its a structural process of design, building, developing and maintaining of software.
it contains of distinct phases each responsible for different phase of the development of the software.

so, basically Dev-ops engineer will make sure the 

Building ----> Testing ----> Deployment

is automated and not manual.(usually dev-ops part)

Virtual Machines

is a compute resource that uses software instead of physical computer to run programs and deploy apps.
a machine that uses resource that are on another computer, thinking it as its own.
basically there is a host(the computer with the physical resource) machine and then the guest(the computer which is on the host machine)
providing a logical isolation.

Hypervisor

is a virtual machine monitor (also known as VMM).
is a software that creates and runs VMs.
it allows one host machine to have multiple VMs by virtually sharing resource, like memory and processing.

AWS (Amazon Web Services)

is cloud computing platform offered by Amazon where, it provides required resources.
they a build a physical server or data centers, that provides a VM(EC2 i.e. in AWS) with specified computing, databases and servers.
users can only interact it with online.

EC2: Virtual servers for running applications.
S3: Object storage for files and media.
RDS: Managed relational databases.
Lambda: Run code without managing servers.

CLI - Command Line Interface is a text-base tool used to interact with the computer using command lines

What happens when u click google.com - Computer Networks

Ravi Bhuvan — Sat, 18 Oct 2025 10:32:53 +0000

Lets start from beginning -

When you install a router, it receives a public IP from the ISP on its WAN interface.
Usually, when u setup a router in your home or anywhere, basic default setting will already be set like

DHCP enabled
NAT enabled
Default routing connecting LAN to WAN and back

DHCP

When a host connects via Ethernet or Wi-fi,

The Host sends broadcast DHCPDISCOVER to the Network
This asks the router to assign a IP Address to itself(host)
now when the router(DHCP server) receives the request
the DHCP server send back a DHCPOFFER this contains

IP Address - host expected IP address
Subnet Mask - the local networks range
Default Gateway - if its outside the local to external IPs
DNS server - usually the router itself
Lease Time - duration of the IP address 
some other parameters

now after the host receives host responds with DHCPREQUEST confirming the IP Address
DHCP server confirms the assignment by sending DHCPACK

IP Address

Internet Protocol is a unique address that identifies a device on the internet.
DHCP assigns a IP address selecting in a address pool
It is a unique assigned numerical label, which is given to the device that is connected to the internet.
two types
- Public IP address - it is address that is assigned to the device that is connected to the internet directly.
- Private IP address - this is a private address that are used in private networks, these cannot directly interact with the internet, basically these talk through the internet by mechanism called NAT.

-based on version two types

IPv4(32 bit addressing)
- it is the most common form of IP address, it consists of four set of numbers

1 byte = 8 bits 
so,
32 bits --> 4 bytes
example IP address :
    192.168.1.1

IPv6(128 bits addressing)
- this version was created to overcome the shortage of IPv4 addresses. this gives us a large amount of addresses.

example:
  2001:0db8:85a3:0000:0000:8a2e:0370:7334

Subnet Mask

a subnet is a portion of a larger network, basically it tells the network boundary or range of the IP address in the local subnet
subnet mask - is 32 bit number that is used to differentiate between network and host part in the IP address

DNS

Domain Name System is the internet phonebook mapping/translating the domain names(people can remember) to the IP addresses(what system/routers understand) via hierarchical name servers.
server for translating the names to IP address

Lease Time

duration of the IP is valid before renewal sent when DHCPOFFER to host.
after assigning, after sometime the host sends a renewal (DHCPREQUEST) request to the DHCP server to maintain the IP address

When you enter google.com in the browser, the OS checks for local cache in your system. If it is not found, the host sends a DNS query to the router. then the router forwards to the actual DNS server i.e. ISP. after that the ISP sends back a IP address back to the host.

lets say the host doesn't know the mac address of the router it only knows the IP address of the router, so it can't send a DNS lookup, so the ARP request/reply exchange is done

ARP - request/reply Process
basic analogy

   Host----switch----router-----(ISP)

host - ARP Table (mapping of MAC address to IP Addresses)
switch - MAC table (mapping of MAC address to switch ports)
router - Arp table (mapping of MAC address to IP Addresses)

lets say all tables are empty

the host sends broadcast ARP requesting the mac address of the default gateway something like this -

source IP address : 192.xx.xx.xx (host's IP)
source MAC address : 00:1A:2B:3C:4D:5E (host's mac)
destination IP address : 192.1xx.x.1 (this will be the router's IP)
destination : FF:FF:FF:FF:FF:FF(this says unknown)

the switch doesn't know, but it is a broadcasts, so it sends the message to the whole LAN and updates the mac table about the host and maps the port number.
other hosts check and discard the IP packet, because in the ARP request the destination IP address is not their owns so.
the router also gets the ARP broadcast, the router gets to know that the host wants the MAC address of the router(the default gateway). The router also updates the ARP table in router and maps mac to IP address of the host.
the router sends the unicast message back to host, as it knows the mac address of the host, by checking the ARP request. here the switch also updates the mac table by adding, the router's mac address and maps the port.

6.the host updates the ARP table and adds the MAC address

now the host has a mac address and can communicate to the internet through router.

the browser sends a an HTTP or HTTPS(secure) request to the server.
the router performs a NAT.

NAT

it is a process of allowing the multiple private IPs to share a single public IP address to interact with the WAN or to access the internet. its in the router
NAT contains a translation table, which contains the mapping of internal host address and port that is connected to the internet.

let me explain when a host A sends a request to a external server via router, the NAT here maps it to a port number before sending it the actual server and send it with a port number.

Host A (192.168.1.2:5000) sends a request to a web server.
Router replaces sourceIP:port with publicIP:10000 in NAT table. for the same server the host B also sends a request
Host B (192.168.1.3:5000) sends a request to the same server
Router replaces source IP:port with publicIP:10001 in NAT table.

the server replies to publicIP:10000, so router checks and forwards it to the host A.

This process is called Port Address Translation (PAT).

so, like this the NAT replaces the private IP address with the Public IP address using NAT table. when the router receives the reply from the server it check the table and forwards back to host.

Finally, the host’s transport layer checks the destination port to deliver the payload to the proper application/session(here the browser), with TCP/UDP connections potentially reused for multiple requests.

Important OS

Ravi Bhuvan — Tue, 26 Aug 2025 10:54:44 +0000

Types of OS

Single Process
Batch Processing
Multiprogramming - multi jobs/ programs running
Multi-tasking - extension of 3 logically - single CPU able to run multiple task simultaneously.
Multiprocessing - more than 1 CPU single computer
Distributed - more CPUs, memory GPUs are or maybe in more than oen place it is distributed.
Real Time -

Multi-tasking vs Multi-Threading

Multi-Tasking

working with many tasks simultaneously.
CPU switches from multiple processes.
eg. employees working in same company(CPU) in different departments(Processes) in their offices(their memory).

Multi-Threading

Breaking a process into several threads which has there own path of execution.
CPU switches between threads from same process, sharing memory.
eg. employees working in same company(CPU) in same project(Processes) in same office(their memory).

Note: in multithreading each thread is executing based on priorities. Each thread their own time slices in the runtime(whole process has the same runtime).

OS Concepts and terms

Ravi Bhuvan — Tue, 22 Jul 2025 15:20:03 +0000

Firmware

Permanently stored software on the hardware Device. give low-level control for specific hardware.

BIOS

Basic input-output system, its a low level firmware that embedded on the motherboard. it is responsible for booting up the system using 16-bit real.

UEFI

bios is old, Unified Extensible Interface is a replacement of traditional bios. which has a faster booting time as it can run in both 32 and 64-bit mode.

Important Terms

Compiler

A program that converts the high-level language(C++,java) into binary code(0s or 1s) so, that the computer can understand.

Loader

part of OS that loads and executes the file in the disk into memory, so PC can run.

Assembler

programs that converts low-level language to binary instructions(machine code)

Interpreter

Program that translates the code and runs line by line.(unlike compiler which translates the whole code first and runs)

System Calls

it is a way of programs that request services from OS kernel, like open()

#include <unistd.h>

int main() {
    const char *message = "Hello, World\n";
    write(1, message, 13);  //here write() is a system call
    return 0;
}

API (Application Programing Interface)

it is a set of rules/protocols that needs to be followed by the program, where two different software interact/communicate with each other.

Kernel

it is the core of an OS, which controls all the hardware

Shell

its a program the helps the user to interact with the kernel via commands

JVM (Java Virtual Machine)

it is VM which acts as a bridge between compiled java code and the OS. that's why java is referred as Compile Once, Run Anywhere.

Booting

the process of starting and loading the OS into the main memory.

Multi -

difference between multiprogramming and multitasking is

in multitasking - programs running simultaneously
in multiprogramming - programs are either ready or waiting for their turn.

Process vs Program

Program -
set of instruction which is yet to be executed. Its is a passive entity that stays in the secondary, which is content of the disks

single user can execute multiple programs
it is a file that needs to be executed
single program can be linked to multiple processes

Process -
active instance of a program.

it is an active entity which is running in the main memory
remains for a specific time
dynamic entity
sequence of execution of instructions

States of Processes

Operating System

Ravi Bhuvan — Tue, 22 Jul 2025 07:21:53 +0000

What is OS?

OS is an Operating System, which interacts with the system software and hardware instead of user, where user is not required to understand the system hardware in order to use the system.

Services Provided by an OS -

Program Execution
Memory Management
Process Management
File System Management
I/O Device Management
Security Access Control
Resource Management
Time Management
Error Detection
Communication Services

Process Execution

The OS runs the application which is installed in the system.

Memory Management

OS is responsible for Allocating and Deallocating for processes.

Process Management

OS tells the Program to run first and till how much - multitasking(creating and sheduling of processes only).

File System Management

Managing and organizing of of file in the system.

I/O Device Management

Devices like Mouse, keyboard scanner and so on are managed by OS.

Security and Access Control

Protects from unauthorized access of data, manages the permission controls of other software.

Resource Management

manages the resources like CPU, RAM and other hardware and assigning of processes is done.

Time management

keeps timer for the running processes to stop or wait for execution of programs.

Error Detection

Detects Hardware and Software errors and handles it. errors like software crashing or disk failure.

Communication service

Helps interact processes to each other for performing specific tasks.

Types of OS

Batched OS

runs multiple jobs gives us batch output and does not interact with the user. Output comes after all jobs(programs that needs to be executed) are done.

Time-Sharing OS

shares CPU time among multiple user or tasks. multiple users use the OS at the same time, but actually the system is switching them very fast.

Distributed OS

this is multiple computer acts as a single computer. Manages tasks across all nodes.

Network OS

Computer working together in the same network(LAN) using Network OS(independent), share file and user management.

Real-Time OS

system where needs instant respond and are reliable. system will be very fast as the OS is build for real-time decision-making.

RAM and ROM (types of memory)

RAM(Random Access Memory)

it is also known as main memory, it is a fast processer. information stored or executed in this is temporary(Volatile Memory), if power goes off then the information stored is also gone.

ROM(Read Only Memory)

it is a non-volatile memory(permanently stored, and is not lost when turned off). the contents of the ROM is written by the manufacturer while manufacturing.

SCRAM and DRAM (Types of RAM)

Static RAM - its like a cache memory of the RAM. it is faster and more reliable compared to other RAM. it does not need refreshing, more expensive and needs more power.
Dynamic RAM - mainly used as main memory, its is used to store data, in the form of bit capacitors value 1(charged) and 0(discharged). needs to be refreshed to retain data.

(Types of ROM)

Programable ROM(PROM) - can be reprogramed.
Erasable ROM(EROM) - can be erased by UV light and reprogramed.
Electrically Erasable ROM (EEROM) - can be erased and reprogramed electrically.
Mask ROM - programed during manufacturing only.

Virtualization

using of a whole hardware(extra power, ram and other things) typa sht on the current system OS using software like hypervisors. example - VM ware

Containerization

running of a specific app/web app isolated from the OS on a container. example - Docker