DEV Community: Dipsan Kadariya

Machine Learning

Dipsan Kadariya — Thu, 20 Feb 2025 14:42:33 +0000

Supervised Learning

Supervised learning involves learning through data with input and output, finding the relationship between them, and using that relationship to predict outputs for new inputs.

In this case, we have both input and output. In supervised learning, we train the machine to learn from the given data and predict whether, for certain IQ and CGPA values, there will be a placement or not.

Types of Supervised Learning:

Regression
Classification

Data Types

Data is generally of two types:

Numerical: Age, weight, CGPA, IQ
Categorical: Gender, nationality, brand, etc.

Regression (Supervised Learning)

If the output is numerical, it is called regression.
Example: For a certain IQ and CGPA, let's say we predict a salary package of 50,000. Since the output column (package) is numerical, this is regression.

Classification (Supervised Learning)

If the output is categorical, it is called classification.
Example: Given certain CGPA and IQ values, we predict whether a student will get placed or not. Since the output is categorical (Yes/No), this is classification.

Unsupervised Learning

Unsupervised learning is used when we have only input data and no corresponding output.

Example:

In this example, we only have inputs and no output. We don't know what to predict.

In unsupervised learning, we perform one of the following:

Clustering
Dimensionality Reduction
Anomaly Detection
Association Rule Learning

Clustering

Let's say we plot IQ and CGPA.
A clustering algorithm detects which students belong to the same group.
Example: We can categorize students into different groups such as:
- High IQ, low CGPA
- Low IQ, low CGPA
- High IQ, high CGPA

Dimensionality Reduction

If there are a lot of input columns (e.g., 1000), the algorithm runs slow, and at some point, adding more columns does not improve results.
Dimensionality Reduction (DR) removes unnecessary columns to improve efficiency.
Example: If we need to predict house price based on the number of rooms and washrooms, DR combines these into a single feature, reducing the number of input columns.
DR also helps in visualizing high-dimensional data by reducing it to 2D or 3D.

Anomaly Detection

Used for finding errors and detecting outliers in data.
Helps in fraud detection, network security, etc.

Association Rule Learning

A technique in unsupervised learning used to find relationships or patterns between variables in large datasets.
Example: Market Basket Analysis (identifying which products are frequently bought together).

Semi-Supervised Learning

Semi-supervised learning lies between supervised and unsupervised learning.
It involves a small amount of labeled data and a large amount of unlabeled data.
The labeled data helps guide the learning process of the unlabeled data.

Reinforcement Learning

Reinforcement learning is where an agent learns how to make decisions by interacting with an environment.
The agent performs actions and receives feedback in the form of rewards or penalties.
The goal is to maximize cumulative rewards over time.

Categories Based on Production

Batch Machine Learning

Code runs on a server (offline learning).
The model is trained once using the "entire dataset" and then deployed.
convential way of training model.
Process: data → model → train → test → server → run

Problems with Batch Learning:

The model is static and does not evolve with new data,since it is trained offline.
Requires periodic retraining with merged new and old data.

Online Machine Learning

Done incrementally (model learns continuously).
Data is fed in small batches (mini-batches) sequentially.
Model is trained online.
The model improves with interactions and new data.

Process: small data → model → train → test → server

<--- Continuous new data

Predictions on New Data

The model continues learning from new data.
Examples: Chatbots like GPT, YouTube video recommendations.

When to Use Online Learning?

Concept Drift: When concepts change over time (e.g., e-commerce trends).
Cost-Effective: Continuous learning without expensive retraining.
Faster Solution: Adaptability in real-time applications.

Out-of-Core Learning

Used when the dataset is too large to fit in memory.
The dataset is split into batches and processed in chunks.
Though performed offline, it follows an online learning approach.

Disadvantage:

More complex and can be risky if not implemented correctly.

Based on Learning

Machine learning can be categorized based on how it learns:

By Memorizing (Instance-Based Learning)
By Generalizing (Understanding concepts, Model-Based Learning)

1. Instance-Based Learning

Instance-based learning does not actually learn patterns but stores training data and responds based on the nearest neighbors.

Example:

IQ	CGPA	Placement
8	8	Yes
7.0	7.3	No

In instance-based learning, the model does not learn anything. It just stores the data.
When a new query comes, it looks at the nearest data points to decide.
If the nearby points mostly have placements, the answer is "Yes"; otherwise, it's "No".
There is no training or learning—just pattern matching.

Key Point:

It focuses on simple pattern matching, where the model stores examples and instantly answers based on the nearest matching data point.

2. Model-Based Learning

The model learns from data using algorithms.
It understands the pattern and draws a boundary.
The boundary helps predict answers for new inputs.
Unlike instance-based learning, model-based learning finds a mathematical relation between input and output.
Even if we don’t have training data points, we can predict using the learned boundary.

Key Point:

This refers to building an internal model of the relationships in the data, which can then be used to make predictions.

Differences Between Instance-Based and Model-Based Learning

Usual/Conventional Machine Learning	Instance-Based Learning
Prepare data for model training.	No model training.
Train models to generalize patterns.	No training—only stores data.
Can make predictions using learned models.	Predictions based on stored examples.
Results in a generalizable model.	No generalization—just stores past data.
Missing attributes are handled better.	Every new input needs complete data.

Challenges in Machine Learning

Data collection issues
Insufficient labeled data
Non-representative data
Poor quality data
Irrelevant features
Overfitting
Underfitting
Software integration issues
High costs involved

Machine Learning Development Lifecycle (MLDLC)

Problem Definition
- Identify the problem, customer needs, and expected outcomes.
Data Gathering
- Collect relevant data from sources such as APIs, sensors, or databases.
Data Preprocessing
- Remove duplicates, fill missing values, and convert data into a usable format.
Exploratory Data Analysis (EDA)
- Understand data distribution, relationships, and visualizations.
Feature Engineering & Selection
- Create new features and remove unnecessary ones.
Model Training, Evaluation, and Selection
- Train models and tune hyperparameters for better performance.
Model Deployment
- Convert trained models into software for real-world use.
Testing
- Perform beta testing, optimize performance, and retrain if needed.

Tensor in Machine Learning

Tensors are data structures used to store numerical data.
They can be 0D, 1D, 2D, 3D, or ND tensors.

Types of Tensors

0D Tensor (Scalar): A single number.
1D Tensor (Vector): A single row of numbers.
2D Tensor (Matrix): A table-like structure with rows and columns.
3D Tensor: A collection of 2D matrices.
ND Tensor: Higher-dimensional tensor for complex data processing.

Data Link layer

Dipsan Kadariya — Wed, 13 Nov 2024 08:16:39 +0000

The Data Link Layer (DLL)

The Data Link Layer (DLL) is the second layer of the OSI model, responsible for ensuring direct, reliable communication between two nodes in a network. By handling functions like error detection, flow control, and framing, the Data Link Layer allows data to move securely and in the right order between neighboring devices, preventing data loss or corruption.

Functions of the Data Link Layer

Definition: The Data Link Layer establishes and maintains reliable links between directly connected devices, or "nodes." It ensures data is transferred without errors, regulates the flow of data, and segments data into smaller pieces called "frames."
Example: Imagine wrapping a fragile item in protective material before shipping it. This way, the item arrives safely and undamaged. The Data Link Layer provides similar protection for data, "wrapping" each data packet with information that ensures its safe delivery.

Key Components of the Data Link Layer

1. Logical Link Control (LLC)

Definition: The LLC is a sub-layer that controls how devices interact at the data link level. It oversees data flow between devices and ensures error-free delivery.
Function: LLC adds information to each data packet so the receiving device knows how to handle the data. It’s especially important in multi-device networks where clear, organized communication is essential.

2. Media Access Control (MAC)

Definition: The MAC sub-layer prevents data collisions when multiple devices try to communicate over the same network channel.
Function: MAC ensures each device waits its turn or "accesses" the communication channel without interfering with other devices, reducing network congestion.

Core Concepts in the Data Link Layer

Framing

Definition: Framing is a process that organizes data into manageable packets or "frames." Each frame has headers and trailers with additional information for error-checking and addressing.
Example: Just as a photo is placed within a frame for better presentation and protection, data packets are framed for orderly transmission.

Error Control Techniques

Stop-and-Wait ARQ
- Definition: A flow control mechanism where the sender transmits one frame and waits for an acknowledgment (ACK) before sending the next.
- Function: Prevents overload by ensuring each frame is received before the next is sent, though it can slow down transmission in high-speed networks.
Go-Back-N ARQ
- Definition: The sender can transmit multiple frames before waiting for an acknowledgment, but if an error is detected, it resends all frames from the erroneous one onward.
- Example: Similar to sending several items in one shipment; if one item is damaged, all items from that point are returned and resent.
Selective Repeat ARQ
- Definition: The sender retransmits only the frames with errors, rather than all subsequent frames.
- Benefit: More efficient than Go-Back-N, as only the frames needing correction are resent.

Channel Allocation Techniques

Channel allocation methods determine how multiple devices share a communication channel without causing interference.

Technique	Description
ALOHA	Devices transmit whenever they have data, leading to a high chance of collisions.
Slotted ALOHA	Time is divided into slots, so devices transmit only at specific times, reducing collisions.
CSMA	Devices listen to the channel before transmitting, reducing the likelihood of collisions.
CSMA/CD	Detects collisions during transmission and allows devices to stop and retry after a delay.
CSMA/CA	In wireless networks, devices avoid collisions by signaling before transmitting data.

Example for CSMA/CD: Similar to stopping when hearing a crash while crossing the street, waiting, and then trying again.

Ethernet Standards in the Data Link Layer

Ethernet standards are protocols that dictate how data is transmitted over networks, enabling devices to communicate through shared standards.

1. 802.3 CSMA/CD (Carrier Sense Multiple Access with Collision Detection)

Definition: This standard for Ethernet uses CSMA/CD to control access and prevent collisions.
Function: When multiple devices access a shared network, CSMA/CD listens for clear signals and detects potential collisions, retrying transmission after a delay.

2. 802.4 Token Bus

Definition: A standard where devices are organized in a bus topology and send data only when they have a token.
Benefit: Prevents collisions by controlling data transmission in an orderly fashion, though devices may have to wait for the token.

3. 802.5 Token Ring

Definition: Devices form a ring topology, passing a token around, and only the device holding the token can transmit.
Function: Ensures organized, sequential data transmission, minimizing chances of collisions.

Wireless LAN Technologies

Bluetooth

Definition: A short-range wireless technology for connecting devices within a limited area, such as a headset to a smartphone.
Application: Useful for quick, local connections with limited interference from other devices.

Wi-Fi

Definition: Wi-Fi enables devices to connect to each other or the internet using radio waves.
Function: Provides high-speed, wireless connectivity over a larger range than Bluetooth, ideal for home and office networks.

Virtual Circuit Switching

Definition: Virtual Circuit Switching establishes a logical path for data between devices, giving the appearance of a dedicated line despite shared resources.
Example: Similar to a telephone call where a virtual circuit connects two phones, creating a continuous connection during the call.

Frame Relay

Definition: A high-speed data communication protocol for connecting networks over a wide area using fixed-size frames.
Application: Frequently used for connecting different local area networks (LANs) across a broad area network (WAN).

ATM (Asynchronous Transfer Mode)

Definition: A protocol using fixed-size cells for reliable, high-speed communication.
Benefit: Enables efficient data transfer, supporting both voice and video services with minimal delay.

Data Link Layer Protocols

HDLC (High-Level Data Link Control)

Definition: A data link layer protocol for reliable communication over serial links, incorporating error detection and flow control.
Function: HDLC uses a structured frame format to manage how data packets are transmitted and ensures accuracy in data delivery.

PPP (Point-to-Point Protocol)

Definition: A protocol used for direct communication between two network nodes, providing authentication and encapsulation.
Application: Widely used in direct internet connections, such as those between a computer and an internet service provider.

The Data Link Layer plays a critical role in managing direct data transfer between neighboring devices, ensuring smooth, reliable communication across networks. By breaking data into frames, managing access to communication channels, and using error-checking methods, it forms the backbone for dependable data transmission.

Database Management System(DBMS)

Dipsan Kadariya — Thu, 31 Oct 2024 15:03:48 +0000

Understanding Database Management Systems (DBMS)

Data: The Raw Information

Definition: Data is raw information that, on its own, doesn't provide any meaning. It can be anything from numbers, words, dates, or measurements, without any added context.

Example: Imagine you have a list of numbers, like "25," "100," and "60." Without additional information, these numbers don't tell us much. They are just raw facts.

Database: Structured Information Storage

Definition: A database is a structured collection of data that is stored so it can be easily accessed, managed, and updated. In a database, information is organized in a way that makes it simple to find, edit, or analyze.

Purpose: The purpose of a database is to help users store information systematically. This means they can quickly find the information they need and use it as needed.

Example: Think of a library catalog. It's a database of books where you can look up the title, author, and location of each book, making it easy to find the book you want.

Database Management System (DBMS)

Definition: A Database Management System, or DBMS, is a software that allows users to create, retrieve, update, and manage data in a database. Instead of manually organizing and searching through data, a DBMS lets users perform these tasks more quickly and accurately.

Examples: Popular DBMSs include MySQL, MongoDB, Oracle, and PostgreSQL. These systems are widely used in businesses and other organizations to handle data efficiently.

Functions of DBMS:

Data Storage: DBMS helps store large amounts of data in an organized way.
Data Retrieval: Users can easily search and retrieve specific data.
Data Manipulation: Allows for updating, adding, or deleting data.
Data Security: Protects data so that only authorized users can access it.

Applications of DBMS

DBMS is used in various fields to manage data effectively:

Banking: Banks use DBMS to manage customer information, account details, and transaction records. This allows for quick access to customer accounts and secure transaction processing.
Education: Schools and universities use DBMS to keep records of students, courses, grades, and staff details, making it easy to access and update information.
Healthcare: Hospitals use DBMS to store patient records, medical histories, and treatment information, helping doctors and staff access important information quickly and securely.
Telecommunication: Telecom companies use DBMS to keep track of user data, call records, and billing information, ensuring accurate billing and customer management.

Advantages of DBMS

Data Integrity: DBMS ensures that data is accurate and consistent across the database. For example, if a bank account balance is updated, it will be reflected in all relevant records.
Data Security: DBMS allows access to be controlled, so only authorized users can see or edit the data. This is especially important for sensitive information like personal details or financial data.
Reduced Redundancy: DBMS avoids the need to store the same information in multiple places, reducing duplication and making data management easier.
Data Sharing: Multiple users can access and work on the data at the same time without interfering with each other. This allows teams to collaborate more efficiently.

Disadvantages of DBMS

Complexity: A DBMS can be complicated to set up and manage, requiring specialized knowledge and skills.
Cost: Installing and maintaining a DBMS can be expensive, as it may involve purchasing software and hiring qualified personnel.
Increased Storage Requirements: A DBMS often requires more storage space and memory than simpler systems, especially if it includes backup and security features.
Maintenance Needs: Regular updates and maintenance are necessary to keep the DBMS running smoothly, which can be time-consuming.

File Management System (Flat File System)

Definition: A File Management System, often called a flat file system, is a way of organizing data into individual files. Each file might represent a different data category, and there is no central structure to connect these files.

Example: Think of a file cabinet where each drawer holds a different type of document. There is no easy way to relate information across different drawers.

Limitations of Flat File System

Data Redundancy: The same data may be stored in multiple files, causing duplicate information and taking up unnecessary space.
Data Isolation: It's hard to access related data stored in separate files, making data retrieval slow and inefficient.
Security Issues: Flat file systems lack sophisticated security measures, making data vulnerable to unauthorized access.
Inconsistency: Data may be different in various files, leading to errors.

Advantages of Flat File System

Simplicity: It is straightforward to use, with each file stored separately, making it easy to understand.
Low Cost: Compared to DBMS, it is inexpensive as it does not require special software.
Less Hardware: It usually requires less memory and storage, making it suitable for smaller data needs.

Advantages of DBMS over File Management System

Data Consistency: DBMS keeps all data consistent and avoids duplication, reducing errors.
Improved Security: DBMS provides a secure environment, ensuring only authorized users can access or modify the data.
Easy Access: It is easy to retrieve and update information as all data is stored centrally.
Better Integration: DBMS connects data, allowing for more powerful data analysis and reporting.

Difference Between File-Based System and Database System

Feature	File-Based System	Database System (DBMS)
Data Redundancy	High; data often duplicated	Low; data is stored centrally
Data Integrity	Harder to maintain	Enforced through constraints
Data Security	Limited security options	Strong security controls
Data Sharing	Difficult to share	Easy multi-user access
Backup & Recovery	Manual and unreliable	Automated and reliable
Data Access Speed	Slower due to file searches	Faster through optimized queries
Cost	Lower but less efficient	Higher but more efficient

Participants in a Database Management System

Actors on the Scene

These are the primary users of the database system:

End-Users: The people who interact with the database applications to access data, like customers or employees using a bank's online system.
Application Programmers: They develop applications that interact with the database, ensuring data retrieval, updates, and smooth operation for users.
Database Administrators (DBAs): They manage the entire database system, handle backups, ensure data security, and set user permissions.
Database Designers: They design the database structure, decide on data types, relationships, and overall data organization to meet business needs.

Workers Behind the Scene

These individuals don't interact with the database directly but support its functionality:

System Analysts: They assess the organization's data needs, design specifications, and ensure that the database system aligns with these needs.
System Programmers: These are software engineers who maintain the DBMS software itself, often working on updates, fixes, and performance improvements.

What Exactly Is a Domain Name Server (DNS) 🌐 🔑? And How Does It Really Work? Simplified Explanation 🔍

Dipsan Kadariya — Fri, 06 Sep 2024 17:06:42 +0000

On the Internet, computers identify each other using unique numbers called IP addresses. An IP address (Internet Protocol address) is a unique identifier assigned to each device on a network. Since computers don't understand human language, you might wonder how websites load when you type something into a web browser, like www.youtube.com. This is where DNS comes into play.

If two people speak different languages, they need a translator for effective communication. Similarly, on the Internet, while computers understand IP addresses and numeric values, we are generally more familiar with English and alphabets. DNS acts as a translator between humans and computers.

DNS maps domain names to their IP addresses. For example, DNS maps www.google.com to its IP address, such as 108.177.122.139. So when a user wants to browse and look up Google, instead of remembering the IP address, we can simply use the domain name.

When we type google.com into the web browser, DNS translates it into the web browser's language, which is an IP address, and provides it to the web browser. The web browser then understands that we want to access google.com, so it contacts the Google server and loads google.com on the computer.

Now that we know what DNS is, To understand how DNS works internally, we need to know about DNS servers. Servers are specialized computers or software systems that provide services, resources, or data to other computers or clients over a network. Servers are computers storing HTML files, images, sounds, videos, and other file types. Servers that work together to provide the IP address of the requested website to the web browser are called DNS servers.

There are four types of DNS:
DNS recursive resolver or DNS resolver, root name server, top-level domain (TLD) name server, and authoritative name server.

1. DNS Recursive Resolver (DNS Resolver)

The DNS recursive resolver is the first point of contact in the DNS query process. It acts as an intermediary between the client (your computer or device) and other DNS servers.

Key points about DNS recursive resolvers:

They receive DNS queries (A DNS query is a request for information sent from a DNS client (such as your computer or smartphone) to a DNS server) from client machines through applications like web browsers.
Its primary function is to find the IP address associated with a given domain name.
It can cache DNS information (previous history) to speed up future requests for the same or similar queries.
If the requested information isn't in their cache, they initiate a series of requests to other DNS servers to find the required information.

Example scenario:
When you type "www.youtube.com" into your browser, your computer first sends this query to a DNS recursive resolver, typically provided by your Internet Service Provider (ISP).

2. Root Name Server

Root name servers are at the top of the DNS hierarchy and can be thought of as the starting point for DNS queries.

Key points about root name servers:

Root servers don't know the IP addresses of individual websites.
Instead, they provide information about the Top-Level Domain (TLD) servers.

Example scenario:
If the DNS resolver doesn't have the IP address for "www.youtube.com" cached, it will ask a root server for the address of the .com TLD server.

3. Top-Level Domain (TLD) Name Server

TLD name servers are responsible for maintaining information for all domain names that share a common domain extension (e.g., .com, .org).

Key points about TLD name servers:

They manage the next level in the hierarchy after the root servers.
Common TLDs include .com, .org, .net, .edu, and country-code TLDs like .uk, .ca, .jp.
They store the IP addresses of authoritative name servers for domains under their TLD.

Example scenario:
The .com TLD name server doesn't know the IP address of "www.youtube.com", but it knows the address of the authoritative name server for the "youtube.com" domain.

4. Authoritative Name Server

The authoritative name server is the final stop in the DNS query journey. It's the server that actually has the needed information about a specific domain.

Key points about authoritative name servers:

They host the DNS records for a specific domain.
These records include the IP addresses associated with the domain and its subdomains.
They are typically managed by the domain owner or their hosting provider.
There are usually at least two authoritative name servers for each domain for redundancy.

Example scenario:
The authoritative name server for "youtube.com" knows the IP address for "www.youtube.com" and provides this information back through the chain to your computer.

The DNS Resolution Process in Detail

Simple walk through of how DNS Work:

User Input: You type "www.youtube.com" into your web browser.
Check Local Cache: Your computer first checks its local DNS cache to see if it has recently looked up this domain.
Query DNS Resolver: If the domain is not found locally, your computer sends a request to the DNS recursive resolver provided by your ISP.
Check Resolver Cache: The resolver checks its own cache to see if it has the IP address for "www.youtube.com."
Query Root Server: If the IP address is not in the resolver's cache, it sends a query to a root name server.
Root Server Response: The root server responds with the address of the TLD DNS server for .com domains.
Query TLD Server: The resolver then queries the .com TLD server.
TLD Server Response: The TLD server responds with the IP address of the authoritative name server for "youtube.com."
Query Authoritative Server: The resolver queries the authoritative name server for "youtube.com."
Authoritative Server Response: The authoritative name server responds with the IP address for "www.youtube.com."
Resolver Response: The DNS resolver sends this information back to your computer.
Local Storage and Browser Usage: Your computer stores the IP address in its local cache and your browser uses this IP address to access "www.youtube.com."

Thanks for reading the blog.

Computer Networks 101 💡| Understanding the Fundamentals in Networking.📶🌐

Dipsan Kadariya — Fri, 06 Sep 2024 05:55:39 +0000

Computer Network

Computer Network is a group of computers and other hardware devices that are linked together via communication channels to process communication and enable resource sharing among a wide range of users.

Uses:

Enable multiple users to share a single hardware devices like printer, scanner
Enable communication among wide range of uses
Easy data sharing and communication

Advantages:

Highly flexible
Inexpensive
Allows resource sharing
Cost efficient

Disadvantages:

Low security
Centralized
Doorway for viruses and malware
Requires a handler

Network Topology

Network Topology refers to the physical or logical layout of network. It defines the way different nodes (computer) are placed and interconnected with each other. Network Topology helps to describes the way the data is transferred into these nodes.

Bus topology

Type of Network Topology where devices are connected sequentially to the same transmission line.

Advantages:

Low cost
Simple to use

Disadvantages:

Low security
If wire fails, the network is down

Star Topology

Nodes are connected to a central devices like switch via cable.

Advantages:

Most preferred way and most popular
Easy to use

Disadvantages:

If hub is down, network is also down

Ring topology

Nodes are connected sequentially same as bus topology but the transmission line ends at the starting node, forming a circular ring.

Advantages:

Overcomes the limitation of bus
Fast

Disadvantages:

Costly because of wire

Tree topology

Nodes are connected in hierarchical network structure resembling a tree
The first node is the parent node (central node, has it has multiple sub nodes connected to it)

Advantages:

High security
Scalable

Disadvantages:

Expensive
Maintenance

Mesh Topology

Nodes are interconnected to each other in decentralized manner
Each node directly connects to multiple other devices forming a mesh like structure

Advantages:

Flexible
Scalable

Disadvantages:

High cost
Complex structure

Types of network:

1. Personal area network (PAN)

Small and basic network
Uses mobile smartphones as the networking devices
Connect devices within an individual space with few meter range
Average speed and cost

2. Local Area Network (LAN)

Also Simple and basic network
Uses router as a networking device
Connects within a limited range such as home, school or building
High speed and low cost

3. Wide area network (WAN)

Spans over a large geographical area, often country or continent
Connects multiple LAN or MAN
Used by big organizations with multiple location for connecting to the internet
Uses satellite links, MPLS (Multiprotocol label switching) for networking

4. Metropolitan area network (MAN)

Covers large geographical area than LAN but smaller than WAN, typically covering city or large campus
Connects multiple LANs within a WAN
Uses fiber optic cables or wireless broadband
Used by school, campus and hospital

Types of Networking

1. Peer to Peer Networking (p2p)

Each computer, or "peer," acts as both a client and a server
No central server or administrator, instead, all peers are equal and communicate directly with each other
Peers can perform all the functions of a server and a client, such as requesting data from other peers, providing data to other peers, and performing processing tasks
Highly decentralized model

2. Client-Server Network

A central server or a group of servers, provide data, resources and services to multiple clients
Clients are typically end-users that request services or resources from the server
The server processes these requests and sends the required data or services back to the clients
This establishes a clear distinction between the service providers (servers) and the service consumers (clients)
Servers are dedicated machines that run server software to handle various tasks, such as hosting websites, managing databases, running applications, or controlling network access. Clients use client software to interact with the server and utilize the provided services.

Network Protocols

Established set of rules that determine how data is transmitted between different devices
Allows to connect and communicate with other users and devices
Is the reason we are able to communicate easily all around the world

Commonly used Networking Protocols

1. HTTP

Hypertext transfer protocol
Defines how data is transmitted over the internet and determines how the web browsers respond to the commands
Appears at the beginning of various URLs or web address online

2. SSH (Secure Shell protocol)

Provides secure access to a computer, even on an unsecured network
Particularly useful for network administrators who need to manage the system remotely

3. SMS (Short message services)

Service that allows users all around the world to communicate via text over cell

The key elements to the protocols are:

Syntax: Structure or format of the data
Semantics: Meaning of each section
Timing: Time for sending data

Networking Standards

Standard agreed upon rules for data communications

Types:

De facto: Rules that are not approved as standard (not approved as a standard)
De jure: Approved by the law (official)

OSI model

Stands for Open System Interconnection model
Developed by ISO (International Standard Organization)
Developed to Standardize the functions of a telecommunication or computing system into seven distinct layers for better communication between different systems and networks

Application Layer (Layer 7)

Manages human-computer interaction and network services
Handles: Services and programs that use the network to transmit and receive data, such as web browsers and email clients
Includes protocols like HTTP, FTP, SMTP

Presentation Layer (Layer 6)

Formats and encrypts data for the application layer
Handles services like compression (reducing data size), encryption (unreadable format so that secure and back to the original format upon receiving)

Session Layer (Layer 5)

Manages sessions and authentication between devices
Handles services like session establishment, authentication and authorization (Ensuring that connections are secure and that users have permission to access resources)

Transport Layer (Layer 4)

Ensures reliable data transfer and manages ports
Handles services like managing ports and data segmentation
Has protocols like TCP (Transfer Control Protocol) for reliability

Network Layer (Layer 3)

Responsible for packet forwarding and routing between different networks
Handles traffic control and logical addressing i.e., managing IP addresses

Data Link Layer (Layer 2)

Responsible for node-to-node data transfer and error detection
Handles MAC Addressing: Uses MAC addresses to identify devices on a local network
Error Detection and Correction: Detects and corrects errors from the Physical layer and data formatting

Physical Layer (Layer 1)

Responsible for: Transmitting data over a physical medium
Handles the transmission and reception of raw binary data

The TCP/IP Model

The TCP/IP model combines OSI layers 1&2 (Physical, Data Link) into a single layer 1 (Network Access)
Similarly layer 5,6,7 (Application, Presentation, Session) into a single layer 4 (Application)
It also renames the network layer (layer 3) into Internet

Layer 1 - Network Access

Combines OSI layers 1 & 2 (Physical and Data Link)
Handles the physical transmission of data and hardware-level protocols

Layer 2 - Internet

Renamed from the OSI Network layer (layer 3)
Deals with logical addressing and routing

Layer 3 - Transport

Equivalent to OSI layer 4 (Transport)
Manages end-to-end communication and data flow

Layer 4 - Application

Combines OSI layers 5, 6, & 7 (Session, Presentation, and Application)
Handles high-level protocols and user interfaces

Key points to remember:

The TCP/IP model is more compact than the OSI model
It merges multiple OSI layers into single layers in some cases
The "Internet" layer in TCP/IP is essentially a renamed "Network" layer from OSI
This model is more closely aligned with how networks actually operate in practice

Addressing in Networks

Addressing refers to process of identifying devices or endpoints within a network.

1. Physical address

Known as MAC address
Used in NIC, most LAN uses 6 bytes (48 bits), each byte containing two bits, separated by colon
Written as 12 hexadecimal digits
Example: 07:08:1B:2C:55:7D (6 byte, 2 bits each)
Included in Data Link layer

2. Logical address

A logical or IP address is used to identify a host or a network interface within a network and across networks
It's assigned by software (usually dynamically via DHCP or statically)
Logical addresses can change, unlike physical addresses
IPv4: A 32-bit address divided into four octets (e.g., 192.168.1.1)
IPv6: A 128-bit address

3. Port Address

16 bit address represented by one decimal
Port addresses are used to identify specific processes or services on a host within a network
They are associated with the transport layer protocols, such as TCP and UDP, and help direct data to the correct application
Example: 753

Backbone Network

A backbone network is the central part of a network that interconnects various smaller networks, providing a path for the exchange of information between different LANs, WANs, or subnetworks. It's responsible for carrying the bulk of data traffic across large distances or within a complex network structure.

Key Points:

Scalability
Centralized Connectivity
High Capacity

Types of Networking Devices

a) Router

Device that connects different networks and routes data between them
Uses IP address to find the best path for the data

b) Hub

Connects multiple devices in a network and broadcasts the data to all
There is no data filtering, so it may lead to collisions

c) Switch

Connects devices and directs data to a specific destination within a network
Uses MAC address to reduce collisions

d) Repeater

Extends network range by amplifying signals
Regenerates weakened signal over long distances

e) Bridge

Connects and filters traffic between network segments
Reduces traffic by forwarding data only to the correct segment

Types of Transmission Media

a) Twisted Pair Cable

Transmits data via copper wires twisted together to reduce interference
Inexpensive and widely used for short to medium distances

Types:

Unshielded Twisted Pair (UTP): Has ability to block interference. Common in LANs (e.g., Ethernet cables)
Shielded Twisted Pair (STP): Uses extra shielding to reduce electromagnetic interference

b) Coaxial Cable

Transmits data through a single copper conductor surrounded by insulation and shielding
Provides better shielding than twisted pair cables
Commonly used in cable TV networks and older Ethernet networks

c) Fiber Optic Cable

Transmits data as light pulses through glass or plastic fibers
High-speed, long-distance transmission with minimal signal loss

Types:

Single-Mode Fiber (SMF): Used for long-distance transmission (e.g., telecom networks)
Multi-Mode Fiber (MMF): Used for shorter distances (e.g., within buildings)

d) Wireless

Electromagnetic waves that can be transmitted in all directions
3kHz to 1kHz

e) Microwaves

Uses microwaves for sending and receiving signals
Cheaper

Switching

For large networks, or if very long distance transmission has to take place, it is difficult to do it without any external hardware devices. We need a dedicated path for the data to travel. Since there are many paths to take, we need to select a particular path. Selecting the path on which the data packets will be transmitted is called switching.

1. Circuit Switching

A dedicated communication path is established between two devices for the duration of the session
The entire bandwidth is reserved for the connection, ensuring consistent data transmission
Example: Traditional telephone networks
Three phases: Setup, data transfer and teardown phase

2. Packet Switching

Data is broken into smaller packets, which are sent independently across the network
Packets may take different paths and are reassembled at the destination
Efficient use of network resources, as no dedicated path is required
Example: The Internet

3. Message Switching

Entire messages are sent from one device to another, stored temporarily at intermediate nodes, and then forwarded
No dedicated path; messages are sent when a path is available
Can lead to delays due to the store-and-forward nature
Example: Older telegraph networks

DNS (Domain Name System)

Now that we know what DNS is, to understand how DNS works internally, we need to know about DNS servers. Servers are specialized computers or software systems that provide services, resources, or data to other computers or clients over a network. Servers are computers storing HTML files, images, sounds, videos, and other file types. Servers that work together to provide the IP address of the requested website to the web browser are called DNS servers.

Working of DNS

DNS Working in Short:

User Request: You type a domain name (e.g., www.example.com) into your browser
DNS Query: The browser checks its cache; if not found, it sends a query to a DNS resolver
Resolver Process:
- The resolver queries the root DNS server, which directs it to the TLD server (e.g., .com)
- The TLD server directs the query to the authoritative DNS server for the domain
IP Address Return: The authoritative DNS server provides the IP address for the domain
Connection: The browser uses the IP address to connect to the website's server
Caching: The IP address is cached for faster access in the future

Cover All Python Fundamentals with these 7 projects🔥 | From Quizzes to Password Manager. 🔐

Dipsan Kadariya — Thu, 05 Sep 2024 15:17:54 +0000

Making projects is the best way to take what you learn and put it into action. While these projects may seem simple and easy, they play a crucial role in building a strong foundation in Python programming. I've created these projects to cover most of the fundamentals in Python, ensuring that anyone can learn and improve their coding skills through hands-on practice.

1. Quiz Game

What is it? A simple quiz game where the computer asks questions and the player answers them.

Concepts used:

Lists and tuples
Random module
Loops
Conditional statements
User input handling
Score tracking

How it works: The game starts by welcoming the player and asking if they want to play. It then presents a series of randomized questions from a predefined list. The player's answers are checked, and their score is updated accordingly. The game provides feedback on each answer and displays the final score at the end.

import random  # Import the random module for shuffling

print("Welcome to the Quiz Game")  # Print welcome message
wanna_play = input("Do you want to play the game (yes/no): ").lower()  # Ask if the user wants to play
if wanna_play != 'yes':  # If user does not want to play, quit
    quit()
print("Okay, then! Let's play")  # Print message to start the game

# Creating a list of tuples containing questions and answers 
question_answer_pairs = [
    ("What does CPU stand for?", "Central Processing Unit"),
    ("Which programming language is known as the 'mother of all languages'?", "C"),
    ("What does HTML stand for?", "HyperText Markup Language"),
    # ... (more questions)
]

# Shuffle the list of tuples to ensure random order
random.shuffle(question_answer_pairs)

score = 0

# Iterate through the shuffled list of tuples 
for question, correct_answer in question_answer_pairs:
    user_answer = input(f"{question} ").strip()  # Ask the question and get user input
    if user_answer.lower() == correct_answer.lower():  # Check if the answer is correct
        print("Correct answer")
        score += 1  # Increase score for a correct answer
    else:
        print(f"Incorrect answer. The correct answer is: {correct_answer}")
        score -= 1  # Decrease score for an incorrect answer
    print(f"Current Score: {score}")

# Print the final score
print(f"Quiz over! Your final score is {score}/{len(question_answer_pairs)}")

2. Number Guessing Game (Computer Guesses)

What is it? A number guessing game where the computer tries to guess a number chosen by the user.

Concepts used:

Functions
Loops
Conditional statements
User input handling
Binary search algorithm

How it works: The user defines a range and chooses a number within that range. The computer then uses a binary search approach to guess the number, with the user providing feedback on whether the guess is too high, too low, or correct. The game continues until the computer guesses correctly or determines that the number is outside the specified range.

def guess_number():
    """
    Function where the computer attempts to guess a number chosen by the user within a specified range.

    The user defines the lower and upper bounds of the range and provides a number for the computer to guess.
    The computer uses a binary search approach to guess the number and the user provides feedback to guide it.
    """
    # Get the lower bound of the range from the user
    low = int(input("Enter the lower range: "))
    # Get the upper bound of the range from the user
    high = int(input("Enter the higher range: "))

    # Check if the provided range is valid
    if low >= high:
        print("Invalid range. The higher range must be greater than the lower range.")
        return  # Exit the function if the range is invalid

    # Get the number from the user that the computer will attempt to guess
    Your_number = int(input(f"Enter your number for the computer to guess between {low} and {high}: "))

    # Check if the number entered by the user is within the specified range
    if Your_number < low or Your_number > high:
        print("The number you entered is out of the specified range.")
        return  # Exit the function if the number is out of the range

    # Initialize the computer's guess variable
    computer_guess = None

    # Loop until the computer guesses the correct number
    while computer_guess != Your_number:
        # Compute the computer's guess as the midpoint of the current range
        computer_guess = (low + high) // 2
        print(f"The computer guesses: {computer_guess}")

        # Get feedback from the user about the computer's guess
        feedback = input(f"Is {computer_guess} too low, too high, or correct? (Enter 'h' for higher, 'l' for lower, 'c' for correct): ").strip().lower()

        # Process the user's feedback to adjust the guessing range
        if feedback == 'c':
            if computer_guess == Your_number:
                print("The computer guessed your number correctly! Congrats!")
                return  # Exit the function once the correct number is guessed
            else:
                continue  
        elif feedback == 'h':
            high = computer_guess - 1  # If the guess is too high, lower the upper range
        elif feedback == 'l':
            low = computer_guess + 1  # If the guess is too low, increase the lower range
        else:
            print("Invalid feedback, please enter 'h', 'l', or 'c'.")  # Handle invalid feedback

# Call the function to start the guessing game
guess_number()

3. Number Guessing Game (User Guesses)

What is it? A number guessing game where the user tries to guess a randomly generated number.

Concepts used:

Functions
Random module
Loops
Conditional statements
Exception handling
User input validation

How it works: The computer generates a random number within a specified range. The user then makes guesses, and the program provides feedback on whether the guess is too high or too low. The game continues until the user guesses the correct number or decides to quit.

import random  # Import the random module to use its functions for generating random numbers

def guess_random_number(number):
    """
    Function to allow the user to guess a random number between 1 and the specified `number`.
    This function generates a random integer between 1 and the provided `number` (inclusive).
    It then repeatedly prompts the user to guess the random number, providing feedback on whether
    the guess is too high or too low, until the correct number is guessed. The function handles
    invalid inputs by catching exceptions and informing the user to enter a valid integer.
    """
    # Generate a random number between 1 and the specified `number` (inclusive)
    random_number = random.randint(1, number)
    guess = None  # Initialize the variable `guess` to None before starting the loop

    # Loop until the user guesses the correct number
    while guess != random_number:
        try:
            # Prompt the user to enter a number between 1 and `number`
            guess = int(input(f"Enter a number between 1 and {number}: "))

            # Provide feedback based on whether the guess is too low or too high
            if guess < random_number:
                print("Too low, guess a greater number.")
            elif guess > random_number:
                print("Too high, guess a smaller number.")

        except ValueError:
            # Handle the case where the user inputs something that isn't an integer
            print("Invalid input. Please enter a valid integer.")

    # Congratulate the user once they guess the correct number
    print("You have guessed the random number correctly. Congrats!")

# Call the function with an upper limit of 10
guess_random_number(10)

4. Hangman Game

What is it? A classic word guessing game where the player tries to guess a hidden word letter by letter.

Concepts used:

Importing modules
Random selection from a list
String manipulation
Loops
Conditional statements
List comprehension

How it works: The game selects a random word from a predefined list. The player then guesses letters one at a time. Correct guesses reveal the letter's position in the word, while incorrect guesses reduce the player's remaining lives. The game ends when the player guesses the entire word or runs out of lives.

import random
from word_list import words  # Import the words from word_list.py file

def hangman():
    random_word = random.choice(words)  # Generate the random word
    print(random_word)  # Print the chosen word for testing purposes; remove in production

    word_display = ["_"] * len(random_word)  # Create blank lines "_" equal to the length of the word
    guessed_letters = []  # Empty list to store the letters that have been guessed
    lives = 5  # Number of lives for the player

    print("Welcome to Hangman!")  # Print welcome statement
    print(" ".join(word_display))  # Display the current state of the word

    while lives > 0:  # The game continues to run as long as the player has more than 0 lives
        user_guess = input("Enter a single letter for your guess: ").lower()  # Ask the player to input a letter

        # Check whether the player entered a valid input
        if len(user_guess) != 1 or not user_guess.isalpha():
            print("Invalid input. Please enter a single letter.")
            continue

        # Check if the letter has already been guessed
        if user_guess in guessed_letters:
            print(f"You've already guessed '{user_guess}'. Try another guess.")
            continue

        # Add the guessed letter to the guessed_letters list
        guessed_letters.append(user_guess)

        # Check if the guessed letter is in the random_word
        if user_guess in random_word:
            # Update word_display with the correctly guessed letter
            for index, letter in enumerate(random_word):
                if letter == user_guess:
                    word_display[index] = user_guess
            print("Good guess!")
        else:
            lives -= 1  # Reduce the number of remaining lives by 1 for an incorrect guess
            print(f"Wrong guess! Remaining lives: {lives}")

        # Display the current state of the word
        print(" ".join(word_display))

        # Check if the player has guessed all letters
        if "_" not in word_display:
            print("Congratulations, you guessed the word!")
            break

    else:
        # This runs if no lives are left
        print(f"You have run out of lives. The word was: {random_word}")

hangman()  # Function to start the game

5.Rock Paper Scissors

What is it? A classic "Rock, Paper, Scissors" game where the user plays against the computer.

Concepts used:

Loops
Conditional statements
Functions
Random module
User input handling

How it works: The user chooses either rock, paper, or scissors, while the computer randomly picks one of the options as well. The program then compares the choices, determines the winner, and asks the user if they want to play again.

import random  # Import the random module to generate random choices for the computer.

def playGame():
    while True:  # Infinite loop to keep the game running until the user decides to stop.
        # Ask the user to enter their choice and convert it to lowercase.
        user_choice = input("Enter 'r' for rock, 'p' for paper, 's' for scissors: ").strip().lower()

        # Check if the user input is valid (i.e., 'r', 'p', or 's').
        if user_choice not in ['r', 'p', 's']:
            print("Invalid Input. Please try again.")
            continue  # If the input is invalid, restart the loop.

        print(f"You chose {user_choice}")  # Display the user's choice.

        # Computer randomly picks one of the choices ('r', 'p', 's').
        computer_choice = random.choice(['r', 'p', 's'])
        print(f"The computer chose {computer_choice}")  # Display the computer's choice.

        # Check if the user's choice is the same as the computer's choice.
        if user_choice == computer_choice:
            print("It's a tie.")  # It's a tie if both choices are the same.
        elif _iswinner(user_choice, computer_choice):
            print("You won!")  # The user wins if their choice beats the computer's choice.
        else:
            print("You lost.")  # The user loses if the computer's choice beats theirs.

        # Ask the user if they want to play again.
        play_again = input("Do you want to play again? Enter 'yes' or 'no': ").strip().lower()

        # If the user doesn't enter 'yes', end the game.
        if play_again != 'yes':
            print("Thank you for playing!")  # Thank the user for playing.
            break  # Exit the loop and end the game.

def _iswinner(user, computer):
    # Determine if the user's choice beats the computer's choice.
    # Rock ('r') beats Scissors ('s'), Scissors ('s') beat Paper ('p'), Paper ('p') beats Rock ('r').
    if (user == "r" and computer == "s") or (user == "p" and computer == "r") or (user == "s" and computer == "p"):
        return True  # Return True if the user wins.

# Start the game by calling the playGame function.
playGame()

6. 2 User Tick Tack Toe

What is it Tic-Tac-Toe is a classic two-player game where players take turns marking spaces on a 3x3 grid. The goal is to be the first to get three of their marks in a row, either horizontally, vertically, or diagonally. The game ends when one player achieves this, or when all spaces on the grid are filled without a winner, resulting in a draw.

*Concepts used: *

Function Definition and Calling
Data Structures (2D List)
Loops (for, while)
Conditional Statements (if, else)
Input Handling and Validation
Game State Management
String Formatting
Exception Handling

def print_board(board):
    """Prints the game board in a structured format with borders."""
    print("\n+---+---+---+")  # Print the top border of the board
    for row in board:
        # print each row with cell values separated by borders
        print("| " + " | ".join(row) + " |")
        # print the border after each row
        print("+---+---+---+")

def check_winner(board):
    """Checks for a winner or a draw."""
    # define all possible winning lines: rows, columns, and diagonals
    lines = [
        [board[0][0], board[0][1], board[0][2]],  # Row 1
        [board[1][0], board[1][1], board[1][2]],  # Row 2
        [board[2][0], board[2][1], board[2][2]],  # Row 3
        [board[0][0], board[1][0], board[2][0]],  # Column 1
        [board[0][1], board[1][1], board[2][1]],  # Column 2
        [board[0][2], board[1][2], board[2][2]],  # Column 3
        [board[0][0], board[1][1], board[2][2]],  # Diagonal from top-left to bottom-right
        [board[0][2], board[1][1], board[2][0]]   # Diagonal from top-right to bottom-left
    ]

    # Check each line to see if all three cells are the same and not empty
    for line in lines:
        if line[0] == line[1] == line[2] and line[0] != ' ':
            return line[0]  # Return the player ('X' or 'O') who has won

    # Check if all cells are filled and there is no winner
    if all(cell != ' ' for row in board for cell in row):
        return 'Draw'  # Return 'Draw' if the board is full and no winner

    return None  # Return None if no winner and the game is not a draw

def main():
    """Main function to play the Tic Tac Toe game."""
    # Initialize the board with empty spaces
    board = [[' ' for _ in range(3)] for _ in range(3)]
    current_player = 'X'  # Start with player 'X'

    while True:
        print_board(board)  # Print the current state of the board

        try:
            # Prompt the current player for their move
            move = input(f"Player {current_player}, enter your move (1-9): ")
            move = int(move)  # Convert the input to an integer

            # Check if the move is valid (between 1 and 9)
            if move < 1 or move > 9:
                print("Invalid move, try again.")
                continue  # Ask for a new move

        except ValueError:
            # Handle cases where the input is not an integer
            print("Invalid move, try again.")
            continue  # Ask for a new move

        # Convert the move number to board coordinates (row, col)
        row, col = divmod(move - 1, 3)

        # Check if the cell is already occupied
        if board[row][col] != ' ':
            print("Cell already occupied. Choose a different cell.")
            continue  # Ask for a new move

        # Place the current player's mark on the board
        board[row][col] = current_player

        # Check if there is a winner or if the game is a draw
        winner = check_winner(board)

        if winner:
            print_board(board)  # Print the final board state
            if winner == 'Draw':
                print("The game is a draw!")
            else:
                print(f"Player {winner} wins!")  # Announce the winner
            break  # End the game

        # Switch players
        current_player = 'O' if current_player == 'X' else 'X'

if __name__ == "__main__":
    main()  # Start the game

7. Password Manager

What is it? A simple password manager that allows users to store and retrieve encrypted passwords.

Concepts used:

File I/O operations
Encryption using the cryptography library
Functions
Exception handling
User input handling
Loops

How it works: The program uses the Fernet symmetric encryption from the cryptography library to securely store passwords. Users can add new passwords or view existing ones. Passwords are stored in an encrypted format in a text file, and decrypted when viewed.

from cryptography.fernet import Fernet

# The write_key function generates an encryption key and saves it to a file.
# It's currently commented out, but you need to run it once to create the 'key.key' file.
'''
def write_key():
    key = Fernet.generate_key()
    with open("key.key", "wb") as key_file:
        key_file.write(key)
'''

def load_key():
    """This function loads the encryption key from the 'key.key' file."""
    file = open("key.key", "rb")
    key = file.read()
    file.close()
    return key

# Load the key and create a Fernet object
key = load_key()
fer = Fernet(key)

def view():
    """Function to view stored passwords in the 'passwords.txt' file"""
    with open('passwords.txt', 'r') as f:
        for line in f.readlines():
            data = line.rstrip()
            user, passw = data.split("|")
            decrypted_password = fer.decrypt(passw.encode()).decode()
            print("User:", user, "| Password:", decrypted_password)

def add():
    """Function to add new account names and passwords to the 'passwords.txt' file"""
    name = input('Account Name: ')
    pwd = input("Password: ")
    with open('passwords.txt', 'a') as f:
        encrypted_password = fer.encrypt(pwd.encode()).decode()
        f.write(name + "|" + encrypted_password + "\n")

# Main loop to ask the user what they want to do: view passwords, add new passwords, or quit
while True:
    mode = input(
        "Would you like to add a new password or view existing ones (view, add), press q to quit? ").lower()

    if mode == "q":
        break
    if mode == "view":
        view()
    elif mode == "add":
        add()
    else:
        print("Invalid mode.")
        continue

Thanks for stopping and reading the blog.
Github Repo : https://github.com/iamdipsan/Python-Projects

Master OS Concepts 💡 | Understanding Threads, Processes & IPC 🔧

Dipsan Kadariya — Sat, 31 Aug 2024 13:41:06 +0000

Operating Systems: Concepts and Structures

Introduction

Operating systems are the backbone of modern computing, serving as the crucial interface between hardware and software. Whether you're a seasoned developer or just starting your journey in computer science, understanding the fundamentals of operating systems is essential. In this comprehensive guide, we'll explore the core concepts, structures, and mechanisms that make operating systems tick.

The Dual Role of Operating Systems

Operating system as a extended Machine acts as a intermediate between the user and Hardware. it helps in data abstraction by hiding the unnecessary details and information and provides a user friendly interface for the user to interact with the computer system.

Operating system as a resource manager manages CPU memory and input output devices. it helps efficient resources allocation by ensuring that the system resources are used optimally preventing wastage of resources and maximizing the performance.

Types of OS

Batch processing operating system is operating system that executes jobs in batches without the user interaction. The jobs are process sequentially one after another.
Multiprogramming operating system is operating system that allows multiple programs to run simultaneously. The CPU switches between the programs to maximize utilization
Multi tasking operating system is operating system that runs multiple task t co -currently It works by rapidly switching between the task which makes it seem like they are running simultaneously.
Multiprocessor operating system is on operating system that supports multiple processor within a single system. It Distributes tasks across multiple CPUs for better performance.
Network operating system is a operating system that managers network resources and communication between computers. It enables file sharing and data access over a network.
Distributed operating system is a operating system that manages a group of independent computers making them appear as a single system. It facilitates resource sharing and task distribution among computers.
Real time operating system is a operating system that Provides precise and predictable task execution within strict time constraints. This OS prioritizes tasks based on importance, ensuring timely completion.

OS structure

OS structure includes components that make up an OS.

includes kernel, user interface, device drivers
kernel: manages core functions like memory, CPU and peripheral devices

Monolithic Structure

In a monolithic structure, the operating system is built as a single, large kernel where all the core functions are tightly integrated. This means that everything from file management to memory management and device drivers operates within a unified space. The advantage of this structure is its high performance since components can communicate directly with each other without intermediaries. However, because all functionalities are part of the same large kernel, debugging and maintaining the system can be more challenging. Unix and early versions of Linux are examples of monolithic operating systems.

Layered Structure

The layered structure organizes the operating system into a hierarchy of layers, where each layer is built on top of the previous one. This design allows for a clear separation of concerns, as each layer has its own specific responsibilities. For instance, lower layers might handle hardware interactions, while higher layers manage user interfaces. A key benefit of this structure is modularity, which makes the OS easier to develop, manage, and debug. Each layer only interacts with the one directly below it, reducing the complexity of the system as a whole. An example of a layered OS is the Windows NT architecture.

Microkernel Structure

The microkernel structure focuses on minimizing the functions that run in the kernel. Only essential services, such as basic inter-process communication (IPC) and simple I/O operations, are included in the kernel. Other services, such as file systems, network protocols, and device drivers, operate in user space. This modular approach enhances the security and stability of the system, as fewer components running in kernel mode means fewer chances for critical failures. Additionally, microkernels are more extensible and easier to update or modify. Minix and QNX are examples of microkernel-based operating systems.

Client-Server Model

In the client-server model, the operating system's functions are divided between clients (user applications) and servers (OS services). The clients make requests to the servers, which provide the necessary services through inter-process communication (IPC). This model is highly suited for distributed systems, where services may run on different machines across a network. It allows for a clear separation between user-level processes and system-level services, making the OS more modular and easier to scale. An example of an OS that uses the client-server model is the Mach kernel, which influenced the development of macOS.

Virtual Machine Structure

The virtual machine structure of an operating system involves creating a virtualized environment that emulates hardware, allowing multiple OS instances to run on a single physical machine. Each virtual machine operates as if it were running on its own independent hardware, with the OS managing resources and ensuring isolation between different virtual machines. This structure is particularly useful in cloud computing and environments where resource isolation and efficient use of hardware are critical. Virtualization platforms like VMware, Microsoft Hyper-V, and Xen use this structure to allow multiple operating systems to coexist on the same hardware.

Open-Source Operating Systems

An open-source operating system is a type of OS whose source code is made publicly available, allowing anyone to view, modify, and distribute it. This openness encourages community collaboration, innovation, and transparency in the development process.

System Calls

A system call is a mechanism that allows a program to request a service from the operating system's kernel. It provides an interface for user applications to perform operations that require privileged access to system resources, such as hardware devices, file systems, and inter-process communication.

example of system call is
key Feature: interface between user and kernel,access to system resources.

Process Model

Process Model refers to the conceptual structure that describes how processes are represented and managed within an operating system. It defines how the system views a process and organizes its operations.

Key Concepts in the Process Model

Single-Threaded Process

A process that contains only one thread of execution, meaning it can only execute one sequence of instructions at a time.
Characteristics: Simple to manage, but less efficient in utilizing system resources, as it cannot perform multiple tasks simultaneously within the same process.

Multi-Threaded Process

A process that contains multiple threads, each of which can execute independently but share the same resources like memory and file handles.
Characteristics: More efficient and responsive, as it allows concurrent execution of multiple tasks within the same process, making better use of system resources.

Benefits of the Process Model

Resource sharing
Modularity

Process States

New: The process is being created.
Ready: The process is waiting to be assigned to the CPU.
Running: Instructions are being executed.
Waiting: The process is waiting for some event (e.g., I/O completion
Terminated: The process has finished execution.

Process Control Block (PCB)

A data structure used by the OS to store all the information about a process.

Components of PCB

1) Process State: Current state of the process (new, ready, running, etc.).
2) Program Counter: Address of the next instruction to be executed.
3) CPU Registers: Information about the CPU's registers when the process is not running.
4) Memory Management Information: Details on memory allocation for the process.
5) I/O Status Information: Details about the process's I/O devices and files.
more are identifers etc

Threads

The smallest unit of processing that can be scheduled by an operating system.

Types of Threads

User Threads

Definition: Managed by user-level libraries rather than directly by the OS.Advantages: Faster context switching.
If one thread makes a blocking system call, the entire process is blocked.

Kernel Threads

Managed directly by the operating system, which schedules and handles thread execution.
multiple threads can run simultaneously on multiple processors.
Slower context switching compared to user threads.

Inter Process Communication (IPC)

A mechanism that allows processes to communicate and synchronize their actions when they are executing concurrently.
Essential for resource sharing, data exchange, and process synchronization in multiprogramming environments.

Race Condition

Occurs when multiple processes or threads read and write shared data, and the final outcome depends on the sequence of execution, leading to unpredictable results.
ex..Two threads incrementing the same variable simultaneously.

Critical Section

A part of the code where shared resources are accessed. Proper synchronization is required to prevent race conditions.
soln:Mechanisms like locks, semaphores, or monitors are used to ensure only one thread enters the critical section at a time.

IPC PROBLEMS

1. Producer-Consumer Problem

Definition:
The Producer-Consumer Problem is a classic synchronization problem where producers generate data and put it into a buffer, while consumers take data out of the buffer. The challenge is to coordinate between them to avoid overflows and underflows.

2. Sleeping Barber Problem

Definition:
The Sleeping Barber Problem involves a barber shop with one barber and several chairs. If no customers are present, the barber sleeps. If customers arrive and all chairs are occupied, they must wait. If chairs are available, they are served immediately.

3. Dining Philosophers Problem

Definition:
The Dining Philosophers Problem involves five philosophers sitting at a round table with a fork between each pair. They need both forks to eat. The challenge is to avoid deadlock and ensure that each philosopher gets a chance to eat.

Implementing Mutual Exclusion

Techniques for Mutual Exclusion

Busy Waiting

Definition: A technique where a process repeatedly checks a condition to achieve synchronization, consuming CPU time while waiting.
Drawback: Wasteful use of CPU resources.

Disabling Interrupts

Definition: Prevents the OS from switching processes by disabling hardware interrupts.
Drawback: Not practical for multi-user systems because it gives the running process control over the CPU for too long.

Lock Variables

Definition: A simple flag that processes can use to signal whether a resource is in use. However, this can lead to busy waiting.

Strict Alternation

Definition: A simple solution for two processes, where they take turns accessing a shared resource.
Drawback: Not efficient for more than two processes, and can cause delays.

Peterson's Solution

Definition: A classic software-based solution for two processes that ensures mutual exclusion without busy waiting.
Key Points: Relies on two variables, flag and turn, to manage access to the critical section.

Test and Set Lock

Definition: A hardware instruction that atomically tests and sets a lock variable, avoiding race conditions.

Sleep and Wakeup

Definition: A synchronization mechanism where processes go to sleep (stop execution) when they can't proceed and are woken up by other processes when they can continue.

Semaphore

Definition: A synchronization tool that uses counters to gain access to shared resources.
Types:
Binary Semaphore: Can be either 0 or 1.
Counting Semaphore: Can take any integer value.
Operations: wait() and signal() are the primary operations.

Monitors

Definition: High-level synchronization constructs that allow threads to have both mutual exclusion and the ability to wait for a certain condition to become true.
Components: Include condition variables for wait() and signal() operations.

Message Passing

Definition: A method of IPC where processes communicate by sending and receiving messages.
Use Case: Useful in distributed systems where processes do not share memory.

Batch System Scheduling

First-Come First-Served (FCFS)

Definition: The first process to arrive is the first to be executed.
Issue: Can cause the "convoy effect," where short processes get stuck behind long ones.

Shortest Job First (SJF)

Definition: The process with the shortest burst time is executed next.
Issue: Can cause starvation of long processes.
Optimality: Minimizes average waiting time in the system.

Shortest Remaining Time Next (SRTN)

Definition: A preemptive version of SJF where the process with the shortest remaining time is executed next.
Advantage: Better response time for shorter processes.

Interactive System Scheduling

Round-Robin Scheduling

Definition: Each process is assigned a fixed time slice, and if it doesn't finish in that time, it is placed back in the queue.
Advantage: Fair and responsive.
Time Quantum: The choice of time quantum is crucial for balancing responsiveness and overhead.

Priority Scheduling

Definition: Processes are assigned priorities, and the process with the highest priority is executed first.
Issue: Can lead to starvation if low-priority processes are never executed.
Solution: Aging can be used to gradually increase the priority of a process waiting in the queue.

Multiple Queues

Definition: Processes are divided into several queues based on priority or other criteria, with each queue having its own scheduling algorithm.
Example: A system might have one queue for foreground (interactive) processes and another for background (batch) processes.

Real-Time System Scheduling

Definition: Ensures that critical processes are completed within a specific time frame.
Use Case: Used in systems where timing is crucial (e.g., embedded systems in medical devices).

Master Python with Ease 🐍 | A Beginner's Guide to Python 📚

Dipsan Kadariya — Fri, 30 Aug 2024 10:30:43 +0000

Python Course Code Examples

This is a Documentation of the python code i used and created , for learning python.
Its easy to understand and Learn.Feel free to learn from here.
For more advanced concepts, please refer to the github repo at
https://github.com/iamdipsan/Python-for-cybersecurity

First Program
Variables and Data Types
Strings
Numbers
Getting Input from Users
Building a Basic Calculator
First Madlibs
Lists
List Functions
Tuples
Functions
Return Statement
If Statements
If Comparisons
Guessing Game 2
For Loop
Exponential Function
2D List and For Loops

First Program

This program is use to show how print() command works.

# This is a simple "Hello World" program that demonstrates basic print statements

# Print the string "Hello world" to the console
print("Hello world")

# Print the integer 1 to the console
print(1)

# Print the integer 20 to the console
print(20)

Variables and Data Types

A variable in Python is a reserved memory location to store values.
Data types define the type of data a variable can hold ie integer,float, string etc.

# This program demonstrates the use of variables and string concatenation

# Assign the string "Dipsan" to the variable _name
_name = "Dipsan"

# Assign the integer 20 to the variable _age
_age = 20

# Assign the string "piano" to the variable _instrument
_instrument = "piano"

# Print a sentence using string concatenation with the _name variable
print("my name is" + _name + ".")

# Print a sentence using string concatenation, converting _age to a string
print("I'm" + str(_age) + "years old")  # Converting int to string for concatenation

# Print a simple string
print("i dont like hanging out")

# Print a sentence using string concatenation with the _instrument variable
print("i love " + _instrument + ".")

Strings

Sequences of characters used to store and manipulate text. They are created by enclosing text in single quotes ('Hello'), double quotes ("Hello"), or triple quotes for multi-line strings ('''Hello'''). Example: "Hello, World!".

# This script demonstrates various string operations

# Assign a string to the variable 'phrase'
phrase = "DipsansAcademy"

# Print a simple string
print("This is a string")

# Concatenate strings and print the result
print('This' + phrase + "")

# Convert the phrase to uppercase and print
print(phrase.upper())

# Convert the phrase to lowercase and print
print(phrase.lower())

# Check if the uppercase version of phrase is all uppercase and print the result
print(phrase.upper().isupper())

# Print the length of the phrase
print(len(phrase))

# Print the first character of the phrase (index 0)
print(phrase[0])

# Print the second character of the phrase (index 1)
print(phrase[1])

# Print the fifth character of the phrase (index 4)
print(phrase[4])

# Find and print the index of 'A' in the phrase
print(phrase.index("A"))

# Replace "Dipsans" with "kadariya" in the phrase and print the result
print(phrase.replace("Dipsans", "kadariya"))

Numbers

Numbers are used for various numeric operations and math functions:

# Import all functions from the math module
from math import *  # Importing math module for additional math functions

# This script demonstrates various numeric operations and math functions

# Print the integer 20
print(20)

# Multiply 20 by 4 and print the result
print(20 * 4)

# Add 20 and 4 and print the result
print(20 + 4)

# Subtract 4 from 20 and print the result
print(20 - 4)

# Perform a more complex calculation and print the result
print(3 + (4 - 5))

# Calculate the remainder of 10 divided by 3 and print the result
print(10 % 3)

# Assign the value 100 to the variable _num
_num = 100

# Print the value of _num
print(_num)

# Convert _num to a string, concatenate with other strings, and print
print(str(_num) + " is my fav number")  # Converting int to string for concatenation

# Assign -10 to the variable new_num
new_num = -10

# Print the absolute value of new_num
print(abs(new_num))  # Absolute value

# Calculate 3 to the power of 2 and print the result
print(pow(3, 2))     # Power function

# Find the maximum of 2 and 3 and print the result
print(max(2, 3))     # Maximum

# Find the minimum of 2 and 3 and print the result
print(min(2, 3))     # Minimum

# Round 3.2 to the nearest integer and print the result
print(round(3.2))    # Rounding

# Round 3.7 to the nearest integer and print the result
print(round(3.7))

# Calculate the floor of 3.7 and print the result
print(floor(3.7))    # Floor function

# Calculate the ceiling of 3.7 and print the result
print(ceil(3.7))     # Ceiling function

# Calculate the square root of 36 and print the result
print(sqrt(36))      # Square root

Getting Input from Users

This program is used to show how to use the input() function to get user input:

# This script demonstrates how to get user input and use it in string concatenation

# Prompt the user to enter their name and store it in the 'name' variable
name = input("Enter your name : ")

# Prompt the user to enter their age and store it in the 'age' variable
age = input("Enter your age. : ")

# Print a greeting using the user's input, concatenating strings
print("hello " + name + " Youre age is " + age + " .")

Building a Basic Calculator

This program creates a simple calculator that adds two numbers:

# This script creates a basic calculator that adds two numbers

# Prompt the user to enter the first number and store it in 'num1'
num1 = input("Enter first number : ")

# Prompt the user to enter the second number and store it in 'num2'
num2 = input("Enter second number: ")

# Convert the input strings to integers and add them, storing the result
result = int(num1) + int(num2)

# Print the result of the addition
print(result)

First Madlibs

This program creates a simple Mad Libs game:

# This program is used to create a simple Mad Libs game.

# Prompt the user to enter an adjective and store it in 'adjective1'
adjective1 = input("Enter an adjective: ")

# Prompt the user to enter an animal and store it in 'animal'
animal = input("Enter an animal: ")

# Prompt the user to enter a verb and store it in 'verb'
verb = input("Enter a verb: ")

# Prompt the user to enter another adjective and store it in 'adjective2'
adjective2 = input("Enter another adjective: ")

# Print the first sentence of the Mad Libs story using string concatenation
print("I have a " + adjective1 + " " + animal + ".")

# Print the second sentence of the Mad Libs story
print("It likes to " + verb + " all day.")

# Print the third sentence of the Mad Libs story
print("My " + animal + " is so " + adjective2 + ".")

Lists

A list is a collection of items in Python that is ordered and changeable. Each item (or element) in a list has an index, starting from 0. Lists can contain items of different data types (like integers, strings, or even other lists).
A list is defined using square brackets [], with each item separated by a comma.

# This script demonstrates basic list operations

# Create a list of friends' names
friends = ["Roi", "alex", "jimmy", "joseph"]

# Print the entire list
print(friends)

# Print the first element of the list (index 0)
print(friends[0])

# Print the second element of the list (index 1)
print(friends[1])

# Print the third element of the list (index 2)
print(friends[2])

# Print the fourth element of the list (index 3)
print(friends[3])

# Print the last element of the list using negative indexing
print(friends[-1])

# Print a slice of the list from the second element to the end
print(friends[1:])

# Print a slice of the list from the second element to the third (exclusive)
print(friends[1:3])

# Change the second element of the list to "kim"
friends[1] = "kim"

# Print the modified list
print(friends)

List Functions

This script showcases various list methods:

# This script demonstrates various list functions and methods

# Create a list of numbers
numbers = [4, 6, 88, 3, 0, 34]

# Create a list of friends' names
friends = ["Roi", "alex", "jimmy", "joseph", "kevin", "tony", "jimmy"]

# Print both lists
print(numbers)
print(friends)

# Add all elements from 'numbers' to the end of 'friends'
friends.extend(numbers)

# Add "hulk" to the end of the 'friends' list
friends.append("hulk")

# Insert "mikey" at index 1 in the 'friends' list
friends.insert(1, "mikey")

# Remove the first occurrence of "Roi" from the 'friends' list
friends.remove("Roi")

# Print the index of "mikey" in the 'friends' list
print(friends.index("mikey"))

# Remove and print the last item in the 'friends' list
print(friends.pop())

# Print the current state of the 'friends' list
print(friends)

# Remove all elements from the 'friends' list
friends.clear()

# Print the empty 'friends' list
print(friends)

# Sort the 'numbers' list in ascending order
numbers.sort()

# Print the sorted 'numbers' list
print(numbers)

Tuples

A tuple is a collection of items in Python that is ordered but unchangeable (immutable). Once you create a tuple, you cannot add, remove, or change its elements. Like lists, tuples can contain items of different data types.
A tuple is defined using parentheses (), with each item separated by a comma.

# This script introduces tuples and their immutability

# Create a tuple with two elements
values = (3, 4)

# Print the entire tuple
print(values)

# Print the second element of the tuple (index 1)
print(values[1])

# The following line would cause an IndexError if uncommented:
# print(values[2])  # This would cause an IndexError

# The following line would cause a TypeError if uncommented:
# values[1] = 30    # This would cause a TypeError as tuples are immutable

# The following line would print the modified tuple if the previous line worked:
# print(values)

Functions

A function is a block of reusable code that performs a specific task. Functions can take inputs (called arguments), process them, and return an output. Functions help organize code, make it more modular, and avoid repetition.
n Python, a function is defined using the def keyword, followed by the function name, parentheses (), and a colon :. The code inside the function is indented.
This code demonstrates how to define and call functions:

# This script demonstrates how to define and call functions

# Define a function called 'greetings' that prints two lines
def greetings():
    print("HI, Welcome to programming world of python")
    print("keep learning")

# Print a statement before calling the function
print("this is first statement")

# Call the 'greetings' function
greetings()

# Print a statement after calling the function
print("this is last statement")

# Define a function 'add' that takes two parameters and prints their sum
def add(num1, num2):
    print(int(num1) + int(num2))

# Call the 'add' function with arguments 3 and 4
add(3, 4)

Return Statement

he return statement is used in a function to send back (or "return") a value to the caller. When return is executed, it ends the function, and the value specified after return is sent back to where the function was called.

This program shows how to use the return statement in functions:

# This script demonstrates the use of return statements in functions

# Define a function 'square' that returns the square of a number
def square(num):
    return num * num
    # Any code after the return statement won't execute

# Call the 'square' function with argument 2 and print the result
print(square(2))

# Call the 'square' function with argument 4 and print the result
print(square(4))

# Call the 'square' function with argument 3, store the result, then print it
result = square(3)
print(result)

If Statements

The if statement evaluates a condition (an expression that returns True or False).
If the condition is True, the block of code under the if statement is executed.
elif : Short for "else if," it allows you to check multiple conditions.
It is used when you have multiple conditions to evaluate, and you want to execute a block of code for the first True condition.
else: The else statement runs a block of code if none of the preceding if or elif conditions are True.

# This script demonstrates the use of if-elif-else statements

# Set boolean variables for conditions
is_boy = True
is_handsome = False

# Check conditions using if-elif-else statements
if is_boy and is_handsome:
    print("you are a boy & youre handsome")
    print("hehe")
elif is_boy and not (is_handsome):
    print("Youre a boy but sorry not handsome")
else:
    print("youre not a boy")

If Comparisons

This code demonstrates comparison operations in if statements:

# This script demonstrates comparison operations in if statements

# Define a function to find the maximum of three numbers
def max_numbers(num1, num2, num3):
    if num1 >= num2 and num1 >= num3:
        return num1
    elif num2 >= num1 and num2 >= num3:
        return num2
    else:
        return num3

# Test the max_numbers function with different inputs
print(max_numbers(20, 40, 60))
print(max_numbers(30, 14, 20))
print(max_numbers(3, 90, 10))

print("For min_number")

# Define a function to find the minimum of three numbers
def min_numbers(num1, num2, num3):
    if num1 <= num2 and num1 <= num3:
        return num1
    elif num2 <= num1 and num2 <= num3:
        return num2
    else:
        return num3

# Test the min_numbers function with different inputs
print(min_numbers(20, 40, 60))
print(min_numbers(30, 14, 20))
print(min_numbers(3, 90, 10))

Guessing Game 2

This script improves the guessing game with more features:

# This script improves the guessing game with more features

import random

# Generate a random number between 1 and 20
secret_number = random.randint(1, 20)

# Initialize the number of attempts and set a limit
attempts = 0
attempt_limit = 5

# Loop to allow the user to guess the number
while attempts < attempt_limit:
    guess = int(input(f"Guess the number (between 1 and 20). You have {attempt_limit - attempts} attempts left: "))
    if guess == secret_number:
        print("Congratulations! You guessed the number!")
        break
    elif guess < secret_number:
        print("Too low!")
    else:
        print("Too high!")
    attempts += 1

# If the user does not guess correctly within the attempt limit, reveal the number
if guess != secret_number:
    print(f"Sorry, the correct number was {secret_number}.")

For Loop

A for loop is used to iterate over a sequence of elements, such as a list, tuple, string, or range.
This code introduces the for loop:

# List of numbers
numbers = [1, 2, 3, 4, 5]

# Iterate over each number in the list
for number in numbers:
    # Print the current number
    print(number)

# Output:
# 1
# 2



# 3
# 4
# 5

# List of friends
friends = ["Roi", "alex", "jimmy", "joseph", "kevin", "tony", "jimmy"]

# Iterate over each friend in the list
for friend in friends:
    # Print the name of the current friend
    print(friend)

# Output:
# Roi
# alex
# jimmy
# joseph
# kevin
# tony
# jimmy

# Use range to generate numbers from 0 to 4
for num in range(5):
    print(num)

# Output:
# 0
# 1
# 2
# 3
# 4

Exponential Function

Exponential functions are mathematical functions where a constant base is raised to a variable exponent.
This script shows how to use the math.pow function:

# This script demonstrates the use of the exponential function
def exponentialFunction(base,power):
    result = 1
    for index in range(power):
        result = result * base
    return result

print(exponentialFunction(3,2))
print(exponentialFunction(4,2))
print(exponentialFunction(5,2))

#or you can power just by
print(2**3) #number *** power

2D List and For Loops

A 2D list (or 2D array) in Python is essentially a list of lists, where each sublist represents a row of the matrix. You can use nested for loops to iterate over elements in a 2D list. Here’s how you can work with 2D lists and for loops:

# This script demonstrates the use of 2D List and For Loops
# Define a 2D list (list of lists)
num_grid = [
    [1, 2, 3],  # Row 0: contains 1, 2, 3
    [4, 5, 6],  # Row 1: contains 4, 5, 6
    [7, 8, 9],  # Row 2: contains 7, 8, 9
    [0]         # Row 3: contains a single value 0
]

# Print specific elements in num_grid
print(num_grid[0][0])   # Print value in the zeroth row, zeroth column (value: 1)
print(num_grid[1][0])   # Print value in the first row, zeroth column (value: 4)
print(num_grid[2][2])   # Print value in the second row, second column (value: 9)


print("using nested for loops")
for row in num_grid :
   for col in row:
    print(col)

This is how we can use 2D List and For Loops.

The reference material for this blog was from Mike form FreeCodeCamp.org. Thank you.

SQL 101 📊 | A Guide to Basic Commands for Beginners 💡

Dipsan Kadariya — Thu, 29 Aug 2024 11:26:16 +0000

Introduction to SQL

What is SQL?

SQL (Structured Query Language) is a standard programming language used for managing and manipulating relational databases. It allows users to create, read, update, and delete data within a database. SQL provides a way to interact with databases using simple, declarative statements.

Why Learn SQL?

Learning SQL is essential for several reasons:

Data Management: SQL is the primary language for managing and querying relational databases, which are widely used in various applications.
Career Opportunities: Proficiency in SQL is a valuable skill for many IT and data-related roles, including database administrators, data analysts, and software developers.
Data Analysis: SQL enables you to perform complex data analysis and reporting tasks, making it easier to extract valuable insights from large datasets.
Versatility: SQL is used in many popular database systems, such as MySQL, PostgreSQL, and Microsoft SQL Server, making it a versatile skill across different platforms.

SQL Database and Table Operations Guide

Database Operations

Creating a Database

CREATE DATABASE FirstDB;

Note: FirstDB is the database name.

Using a Database

USE FirstDB;

Note: This selects the database for use.

Dropping a Database

DROP DATABASE FirstDB;

Note: This permanently deletes the database and all its contents.

Altering Database (Set to Read-Only)

ALTER DATABASE FirstDB READ ONLY = 1;

Note: This makes the database read-only, preventing any modifications.

Table Operations

Creating a Table

CREATE TABLE student (
    student_id INT,
    first_name VARCHAR(30),
    last_name VARCHAR(50),
    student_address VARCHAR(50),
    hourly_pay DECIMAL(5,2),
    student_date DATE
);

Note: This creates a table named 'student' with specified columns and data types.

Selecting All Data from a Table

SELECT * FROM student;

Note: This retrieves all rows and columns from the 'student' table.

Renaming a Table

RENAME TABLE student TO students;

Note: This changes the table name from 'student' to 'students'.

Altering Table Structure

Adding a New Column

ALTER TABLE students
ADD phone_number VARCHAR(15);

Note: This adds a new column 'phone_number' to the 'students' table.

Renaming a Column

ALTER TABLE students
CHANGE phone_number email VARCHAR(100);

Note: This changes the column name from 'phone_number' to 'email' and modifies its data type.

Modifying a Column's Data Type

ALTER TABLE students 
MODIFY COLUMN email VARCHAR(100);

Note: This changes the data type of the 'email' column to VARCHAR(100).

Changing a Column's Position

ALTER TABLE students
MODIFY email VARCHAR(100) AFTER last_name;

Note: This moves the 'email' column to be after the 'last_name' column.

ALTER TABLE students
MODIFY email VARCHAR(100) FIRST;

Note: This moves the 'email' column to be the first column in the table.

Dropping a Column

ALTER TABLE students
DROP COLUMN email;

Note: This permanently removes the 'email' column from the table.

Combining Multiple Operations

ALTER TABLE students
MODIFY email VARCHAR(100) AFTER last_name;
SELECT * FROM students;

Note: This changes the column position and then displays the new table structure in one operation.

Automate Git Commands with Shell Scripts 🚀 | Boost Your Workflow 📜

Dipsan Kadariya — Thu, 29 Aug 2024 10:36:46 +0000

Git Automation Script

Overview

This repository contains a PowerShell script designed to automate common Git operations.This script is designed to work globally across any project on your system.Once configured, the script simplifies the process of staging changes, committing with a message, and pushing updates to a remote repository.

Features

Automate Git Operations: Add all changes, commit with a message, and push to the remote repository with a single command.
Easy to Use: Run the script with a custom commit message to handle the Git workflow.

Setup Instructions

Follow these steps to set up and use the git-automation.ps1 script:

1. Create the Script

In a text editor, create a new file and save it as git-automation.ps1 (or any preferred name).

Add the following content to the file:

if ($args.Length -eq 0) {
    $COMMIT_MSG = "Auto-commit"
} else {
    $COMMIT_MSG = $args[0]
}

git add .
git commit -m $COMMIT_MSG
git push

2. Create a Directory for the Script

Open PowerShell and run:
```
mkdir C:\Scripts
```

Move your script to this directory:

move C:\Users\dipsa\Desktop\git-automation.ps1 C:\Scripts\

3. Add the Directory to PATH

Click "Environment Variables."
In "System variables," select Path and click "Edit."
Click "New" and add:
```
C:\Scripts
```
Click "OK" to save and close the dialog boxes.

4. Set Execution Policy

Open PowerShell and run:

Set-ExecutionPolicy RemoteSigned -Scope CurrentUser

Confirm by typing Y if prompted.

Usage

To use the script, run the following command from any project directory:


powershell
git-automation.ps1 "commit-message"

The OSI and TCP/IP Network Reference Models 🌐Explained 🛠️

Dipsan Kadariya — Thu, 29 Aug 2024 10:25:47 +0000

Introduction

Models that provide abstract representation of how data is transmitted over a network.
Each model is described by a so-called stack of layers, because each layer is dependent on its adjacent layers.
The OSI stack has 7 such layers and TCP/IP stack has 4.

The OSI Model

Stands for Open System Interconnection Model and was created by ISO (International Standards Organization) in the 1970's as a way to organize the efforts around the creation of new networking protocols, and to provide a common perspective for the existing network protocols at the time.
The OSI model has 7 layers, the bottom 4 layers are referred to as "media" layers and are used for performing tasks like data transport, addressing and data delivery. The top 3 layers are referred to as "Host" layers that use the media layers to enable communication between applications.

Breakdown of each layer:

Application Layer (Layer-7)
- Responsible for Human-Computer interaction.
- Handles services and programs that use the network to transmit and receive data, such as web browsers and email clients.
- Includes protocols like HTTP, FTP, SMTP, and DNS.
Presentation layer (Layer-6)
- Responsible for formatting and presentation of data.
- This layer handles things like compression/decompression, encryption/decryption, and encoding/decoding. Basically, ensuring the data is in a usable format for the next layer (Layer 5 if sending data, Layer 7 if receiving it).
Session layer (Layer-5)
- Responsible for Managing Communication between devices.
- This layer is responsible for setting up, maintaining, and tearing down sessions, in addition to performing functions like authentication and authorization. This ensures connections between clients are opened for as long as needed to transfer data, then torn down as soon as the transfer is complete.
Transport Layer (Layer-4)
- Responsible for Transporting data between hosts.
- This is the layer that handles ports, like HTTP at port 80, HTTPS at port 443. Being responsible for data delivery, this layer also handles breaking large data transfers into pieces for delivery, and then reconstituting them at the other end.
- There are two main protocols that are used at this layer: TCP and UDP.
  1. TCP (Transmission Control Protocol):
  2. Reliable, ensures data arrives correctly
  3. Checks for errors and lost packets
  4. Slower due to these checks
  5. UDP (User Datagram Protocol):
  6. Faster but less reliable
  7. Doesn't check for errors or lost packets
  8. Better for streaming media, gaming
Network Layer (Layer-3)
- This layer handles packet forwarding and routing between different networks, i.e., routing!
- Provides logical addressing (e.g., IP addresses).
- Manages traffic control and packet sequencing.
Data Link Layer (Layer-2)
- Responsible for providing node-to-node data transfer.
- Detects and possibly corrects errors from the Physical layer.
- Defines how data is formatted for transmission.
- Includes MAC (Media Access Control) addressing.
Physical Layer (Layer-1)
- Responsible for Transmitting data over a physical medium, such as a cable or over-the-air.
- Defines hardware specifications (cables, switches, network interface cards).
- Handles the transmission and reception of raw bit streams.

The TCP/IP Model

The TCP/IP model combines OSI layers 1 & 2 (Physical, Data Link) into a single layer 1 (Network Access).
Similarly, layers 5, 6, 7 (Application, Presentation, Session) are combined into a single layer 4 (Application).
It also renames the network layer (layer 3) to Internet.

Layer 1 - Network Access:

Combines OSI layers 1 & 2 (Physical and Data Link)
Handles the physical transmission of data and hardware-level protocols

Layer 2 - Internet:

Renamed from the OSI Network layer (layer 3)
Deals with logical addressing and routing

Layer 3 - Transport:

Equivalent to OSI layer 4 (Transport)
Manages end-to-end communication and data flow

Layer 4 - Application:

Combines OSI layers 5, 6, & 7 (Session, Presentation, and Application)
Handles high-level protocols and user interfaces

Notes:

The TCP/IP model is more compact than the OSI model.
It merges multiple OSI layers into single layers in some cases.
The "Internet" layer in TCP/IP is essentially a renamed "Network" layer from OSI.
This model is more closely aligned with how networks actually operate in practice.

Linux Basics 📂 | Essential Commands Every Beginner Should Know 📝

Dipsan Kadariya — Thu, 29 Aug 2024 10:08:19 +0000

Sudo su

"sudo" stands for "superuser do". It allows a permitted user to execute a command as the superuser or another user.
"su" stands for "switch user".
The hyphen (-) at the end is a shorthand for "-l" or "--login", which provides a full login shell.
(This is just for knowing, not necessary used for now)...just knowing is good.

pwd (Print Working Directory)

The pwd command shows your current location in the file system.

ls (List Directory Contents)

The ls command lists files and directories in your current location.

ls -la (Detailed List View)

Adding the -la options to ls provides a detailed, long-format list that includes hidden files, hidden files have "." in front of them.

cd (Change Directory)

Initially we were in /home/kali, when we write cd Desktop, path changes to /home/kali/Desktop.

cd .. (Reverse Directory)

This command helps to go back to the previous directory.
Let's say you are in Desktop directory but you want to go back to kali directory
You can do it by typing:

  cd ..

Mkdir (Make a new Subdirectory)

It is used to make a new folder. Let's make a new folder in the Desktop by first changing the directory to Desktop, and typing:

  mkdir filename

Example:

  mkdir helloworld

This will create a folder named helloworld in the Desktop.

touch

The primary purpose of the touch command is to update the access and/or modification date of a file or directory. However, it can also be used to create a file if it doesn't exist.
Let's create a file named file.txt in the helloworld folder. The first step would be changing the directory to the helloworld folder if not done, then typing:

  touch file.txt

cp (copy)

Let's say we want to copy the file.txt to a new folder named "newfolder", we can do it by first creating a newfolder in the desktop, now the desktop will have two folders, one being the helloworld folder which contains the file.txt and a new empty folder named "newfolder"
To copy the file.txt what we can do is, type:

  cp ~/Desktop/helloworld/file.txt ~/Desktop/newfolder/

Basically what we are doing is, taking the path of the file.txt i.e. ~/Desktop/helloworld/file.txt (which is inside helloworld folder in desktop) and copying it to where we want to copy it, i.e. ~/Desktop/newfolder/ (inside newfolder).

mv (move)

Let's say we want to move the file.txt from "helloworld" folder to "newfolder", so that helloworld folder has nothing inside, and only the newfolder will have file.txt inside it.
We can do it by typing:

mv ~/Desktop/helloworld/file.txt ~/Desktop/newfolder/

Here too, basically what we are doing is, taking the path of the file.txt i.e. ~/Desktop/helloworld/file.txt (which is inside helloworld folder in desktop) and moving it to where we want to move it, i.e. ~/Desktop/newfolder/ (inside newfolder).